Class OCCTW

Readonlyshapes

Readonlygeom

Readonlyfillets

Readonlytransforms

Readonlyoperations

Readonlybooleans

Readonlydimensions

ReadonlyshapeFix

Readonlyassembly

ReadonlybrepGraph

Readonlycorners

Readonlydraft

Readonlypath

Readonlysvg

shapeFacesToPolygonPoints

• shapeFacesToPolygonPoints(
      inputs: ShapeFacesToPolygonPointsDto<TopoDSShapePointer>,
  ): Promise<Point3[][]>

  Triangulates a shape and returns every triangle as three points, in one flat list over all faces.

  precision is the meshing tolerance in model units: smaller values follow curved surfaces more closely and give more triangles. adjustYtoZ swaps the Y and Z axes for tools that treat Z as up, and reversedPoints flips the winding of each triangle.

  Parameters

  • inputs: ShapeFacesToPolygonPointsDto<TopoDSShapePointer>

    The shape, the meshing precision and the axis and winding options

  Returns Promise<Point3[][]>

  One list of three points per triangle

  Example

  const triangles = await bitbybit.occt.shapeFacesToPolygonPoints({ shape: sphere, precision: 0.01, adjustYtoZ: false, reversedPoints: false });
  Copy

shapeToMesh

• shapeToMesh(
      inputs: ShapeToMeshDto<TopoDSShapePointer>,
  ): Promise<DecomposedMeshDto>

  Triangulates a shape into a mesh for drawing: one entry per face with its vertices, normals, UVs and triangle indexes, one per edge with its points, and the vertex points.

  precision is the meshing tolerance in model units; smaller values follow curved surfaces more closely and cost more triangles. adjustYtoZ swaps Y and Z. A null shape gives empty lists.

  Parameters

  • inputs: ShapeToMeshDto<TopoDSShapePointer>

    The shape, the meshing precision and the options

  Returns Promise<DecomposedMeshDto>

  The mesh as face, edge and point lists

  Example

  const mesh = await bitbybit.occt.shapeToMesh({ shape: sphere, precision: 0.01, adjustYtoZ: false });
  console.log(mesh.faceList.length, mesh.edgeList.length);
  Copy

shapesToMeshes

• shapesToMeshes(
      inputs: ShapesToMeshesDto<TopoDSShapePointer>,
  ): Promise<DecomposedMeshDto[]>

  Triangulates several shapes with the same settings, as shapeToMesh does for one.

  Parameters

  • inputs: ShapesToMeshesDto<TopoDSShapePointer>

    The shapes, the meshing precision and the options

  Returns Promise<DecomposedMeshDto[]>

  One mesh per shape, in the same order

  Example

  const meshes = await bitbybit.occt.shapesToMeshes({ shapes: [box, sphere], precision: 0.01, adjustYtoZ: false });
  Copy

deleteShape

• deleteShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<void>

  Frees the memory a shape holds inside the kernel; the shape cannot be used afterwards. Call it for intermediate results a script no longer needs, so long sessions do not run out of memory.

  Parameters

  • inputs: ShapeDto<TopoDSShapePointer>

    The shape to free

  Returns Promise<void>

  Example

  const box = await bitbybit.occt.shapes.solid.createBox({ width: 10, length: 10, height: 10, center: [0, 0, 0] });
  const rounded = await bitbybit.occt.fillets.filletEdges({ shape: box, radius: 1 });
  await bitbybit.occt.deleteShape({ shape: box });
  Copy

deleteShapes

• deleteShapes(inputs: ShapesDto<TopoDSShapePointer>): Promise<void>

  Frees the memory several shapes hold inside the kernel; they cannot be used afterwards. Call it for intermediate results a script no longer needs, so long sessions do not run out of memory.

  Parameters

  • inputs: ShapesDto<TopoDSShapePointer>

    The shapes to free

  Returns Promise<void>

  Example

  await bitbybit.occt.deleteShapes({ shapes: [box, cylinder] });
  Copy

cleanAllCache

• cleanAllCache(): Promise<void>

  Frees every shape the kernel holds at once, including the ones your variables still point to, so nothing created before can be used afterwards. Call it when starting over rather than between steps.

  Returns Promise<void>

  Example

  await bitbybit.occt.cleanAllCache();
  Copy