Class OCCT

constructor

• new OCCT(): Bit.OCCT

  Returns Bit.OCCT

ReadonlyoccWorkerManager

Readonlyshapes

Readonlygeom

Readonlyfillets

Readonlytransforms

Readonlyoperations

Readonlybooleans

Readonlydimensions

ReadonlyshapeFix

Readonlyassembly

ReadonlybrepGraph

Readonlycorners

Readonlydraft

Readonlyfeatures

Readonlyselect

Readonlyanalysis

Readonlyio

Readonlypath

Readonlysketch

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. isoCurvesU and isoCurvesV add each face's iso curves as polylines, and surfaceAnalysis a value per vertex. 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, with iso curves and analysis values when asked for

  Example

  const mesh = await bitbybit.occt.shapeToMesh({ shape: sphere, precision: 0.01, isoCurvesU: 4, isoCurvesV: 4, surfaceAnalysis: Bit.Inputs.OCCT.surfaceAnalysisEnum.gaussian });
  console.log(mesh.isoCurveList?.length, mesh.faceList[0]?.analysisValues);
  Copy

shapeToManifoldMesh

• shapeToManifoldMesh(
      inputs: ShapeToManifoldMeshDto<TopoDSShapePointer>,
  ): Promise<Bit.Inputs.OCCT.DecomposedManifoldMeshDto>

  Meshes a shape into one indexed triangle mesh whose faces share vertices where they meet, the form manifold.shapes.manifoldFromMesh takes, so an OCCT solid can carry on as a Manifold solid.

  Vertices are shared through the shape's own edges, not by matching coordinates, so a closed solid gives a closed mesh. precision is the meshing tolerance.

  Parameters

  • inputs: ShapeToManifoldMeshDto<TopoDSShapePointer>

    The shape and the meshing precision

  Returns Promise<Bit.Inputs.OCCT.DecomposedManifoldMeshDto>

  The mesh: three numbers per vertex and three vertex indexes per triangle

  Example

  const mesh = await bitbybit.occt.shapeToManifoldMesh({ shape: solid, precision: 0.01 });
  const manifold = await bitbybit.manifold.manifold.shapes.manifoldFromMesh({ mesh });
  Copy

shapesToMeshes

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

  Triangulates several shapes with the same settings, as shapeToMesh does for one, iso curves and surface analysis included.

  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, isoCurvesU: 2, isoCurvesV: 2 });
  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