Class OCCTOperations

The modeling operations that turn OpenCascade wires and faces into surfaces and solids and measure shapes: lofting through sections, extruding and revolving, sweeping profiles along paths, offsetting, thickening shells into solids, slicing and splitting, plus bounding boxes, bounding spheres and closest-point queries. Distances are in model units and angles in degrees; every operation returns a new shape. Booleans live in booleans, rounding in fillets.

Constructors

constructor

new OCCTOperations(): OCCTOperations
Returns OCCTOperations

closest pts

closestPointsBetweenTwoShapes

closestPointsBetweenTwoShapes(
inputs: ClosestPointsBetweenTwoShapesDto<TopoDSShapePointer>,
): Promise<Point3[]>
Finds the pair of points, one on each shape, that are closest to each other.

The distance between them is the gap between the shapes; it is 0 when they touch or overlap. Throws an error when no pair can be found.
Parameters
- inputs: ClosestPointsBetweenTwoShapesDto<TopoDSShapePointer>
  The two shapes
Returns Promise<Point3[]>
The point on the first shape and the point on the second
Example
```
const [onBox, onSphere] = await bitbybit.occt.operations.closestPointsBetweenTwoShapes({ shape1: box, shape2: sphere });
```
- Defined in bitbybit-docs.d.ts:41510

closestPointsOnShapeFromPoints

closestPointsOnShapeFromPoints(
inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>,
): Promise<Point3[]>
Finds, for each point in a list, the closest point on a shape.

A point already on the shape maps to itself. Useful for snapping points onto a surface.
Parameters
- inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>
  The shape and the points
Returns Promise<Point3[]>
One point on the shape per input point, in the same order
Example
```
const snapped = await bitbybit.occt.operations.closestPointsOnShapeFromPoints({ shape: sphere, points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41525

closestPointsOnShapesFromPoints

closestPointsOnShapesFromPoints(
inputs: ClosestPointsOnShapesFromPointsDto<TopoDSShapePointer>,
): Promise<Point3[]>
Finds the closest point on each of several shapes for each point in a list.

The result is one flat list: all the points for the first shape, in point order, then all the points for the second shape, and so on.
Parameters
- inputs: ClosestPointsOnShapesFromPointsDto<TopoDSShapePointer>
  The shapes and the points
Returns Promise<Point3[]>
The closest points, grouped shape by shape
Example
```
const snapped = await bitbybit.occt.operations.closestPointsOnShapesFromPoints({ shapes: [box, sphere], points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41541

divisions

splitShapeWithShapes

splitShapeWithShapes(
inputs: SplitDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer[]>
Cuts a shape into pieces with other shapes, the way a knife splits a loaf, without removing any material.

With nonDestructive true, the default, the inputs are left untouched and the result holds the pieces of every shape involved, the cutters included; with false only the pieces of shape come back. localFuzzyTolerance lets geometry that nearly touches count as touching.
Parameters
- inputs: SplitDto<TopoDSShapePointer>
  The shape to split, the shapes to split it with and the options
Returns Promise<TopoDSShapePointer[]>
The pieces
Example
```
const pieces = await bitbybit.occt.operations.splitShapeWithShapes({ shape: box, shapes: [cuttingPlane], localFuzzyTolerance: 1e-4, nonDestructive: false });
```
- Defined in bitbybit-docs.d.ts:41751

slice

slice(
inputs: Bit.Inputs.OCCT.SliceDto<TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer>
Cuts a solid into parallel slices along a direction, like a loaf of bread, every step model units from the bottom of the shape up.

Each slice is the flat section where a cutting plane meets the solid; they come back together in one compound. The shape must be or contain solids, or an error is thrown.
Parameters
- inputs: Bit.Inputs.OCCT.SliceDto<TopoDSShapePointer>
  The shape, the distance between slices and the slicing direction
Returns Promise<TopoDSCompoundPointer>
A compound of the section faces
Example
```
const layers = await bitbybit.occt.operations.slice({ shape: sphere, step: 0.5, direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:41973

sliceInStepPattern

sliceInStepPattern(
inputs: SliceInStepPatternDto<TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer>
Cuts a solid into parallel slices like slice, but with a repeating pattern of gaps between them, such as 0.1, 0.5, 0.1, 0.5.

The pattern is applied from the bottom of the shape up and repeats until the top is reached.
Parameters
- inputs: SliceInStepPatternDto<TopoDSShapePointer>
  The shape, the pattern of gaps and the slicing direction
Returns Promise<TopoDSCompoundPointer>
A compound of the section faces
Example
```
const layers = await bitbybit.occt.operations.sliceInStepPattern({ shape: sphere, steps: [0.1, 0.5], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:41989

extrusions

extrude

extrude(
inputs: Bit.Inputs.OCCT.ExtrudeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Sweeps a shape in a straight line along a vector, whose length is the distance: a face becomes a solid, a wire a shell, an edge a face.

The shape itself stays at the start of the extrusion; the vector is in model units, so [0, 10, 0] extrudes 10 units up.
Parameters
- inputs: Bit.Inputs.OCCT.ExtrudeDto<TopoDSShapePointer>
  The shape and the direction vector, whose length is the distance
Returns Promise<TopoDSShapePointer>
The extruded shape
Example
```
const disc = await bitbybit.occt.shapes.face.createCircleFace({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
const cylinder = await bitbybit.occt.operations.extrude({ shape: disc, direction: [0, 10, 0] });
```
- Defined in bitbybit-docs.d.ts:41720

extrudeShapes

extrudeShapes(
inputs: ExtrudeShapesDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer[]>
Sweeps several shapes along the same vector, as extrude does for one.
Parameters
- inputs: ExtrudeShapesDto<TopoDSShapePointer>
  The shapes and the direction vector, whose length is the distance
Returns Promise<TopoDSShapePointer[]>
The extruded shapes, in the same order
Example
```
const walls = await bitbybit.occt.operations.extrudeShapes({ shapes: [faceA, faceB], direction: [0, 10, 0] });
```
- Defined in bitbybit-docs.d.ts:41733

rotatedExtrude

rotatedExtrude(
inputs: RotationExtrudeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Extrudes a flat shape up along Y by height while twisting it by angle degrees about the Y axis, like a twisted column.

The shape should lie flat, as the profiles this package creates do. With makeSolid true, the default, a face profile gives a closed solid; a wire gives a twisted shell.
Parameters
- inputs: RotationExtrudeDto<TopoDSShapePointer>
  The profile shape, the height, the twist angle in degrees and whether to make a solid
Returns Promise<TopoDSShapePointer>
The twisted extrusion
Example
```
const square = await bitbybit.occt.shapes.face.createSquareFace({ size: 5, center: [0, 0, 0], direction: [0, 1, 0] });
const twisted = await bitbybit.occt.operations.rotatedExtrude({ shape: square, height: 20, angle: 90, makeSolid: true });
```
- Defined in bitbybit-docs.d.ts:41787

lofts

loft

loft(inputs: LoftDto<TopoDSWirePointer>): Promise<TopoDSShapePointer>
Builds a surface through a series of wires, like skin stretched over ribs: each wire is one section and the surface passes through them in list order.

Edges are accepted as single-edge wires. With makeSolid true and closed sections the result is capped into a solid; otherwise it is a shell. Sections match up best with equal edge counts.
Parameters
- inputs: LoftDto<TopoDSWirePointer>
  The section wires or edges, in order, and whether to make a solid
Returns Promise<TopoDSShapePointer>
The lofted shell or solid
Example
```
const bottom = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
const upper = await bitbybit.occt.shapes.wire.createSquareWire({ size: 6, center: [0, 10, 0], direction: [0, 1, 0] });
const vase = await bitbybit.occt.operations.loft({ shapes: [bottom, upper], makeSolid: true });
```
- Defined in bitbybit-docs.d.ts:41464

loftAdvanced

loftAdvanced(
inputs: LoftAdvancedDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
Builds a surface through a series of wires like loft, with control over how the skin is fitted.

straight makes ruled patches between sections instead of a smooth blend; closed loops the surface from the last section back to the first, and periodic makes that loop smooth by resampling the sections. startVertex and endVertex close the ends to points.
Parameters
- inputs: LoftAdvancedDto<TopoDSWirePointer>
  The section wires or edges, whether to make a solid, the closing and smoothing options and optional end points
Returns Promise<TopoDSShapePointer>
The lofted shell or solid
Example
```
const cone = await bitbybit.occt.operations.loftAdvanced({
    shapes: [circleBottom, circleMiddle],
    makeSolid: true,
    closed: false,
    periodic: false,
    straight: false,
    nrPeriodicSections: 10,
    useSmoothing: false,
    maxUDegree: 3,
    tolerance: 1e-7,
    parType: Bit.Inputs.OCCT.approxParametrizationTypeEnum.approxCentripetal,
    endVertex: [0, 20, 0],
});
```
- Defined in bitbybit-docs.d.ts:41494

measure

distancesToShapeFromPoints

distancesToShapeFromPoints(
inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>,
): Promise<number[]>
Measures how far each point in a list is from a shape, as the straight distance to the closest point on it, in model units.

The distance is to the shape's surface, so a point inside a solid still reports its distance to the skin.
Parameters
- inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>
  The shape and the points
Returns Promise<number[]>
One distance per point, in the same order
Example
```
const distances = await bitbybit.occt.operations.distancesToShapeFromPoints({ shape: sphere, points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41558

boundingBoxOfShape

boundingBoxOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<BoundingBoxPropsDto>
Computes the axis-aligned box that encloses a shape: its minimum and maximum corners, its center and its size along X, Y and Z.

On curved shapes the box can be a little larger than the shape itself, because the kernel bounds the control geometry rather than the exact surface.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<BoundingBoxPropsDto>
The box as min, max, center and size
Example
```
const box = await bitbybit.occt.operations.boundingBoxOfShape({ shape });
console.log(box.size, box.center);
```
- Defined in bitbybit-docs.d.ts:41576

boundingBoxMinOfShape

boundingBoxMinOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
Reads the minimum corner of a shape's axis-aligned bounding box, the point with the smallest X, Y and Z.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<Point3>
The minimum corner
Example
```
const min = await bitbybit.occt.operations.boundingBoxMinOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41590

boundingBoxMaxOfShape

boundingBoxMaxOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
Reads the maximum corner of a shape's axis-aligned bounding box, the point with the largest X, Y and Z.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<Point3>
The maximum corner
Example
```
const max = await bitbybit.occt.operations.boundingBoxMaxOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41604

boundingBoxCenterOfShape

boundingBoxCenterOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
Reads the center of a shape's axis-aligned bounding box, halfway between its two corners.

This is not the center of mass; shapes.solid.getSolidCenterOfMass and its siblings give that.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<Point3>
The center of the box
Example
```
const center = await bitbybit.occt.operations.boundingBoxCenterOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41620

boundingBoxSizeOfShape

boundingBoxSizeOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Vector3>
Reads the size of a shape's axis-aligned bounding box along X, Y and Z, in model units.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<Vector3>
The width, height and length of the box
Example
```
const size = await bitbybit.occt.operations.boundingBoxSizeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41633

boundingBoxShapeOfShape

boundingBoxShapeOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Builds the axis-aligned bounding box of a shape as a box solid, handy for drawing it or using it in a boolean.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<TopoDSShapePointer>
The box solid
Example
```
const boxSolid = await bitbybit.occt.operations.boundingBoxShapeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41647

boundingSphereOfShape

boundingSphereOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<BoundingSpherePropsDto>
Computes a sphere that encloses a shape: it is centered on the bounding box and reaches its corners, so it always contains the shape but is not the smallest possible sphere.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<BoundingSpherePropsDto>
The sphere as center and radius
Example
```
const sphere = await bitbybit.occt.operations.boundingSphereOfShape({ shape });
console.log(sphere.radius);
```
- Defined in bitbybit-docs.d.ts:41662

boundingSphereCenterOfShape

boundingSphereCenterOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<Point3>
Reads the center of a shape's bounding sphere, which is the center of its bounding box.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<Point3>
The center of the sphere
Example
```
const center = await bitbybit.occt.operations.boundingSphereCenterOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41675

boundingSphereRadiusOfShape

boundingSphereRadiusOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<number>
Reads the radius of a shape's bounding sphere, the distance from the bounding box center to its corner, in model units.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<number>
The radius
Example
```
const radius = await bitbybit.occt.operations.boundingSphereRadiusOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41689

boundingSphereShapeOfShape

boundingSphereShapeOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Builds the bounding sphere of a shape as a sphere solid.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<TopoDSShapePointer>
The sphere solid
Example
```
const sphereSolid = await bitbybit.occt.operations.boundingSphereShapeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41702

offsets

offset

offset(
inputs: Bit.Inputs.OCCT.OffsetDto<TopoDSShapePointer, TopoDSFacePointer>,
): Promise<TopoDSShapePointer>
Moves the boundary of a shape outward, or inward for a negative distance, by a fixed distance: a wire grows into a parallel outline, a face or solid into a bigger one.

A wire or edge is offset in its own plane, or on face when given; corners are rounded. A distance of 0 returns the shape as it is.
Parameters
- inputs: Bit.Inputs.OCCT.OffsetDto<TopoDSShapePointer, TopoDSFacePointer>
  The shape, an optional face to offset a wire on, the distance and the tolerance
Returns Promise<TopoDSShapePointer>
The offset shape
Example
```
const bigger = await bitbybit.occt.operations.offset({ shape: box, distance: 1, tolerance: 0.1 });
```
- Defined in bitbybit-docs.d.ts:41888

offsetAdv

offsetAdv(
inputs: OffsetAdvancedDto<TopoDSShapePointer, TopoDSFacePointer>,
): Promise<TopoDSShapePointer>
Offsets a shape like offset, with a choice of how corners are joined: arc rounds them, intersection extends the sides to a sharp corner, tangent keeps them tangent.

removeIntEdges drops the internal edges the offset can leave behind on a solid.
Parameters
- inputs: OffsetAdvancedDto<TopoDSShapePointer, TopoDSFacePointer>
  The shape, an optional face to offset a wire on, the distance, the tolerance, the corner join type and whether to remove internal edges
Returns Promise<TopoDSShapePointer>
The offset shape
Example
```
const sharper = await bitbybit.occt.operations.offsetAdv({
    shape: rectangleWire,
    distance: 1,
    tolerance: 0.1,
    joinType: Bit.Inputs.OCCT.joinTypeEnum.intersection,
    removeIntEdges: false,
});
```
- Defined in bitbybit-docs.d.ts:41910

makeThickSolidSimple

makeThickSolidSimple(
inputs: ThisckSolidSimpleDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Gives a face or shell a thickness, turning it into a solid slab or wall of the given offset.

A positive offset thickens toward the surface normal, a negative one the other way. Use it to turn a lofted or swept skin into something printable.
Parameters
- inputs: ThisckSolidSimpleDto<TopoDSShapePointer>
  The face or shell and the thickness
Returns Promise<TopoDSShapePointer>
The thick solid
Example
```
const wall = await bitbybit.occt.operations.makeThickSolidSimple({ shape: loftedShell, offset: 0.5 });
```
- Defined in bitbybit-docs.d.ts:41927

makeThickSolidByJoin

makeThickSolidByJoin(
inputs: ThickSolidByJoinDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Hollows a solid into a shell of the given wall thickness by removing the listed faces and offsetting the rest.

Removing the top face of a box, for instance, gives an open cup. offset is the wall thickness, negative to grow inward; joinType says how the offset walls meet at corners, the other flags go to the kernel's thick-solid builder.
Parameters
- inputs: ThickSolidByJoinDto<TopoDSShapePointer>
  The solid, the faces to remove, the wall thickness, the tolerance and the join options
Returns Promise<TopoDSShapePointer>
The hollowed solid
Example
```
const box = await bitbybit.occt.shapes.solid.createBox({ width: 10, length: 10, height: 10, center: [0, 0, 0] });
const faces = await bitbybit.occt.shapes.face.getFaces({ shape: box });
const cup = await bitbybit.occt.operations.makeThickSolidByJoin({
    shape: box,
    shapes: [faces[0]],
    offset: -1,
    tolerance: 1e-3,
    intersection: false,
    selfIntersection: false,
    joinType: Bit.Inputs.OCCT.joinTypeEnum.arc,
    removeIntEdges: false,
});
```
- Defined in bitbybit-docs.d.ts:41956

offset3DWire

offset3DWire(
inputs: Offset3DWireDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Offsets a wire that does not lie in one plane, by extruding it along direction, thickening the result and reading the offset edge back off it.

It works best on smooth wires; fillet sharp corners first with fillets.fillet3DWire. When the offset edges cannot be joined into one wire they come back as a list of edges.
Parameters
- inputs: Offset3DWireDto<TopoDSWirePointer>
  The wire, the offset distance and the direction to extrude along
Returns Promise<TopoDSWirePointer>
The offset wire, or the loose edges when they could not be joined
Example
```
const outer = await bitbybit.occt.operations.offset3DWire({ shape: smoothWire, offset: 1, direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:42006

pipeing

pipe

pipe(
inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Sweeps one or more profile shapes along a path wire and closes the result into a solid.

The profiles should be placed on the path; with several profiles the sweep blends from one to the next along the way.
Parameters
- inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSShapePointer>
  The path wire and the profile shapes placed on it
Returns Promise<TopoDSShapePointer>
The swept solid
Example
```
const tube = await bitbybit.occt.operations.pipe({ shape: pathWire, shapes: [profileAtStart] });
```
- Defined in bitbybit-docs.d.ts:41803

pipePolylineWireNGon

pipePolylineWireNGon(
inputs: PipePolygonWireNGonDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
Sweeps a regular polygon along a wire, giving a tube with nrCorners flat sides, for instance a hexagonal bar along a path.

The polygon of radius is placed at the start of the wire, perpendicular to it. makeSolid gives a solid instead of a shell, trihedronEnum chooses how the profile turns along the path, and forceApproxC1 smooths the result.
Parameters
- inputs: PipePolygonWireNGonDto<TopoDSWirePointer>
  The path wire, the polygon radius and corner count, and the sweep options
Returns Promise<TopoDSShapePointer>
The swept solid or shell
Example
```
const bar = await bitbybit.occt.operations.pipePolylineWireNGon({
    shape: pathWire,
    radius: 0.5,
    nrCorners: 6,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41828

pipeWiresCylindrical

pipeWiresCylindrical(
inputs: PipeWiresCylindricalDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer[]>
Sweeps a circle along each of several wires, as pipeWireCylindrical does for one, all with the same radius and options.
Parameters
- inputs: PipeWiresCylindricalDto<TopoDSWirePointer>
  The path wires, the radius and the sweep options
Returns Promise<TopoDSShapePointer[]>
One tube per wire, in the same order
Example
```
const tubes = await bitbybit.occt.operations.pipeWiresCylindrical({
    shapes: [pathA, pathB],
    radius: 0.5,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41848

pipeWireCylindrical

pipeWireCylindrical(
inputs: PipeWireCylindricalDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
Sweeps a circle along a wire, giving a round tube of the given radius that follows the path.

The circle is placed at the start of the wire, perpendicular to it. makeSolid gives a solid instead of a shell, trihedronEnum chooses how the profile turns as it follows the path, and forceApproxC1 smooths the result.
Parameters
- inputs: PipeWireCylindricalDto<TopoDSWirePointer>
  The path wire, the radius and the sweep options
Returns Promise<TopoDSShapePointer>
The tube as a solid or shell
Example
```
const tube = await bitbybit.occt.operations.pipeWireCylindrical({
    shape: pathWire,
    radius: 0.5,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41871

revolutions

revolve

revolve(
inputs: Bit.Inputs.OCCT.RevolveDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Spins a shape around an axis through the origin to sweep out a surface or solid: a face gives a solid, a wire a shell.

angle is in degrees; 360 or more gives a full turn. The axis runs along direction: a profile beside the Y axis revolved about it gives a vase. The profile must not cross it.
Parameters
- inputs: Bit.Inputs.OCCT.RevolveDto<TopoDSShapePointer>
  The profile shape, the angle in degrees, the axis direction and whether to copy the geometry
Returns Promise<TopoDSShapePointer>
The revolved shape
Example
```
const profile = await bitbybit.occt.shapes.wire.createPolylineWire({ points: [[2, 0, 0], [4, 0, 0], [3, 10, 0], [2, 12, 0]] });
const vase = await bitbybit.occt.operations.revolve({ shape: profile, angle: 360, direction: [0, 1, 0], copy: false });
```
- Defined in bitbybit-docs.d.ts:41769

Class OCCTOperations

Index

Constructors

closest pts

divisions

extrusions

lofts

measure

offsets

pipeing

revolutions

Constructors

constructor

Returns OCCTOperations

closest pts

closestPointsBetweenTwoShapes

Parameters

Returns Promise<Point3[]>

Example

closestPointsOnShapeFromPoints

Parameters

Returns Promise<Point3[]>

Example

closestPointsOnShapesFromPoints

Parameters

Returns Promise<Point3[]>

Example

divisions

splitShapeWithShapes

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

slice

Parameters

Returns Promise<TopoDSCompoundPointer>

Example

sliceInStepPattern

Parameters

Returns Promise<TopoDSCompoundPointer>

Example

extrusions

extrude

Parameters

Returns Promise<TopoDSShapePointer>

Example

extrudeShapes

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

rotatedExtrude

Parameters

Returns Promise<TopoDSShapePointer>

Example

lofts

loft

Parameters

Returns Promise<TopoDSShapePointer>

Example

loftAdvanced

Parameters

Returns Promise<TopoDSShapePointer>

Example

measure

distancesToShapeFromPoints

Parameters

Returns Promise<number[]>

Example

boundingBoxOfShape

Parameters

Returns Promise<BoundingBoxPropsDto>

Example

boundingBoxMinOfShape

Parameters

Returns Promise<Point3>

Example

boundingBoxMaxOfShape

Parameters

Returns Promise<Point3>

Example

boundingBoxCenterOfShape