Documentação

CAD exato

Analise geometria exata, exporte STEP e inspecione relações de montagem a partir de instantâneos de cena ou desenhos salvos.

Traduzido automaticamente do inglês. Ver o original em inglês

Área de testes

Envie essas solicitações para seu próprio sidecar em execução. Os valores permanecem neste navegador.

Não conectado

URL base Token do portador opcional Token de sessão opcional

Como isso funciona

O sidecar escuta em uma porta de loopback escolhida na inicialização e a imprime em seu ready linha; use esse URL e o CADCAMFUN_TOKEN foi iniciado. As solicitações vão direto desta página para esse endereço.

O sidecar envia cabeçalhos CORS apenas para as origens Tauri e para http://localhost ou http://127.0.0.1 em qualquer porto. Nos documentos hospedados, o navegador bloqueia a resposta, então execute os documentos localmente (bun run dev em packages/web) para usar o playground ou copie a solicitação como curl. Para experimentar sem tocar em dados reais, inicie o sidecar com CADCAMFUN_DATA_DIR apontado para um diretório descartável - veja o passo a passo da API.

Operações

5 endpoints no cadExact grupo, gerado a partir do próprio sidecar Documento OpenAPI. As operações protegidas levam Authorization: Bearer $CADCAMFUN_TOKEN; ver autenticação. Comportamento e limites estão em o guia do subsistema.

publicar	/api/cad/exact/analyze	cadExact.analyze
publicar	/api/cad/exact/step	cadExact.step
publicar	/api/cad/exact/assembly	cadExact.assembly
publicar	/api/cad/exact/setups	cadExact.setups
publicar	/api/cad/exact/hole	cadExact.hole

Operações CAD exatas em 3D Arraste para orbitar · role para ampliar · arraste com o botão direito para deslocar

Um bloco por operação (5), empilhado por seção de recursos desta página e colorido por método: verde GET, laranja POST, azul PUT, violeta PATCH, vermelho DELETE. Gerado a partir do documento OpenAPI em tempo de construção.

/api/cad/exact

publicar /api/cad/exact/analyze # cadExact.analyze

Requer Authorization: Bearer <token>.

Corpo da solicitação · obrigatório · aplicação/json

{
  elements?: object[]
  drawingId?: string
  ids?: string[]
  machining?: boolean
}

Respostas

200 objeto application/json

{
  parts: Array<{
    id: string
    name: string
    valid: boolean
    issues: string[]
    volume: number
    area: number
    centroid: {
      x: number
      y: number
      z: number
    }
    bounds: {
      min: {
        x: number
        y: number
        z: number
      }
      max: {
        x: number
        y: number
        z: number
      }
    }
    faces: number
    edges: number
    vertices: number
    surfaces: {
      [key: string]: number
    }
    throughHoles?: number
    holes: Array<{
      entry: {
        x: number
        y: number
        z: number
      }
      direction: {
        x: number
        y: number
        z: number
      }
      diameter: number
      depth: number
      form: "simple" | "counterbore" | "countersink"
      bottom: "through" | "flat" | "drill-point"
      headDiameter?: number
      headDepth?: number
    }>
    machining: {
      prismatic: true
      holes: number
      pockets: number
      outlines: number
      top: number
      bottom: number
      islands?: number
      sideHoles?: number
      hiddenFaces?: number
    } | {
      prismatic: false
      reason: string
    }
    bosses: Array<{
      diameter: number
      length: number
      free: "near" | "far" | "both" | "none"
      origin: {
        x: number
        y: number
        z: number
      }
      axis: {
        x: number
        y: number
        z: number
      }
    }>
    nurbsFaces?: Array<{
      face: number
      normal: {
        x: number
        y: number
        z: number
      }
      spread: number
      trimmed: boolean
    }>
    fillets?: Array<{
      face: number
      kind: "cylinder" | "torus"
      radius: number
      convex: boolean
      length: number
    }>
    swarfWalls?: Array<{
      face: number
      kind: "plane" | "cone" | "cylinder"
      near: {
        x: number
        y: number
        z: number
      }
      height: number
      lean: number
      concaveRadius?: number
    }>
    faceNames?: string[]
    repair?: {
      verticesWelded: number
      edgesWelded: number
      collapsedUses: number
      validAfter: boolean
      issuesAfter: string[]
    }
  }>
  skipped: Array<{
    id: string
    name: string
    reason: string
  }>
  totals: {
    parts: number
    volume: number
    area: number
  }
}

400 BadRequestEncoded application/json

BadRequestEncoded

401 UnauthorizedEncoded application/json

UnauthorizedEncoded

403 ForbiddenEncoded application/json

ForbiddenEncoded

404 NotFoundEncoded application/json

NotFoundEncoded

500 InternalErrorEncoded application/json

InternalErrorEncoded

Exemplo de SDK

cadExact.analyze

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// CadExactAnalyzeInput
const result = await client.cadExact.analyze({
  elements: [
    {}
  ],
  drawingId: "",
  ids: [
    ""
  ],
  machining: false
})

curl

POST /api/cad/exact/analisar

curl --request POST "${CADCAMFUN_URL}/api/cad/exact/analyze" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

Experimente

Solicitar corpo application/json

publicar /api/cad/exact/step # cadExact.step

Requer Authorization: Bearer <token>.

Corpo da solicitação · obrigatório · aplicação/json

{
  elements?: object[]
  drawingId?: string
  ids?: string[]
  faceted?: boolean
  author?: string
}

Respostas

200 objeto application/json

{
  step?: string
  parts: Array<{
    id: string
    name: string
    exact: boolean
    faces: number
    valid: boolean
    note?: string
  }>
  skipped: Array<{
    id: string
    name: string
    reason: string
  }>
}

400 BadRequestEncoded application/json

BadRequestEncoded

401 UnauthorizedEncoded application/json

UnauthorizedEncoded

403 ForbiddenEncoded application/json

ForbiddenEncoded

404 NotFoundEncoded application/json

NotFoundEncoded

500 InternalErrorEncoded application/json

InternalErrorEncoded

Exemplo de SDK

cadExact.step

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// CadExactStepInput
const result = await client.cadExact.step({
  elements: [
    {}
  ],
  drawingId: "",
  ids: [
    ""
  ],
  faceted: false,
  author: ""
})

curl

POST /api/cad/exact/step

curl --request POST "${CADCAMFUN_URL}/api/cad/exact/step" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

Experimente

Solicitar corpo application/json

publicar /api/cad/exact/assembly # cadExact.assembly

Requer Authorization: Bearer <token>.

Corpo da solicitação · obrigatório · aplicação/json

{
  elements?: object[]
  drawingId?: string
  washers?: boolean
}

Respostas

200 objeto application/json

{
  parts: number
  interference: {
    clashes: Array<{
      a: string
      b: string
      aName: string
      bName: string
      volume: number
      centroid: {
        x: number
        y: number
        z: number
      }
    }>
    expected: Array<{
      a: string
      b: string
      aName: string
      bName: string
      volume: number
      note: string
    }>
    touching: Array<{
      a: string
      b: string
    }>
    undetermined: Array<{
      a: string
      b: string
      reason: string
    }>
    checked: number
  }
  clearance?: Array<{
    a: string
    b: string
    aName: string
    bName: string
    distance: number
    overlap: boolean
  }>
  bom: Array<{
    item: number
    name: string
    designation?: string
    material?: string
    quantity: number
    volume: number
    mass?: number
    parts: string[]
  }>
  joints: Array<{
    parent: string
    child: string
    parentName: string
    childName: string
    kind: "revolute" | "fixed"
    origin: {
      x: number
      y: number
      z: number
    }
    axis: {
      x: number
      y: number
      z: number
    }
    axes: number
  }>
  fasteners: {
    plans: Array<{
      id: string
      size: string
      threadName: string
      designation: string
      length: number
      seat: {
        x: number
        y: number
        z: number
      }
      direction: {
        x: number
        y: number
        z: number
      }
      bodies: string[]
      tapped?: string
      grip: number
      engagement?: number
      headWasher?: {
        designation: string
        inner: number
        outer: number
        thickness: number
      }
      nutWasher?: {
        designation: string
        inner: number
        outer: number
        thickness: number
      }
      nutWasherAt?: {
        x: number
        y: number
        z: number
      }
      nut?: {
        designation: string
        across: number
        height: number
        at: {
          x: number
          y: number
          z: number
        }
      }
      warnings: string[]
    }>
    unfastened: Array<{
      bodies: string[]
      at: {
        x: number
        y: number
        z: number
      }
      reason: string
    }>
    existing: number
  }
  skipped: Array<{
    id: string
    name: string
    reason: string
  }>
}

400 BadRequestEncoded application/json

BadRequestEncoded

401 UnauthorizedEncoded application/json

UnauthorizedEncoded

403 ForbiddenEncoded application/json

ForbiddenEncoded

404 NotFoundEncoded application/json

NotFoundEncoded

500 InternalErrorEncoded application/json

InternalErrorEncoded

Exemplo de SDK

cadExact.assembly

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// CadExactAssemblyInput
const result = await client.cadExact.assembly({
  elements: [
    {}
  ],
  drawingId: "",
  washers: false
})

curl

POST /api/cad/exact/assembly

curl --request POST "${CADCAMFUN_URL}/api/cad/exact/assembly" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

Experimente

Solicitar corpo application/json

publicar /api/cad/exact/setups # cadExact.setups

Requer Authorization: Bearer <token>.

Corpo da solicitação · obrigatório · aplicação/json

{
  elements?: object[]
  drawingId?: string
  ids?: string[]
  fixture?: "bottom" | "none"
  allowed?: Array<"+Z" | "-Z" | "+X" | "-X" | "+Y" | "-Y">
}

Respostas

200 objeto application/json

{
  parts: Array<{
    id: string
    name: string
    plan: {
      setups: Array<{
        orientation: "+Z" | "-Z" | "+X" | "-X" | "+Y" | "-Y"
        faces: number[]
        area: number
        share: number
        holes: Array<{
          entry: {
            x: number
            y: number
            z: number
          }
          direction: {
            x: number
            y: number
            z: number
          }
          diameter: number
          depth: number
          form: "simple" | "counterbore" | "countersink"
        }>
        prismatic: {
          ok: true
          holes: number
          pockets: number
          outlines: number
        } | {
          ok: false
          reason: string
        }
      }>
      uncovered: Array<{
        face: number
        kind: string
        area: number
        reason: string
      }>
      held: Array<{
        face: number
        kind: string
        area: number
      }>
      indexed: Array<{
        entry: {
          x: number
          y: number
          z: number
        }
        direction: {
          x: number
          y: number
          z: number
        }
        diameter: number
        depth: number
        form: "simple" | "counterbore" | "countersink"
      }>
      reach: Array<{
        orientation: "+Z" | "-Z" | "+X" | "-X" | "+Y" | "-Y"
        faces: number
        area: number
        share: number
      }>
      faces: number
      area: number
      notes: string[]
    }
  }>
  skipped: Array<{
    id: string
    name: string
    reason: string
  }>
}

400 BadRequestEncoded application/json

BadRequestEncoded

401 UnauthorizedEncoded application/json

UnauthorizedEncoded

403 ForbiddenEncoded application/json

ForbiddenEncoded

404 NotFoundEncoded application/json

NotFoundEncoded

500 InternalErrorEncoded application/json

InternalErrorEncoded

buscar exemplo

cadExact.setups

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/cad/exact/setups`, {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl

POST /api/cad/exact/setups

curl --request POST "${CADCAMFUN_URL}/api/cad/exact/setups" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

Experimente

Solicitar corpo application/json

publicar /api/cad/exact/hole # cadExact.hole

Requer Authorization: Bearer <token>.

Corpo da solicitação · obrigatório · aplicação/json

{
  elements?: object[]
  drawingId?: string
  id: string
  hole?: number
  boss?: number
  fillet?: number
  nurbs?: number
  distance?: number
  direction?: {
    x: number
    y: number
    z: number
  }
  mode?: "move" | "offset" | "draft"
  angle?: number
  neutral?: number
  pull?: {
    x: number
    y: number
    z: number
  }
  tolerance?: number
  radius?: number
  diameter?: number
  taper?: number
  fill?: boolean
}

Respostas

200 objeto | objeto | objeto | objeto | objeto application/json

{
  ok: true
  id: string
  name: string
  hole: number
  holes: number
  before: {
    diameter: number
    depth: number
    form: "simple" | "counterbore" | "countersink"
  }
  edit: {
    kind: "resize"
    diameter: number
    taper?: number
  } | {
    kind: "fill"
  }
  volume: number
  originalVolume: number
  volumeChange: number
  faces: number
  valid: boolean
} | {
  ok: true
  id: string
  name: string
  boss: number
  bosses: number
  before: {
    diameter: number
    length: number
  }
  diameter: number
  taper?: number
  volume: number
  originalVolume: number
  volumeChange: number
  faces: number
  valid: boolean
} | {
  ok: true
  id: string
  name: string
  fillet: number
  fillets: number
  before: {
    radius: number
    convex: boolean
  }
  radius: number
  volume: number
  originalVolume: number
  volumeChange: number
  faces: number
  valid: boolean
} | {
  ok: true
  id: string
  name: string
  nurbs: number
  nurbsFaces: number
  mode: "move" | "offset" | "draft"
  before: {
    normal: {
      x: number
      y: number
      z: number
    }
    spread: number
  }
  distance?: number
  direction?: {
    x: number
    y: number
    z: number
  }
  angle?: number
  approximate?: {
    deviation: number
  }
  volume: number
  originalVolume: number
  volumeChange: number
  faces: number
  valid: boolean
} | {
  ok: false
  error: string
}

400 BadRequestEncoded application/json

BadRequestEncoded

401 UnauthorizedEncoded application/json

UnauthorizedEncoded

403 ForbiddenEncoded application/json

ForbiddenEncoded

404 NotFoundEncoded application/json

NotFoundEncoded

500 InternalErrorEncoded application/json

InternalErrorEncoded

buscar exemplo

cadExact.hole

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/cad/exact/hole`, {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl

POST /api/cad/exact/hole

curl --request POST "${CADCAMFUN_URL}/api/cad/exact/hole" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

Experimente

Solicitar corpo application/json

Esquemas

Esquemas nomeados acessíveis a partir dos parâmetros, corpos e respostas deste grupo. UM ? marca um campo opcional; | null marca um campo que pode estar presente com um valor nulo.

BadRequestEncoded

{
  _tag: "BadRequest"
  message: string
}

ForbiddenEncoded

{
  _tag: "Forbidden"
  message: string
}

InternalErrorEncoded

{
  _tag: "InternalError"
  message: string
}

NotFoundEncoded

{
  _tag: "NotFound"
  message: string
}

UnauthorizedEncoded

{
  _tag: "Unauthorized"
  message: string
}

Chamando este grupo

Os IDs de operação têm o formato cadExact.<name>. O Promise SDK gerado (@cadcamfun/api/sdk) expõe a maioria deles como client.<namespace>.<method>(input), onde input é um objeto plano de parâmetros de caminho e campos de corpo; o exemplo do SDK de cada cartão mostra o acessador e o tipo de entrada exatos. Multipart uploads, respostas binárias ou JavaScript e webhooks brutos não são gerados; essas cartas mostram fetch em vez disso.

Erros do Promise SDK

import { CadCam, ClientError } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

try {
  await client.projects.list()
} catch (error) {
  if (error instanceof ClientError) {
    // Transport | UnexpectedStatus | UnsupportedContentType | MalformedResponse | SseEventTooLarge
  } else {
    // a declared error body: switch on error._tag
  }
}

Solução de problemas

Sintoma	Causa provável	Consertar
401 em cada chamada	Token de um lançamento anterior ou ausente `Bearer` prefixo	Enviar `Authorization: Bearer <token>` com o token com o qual o sidecar foi iniciado.
400 antes que algo aconteça	O corpo ou parâmetro não corresponde ao esquema	Compare a carga útil com o esquema de solicitação no cartão.
403 ou 404 em um registro que você vê em outro lugar	A conta atuante difere	Envie o certo `x-session-token`ou use o perfil local que possui o registro.
409	Estado conflitante, como um nome duplicado ou um cabeçalho de ramificação obsoleto	Leia novamente o recurso e tente novamente com os dados atuais.
Tente dizer "bloqueado pelo CORS"	Os documentos são veiculados a partir de uma origem sem loopback	Execute os documentos localmente ou copie a solicitação como curl.
Ligação recusada	O sidecar foi reiniciado em uma nova porta	Leia a porta do novo `ready` linha.