Documentation

CAO exacte

Analysez la géométrie exacte, exportez STEP et inspectez les relations d'assemblage à partir d'instantanés de scène ou de dessins enregistrés.

Traduit automatiquement de l'anglais. Voir l'original en anglais

Playground

Envoyez ces demandes à votre propre sidecar en cours d’exécution. Les valeurs restent dans ce navigateur.

Non connecté

URL de base Jeton du porteur facultatif Jeton de session facultatif

Comment ça marche

Le sidecar écoute sur un port de bouclage choisi au démarrage et l'imprime dans son ready doubler; utilisez cette URL et le CADCAMFUN_TOKEN ça a commencé avec. Les demandes vont directement de cette page à cette adresse.

Le sidecar envoie les en-têtes CORS uniquement aux origines Tauri et à http://localhost ou http://127.0.0.1 sur n'importe quel port. À partir des documents hébergés, le navigateur bloque la réponse, exécutez donc les documents localement (bun run dev dans packages/web) pour utiliser le terrain de jeu, ou copiez la requête sous forme curl. Pour expérimenter sans toucher aux données réelles, démarrez le sidecar avec CADCAMFUN_DATA_DIR pointé vers un répertoire jetable — voir la procédure pas à pas de l'API.

Opérations

5 endpoints dans le cadExact groupe, généré à partir du propre sidecar Document OpenAPI. Les opérations protégées prennent Authorization: Bearer $CADCAMFUN_TOKEN; voir authentification. Le comportement et les limites sont en place le guide du sous-système.

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

Opérations CAO exactes en 3D Faites glisser vers l'orbite · faites défiler pour zoomer · faites glisser vers la droite pour effectuer un panoramique

Un bloc par opération (5), empilé par section de ressources de cette page et coloré par méthode : vert GET, orange POST, bleu PUT, violet PATCH, rouge DELETE. Généré à partir du document OpenAPI au moment de la construction.

/api/cad/exact

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

Nécessite Authorization: Bearer <token>.

Corps de la requête · requis · application/json

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

Réponses

200 objet 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

Exemple 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/analyser

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

Essayez-le

Corps de la demande application/json

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

Nécessite Authorization: Bearer <token>.

Corps de la requête · requis · application/json

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

Réponses

200 objet 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

Exemple 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/étape

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

Essayez-le

Corps de la demande application/json

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

Nécessite Authorization: Bearer <token>.

Corps de la requête · requis · application/json

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

Réponses

200 objet 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

Exemple 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

Essayez-le

Corps de la demande application/json

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

Nécessite Authorization: Bearer <token>.

Corps de la requête · requis · application/json

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

Réponses

200 objet 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

récupérer un exemple

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

Essayez-le

Corps de la demande application/json

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

Nécessite Authorization: Bearer <token>.

Corps de la requête · requis · application/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
}

Réponses

200 objet | objet | objet | objet | objet 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

récupérer un exemple

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

Essayez-le

Corps de la demande application/json

Schémas

Schémas nommés accessibles à partir des paramètres, des corps et des réponses de ce groupe. UN ? marque un champ facultatif ; | null marque un champ qui peut être présent avec une valeur nulle.

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
}

Appel à ce groupe

Les identifiants d'opération ont la forme cadExact.<name>. Le SDK Promise généré (@cadcamfun/api/sdk) expose la plupart d'entre eux comme client.<namespace>.<method>(input), où input est un objet plat composé de paramètres de chemin et de champs de corps ; L'exemple de SDK de chaque carte montre l'accesseur exact et le type d'entrée. Les téléchargements en plusieurs parties, les réponses binaires ou JavaScript et les webhooks bruts ne sont pas générés ; ces cartes montrent fetch à la place.

Erreurs du SDK Promise

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
  }
}

Dépannage

Symptôme	Cause probable	Réparer
401 à chaque appel	Jeton d'un lancement précédent, ou manquant `Bearer` préfixe	Envoyer `Authorization: Bearer <token>` avec le jeton avec lequel le sidecar a été démarré.
400 avant que quoi que ce soit se produise	Le corps ou le paramètre ne correspond pas au schéma	Comparez la charge utile avec le schéma de demande sur la carte.
403 ou 404 sur un enregistrement visible ailleurs	Le compte intérimaire diffère	Envoyez le droit `x-session-token`, ou utilisez le profil local propriétaire de l'enregistrement.
409	État conflictuel, tel qu'un nom en double ou un chef de succursale obsolète	Relisez la ressource et réessayez avec les données actuelles.
Essayez, il est écrit "bloqué par CORS"	Les documents sont servis à partir d'une origine sans bouclage	Exécutez la documentation localement ou copiez la demande en tant que curl.
Connexion rejetée	Le sidecar a redémarré sur un nouveau port	Lire le port du nouveau `ready` ligne.