Class OCCTEdge

Edges in OpenCascade: single curves between two vertices, straight, circular, elliptical or free-form. Build them from points and lines, as arcs, circles and ellipses, or as lines and circles tangent to other curves in a plane; cut, lengthen and blend them; read them back as points, lengths, tangents and centers; and pick edges out of any shape. Edges join end to end into wires, which shapes.wire handles. Parameters along an edge run from 0 at its start to 1 at its end; angles are in degrees.

Index

Constructors

constructor

new OCCTEdge(): OCCTEdge
Returns OCCTEdge

constraint

constraintTanLinesFromTwoPtsToCircle

constraintTanLinesFromTwoPtsToCircle(
inputs: ConstraintTanLinesFromTwoPtsToCircleDto<TopoDSEdgePointer>,
): Promise<TopoDSShapePointer[]>
Draws the straight lines from two points that just touch a circle, one tangent line from each point.

positionResult keeps the solutions on one side of the circle or all of them, and circleRemainder adds the piece of the circle between the touching points. It is replaced by linesTangentToTwo, which takes curves other than circles too.
Parameters
- inputs: ConstraintTanLinesFromTwoPtsToCircleDto<TopoDSEdgePointer>
  The circle edge, the two points, the tolerance and which solutions to keep
Returns Promise<TopoDSShapePointer[]>
The tangent lines, and the circle piece when asked for
Deprecated
Use linesTangentToTwo once per point, with the point as a vertex (shapes.vertex.vertexFromPoint) and a frame in the circle's plane; it gives no circle piece. It is removed in a future major version and works until then.
Example
```
const tangents = await bitbybit.occt.shapes.edge.constraintTanLinesFromTwoPtsToCircle({
    circle,
    point1: [20, 0, 0],
    point2: [-20, 0, 0],
    tolerance: 1e-7,
    positionResult: Bit.Inputs.OCCT.positionResultEnum.all,
    circleRemainder: Bit.Inputs.OCCT.circleInclusionEnum.none,
});
```
- Defined in bitbybit-docs.d.ts:48923

constraintTanLinesFromPtToCircle

constraintTanLinesFromPtToCircle(
inputs: ConstraintTanLinesFromPtToCircleDto<TopoDSEdgePointer>,
): Promise<TopoDSShapePointer[]>
Draws the two straight lines from a point that just touch a circle.

positionResult keeps the solution on one side of the circle or both, and circleRemainder adds the piece of the circle between the touching points. It is replaced by linesTangentToTwo, which takes curves other than circles too.
Parameters
- inputs: ConstraintTanLinesFromPtToCircleDto<TopoDSEdgePointer>
  The circle edge, the point, the tolerance and which solutions to keep
Returns Promise<TopoDSShapePointer[]>
The tangent lines, and the circle piece when asked for
Deprecated
Use linesTangentToTwo with the point as a vertex (shapes.vertex.vertexFromPoint) and a frame in the circle's plane; it gives no circle piece. It is removed in a future major version and works until then.
Example
```
const tangents = await bitbybit.occt.shapes.edge.constraintTanLinesFromPtToCircle({
    circle,
    point: [20, 0, 0],
    tolerance: 1e-7,
    positionResult: Bit.Inputs.OCCT.positionResultEnum.all,
    circleRemainder: Bit.Inputs.OCCT.circleInclusionEnum.none,
});
```
- Defined in bitbybit-docs.d.ts:48948

constraintTanLinesOnTwoCircles

constraintTanLinesOnTwoCircles(
inputs: ConstraintTanLinesOnTwoCirclesDto<TopoDSEdgePointer>,
): Promise<TopoDSShapePointer[]>
Draws the straight lines that just touch two circles at once, like a belt around two pulleys.

positionResult keeps the lines on one side or all of them, and circleRemainders adds the outside or inside pieces of the circles between the touching points, which completes the belt shape. It is replaced by linesTangentToTwo, which takes curves other than circles too.
Parameters
- inputs: ConstraintTanLinesOnTwoCirclesDto<TopoDSEdgePointer>
  The two circle edges, the tolerance and which solutions and circle pieces to keep
Returns Promise<TopoDSShapePointer[]>
The tangent lines, and the circle pieces when asked for
Deprecated
Use linesTangentToTwo with the two circles and a frame in their plane; it gives no circle pieces. It is removed in a future major version and works until then.
Example
```
const belt = await bitbybit.occt.shapes.edge.constraintTanLinesOnTwoCircles({
    circle1,
    circle2,
    tolerance: 1e-7,
    positionResult: Bit.Inputs.OCCT.positionResultEnum.all,
    circleRemainders: Bit.Inputs.OCCT.twoCircleInclusionEnum.outside,
});
```
- Defined in bitbybit-docs.d.ts:48973

constraintTanCirclesOnTwoCircles

constraintTanCirclesOnTwoCircles(
inputs: ConstraintTanCirclesOnTwoCirclesDto<TopoDSEdgePointer>,
): Promise<TopoDSShapePointer[]>
Draws the circles of a given radius that just touch two circles at once.

It is replaced by circlesTangentToTwoWithRadius, which takes curves other than circles too.
Parameters
- inputs: ConstraintTanCirclesOnTwoCirclesDto<TopoDSEdgePointer>
  The two circle edges, the tolerance and the radius of the new circles
Returns Promise<TopoDSShapePointer[]>
The tangent circles
Deprecated
Use circlesTangentToTwoWithRadius with the two circles and a frame in their plane. It is removed in a future major version and works until then.
Example
```
const circles = await bitbybit.occt.shapes.edge.constraintTanCirclesOnTwoCircles({ circle1, circle2, tolerance: 1e-7, radius: 3 });
```
- Defined in bitbybit-docs.d.ts:48990

constraintTanCirclesOnCircleAndPnt

constraintTanCirclesOnCircleAndPnt(
inputs: ConstraintTanCirclesOnCircleAndPntDto<TopoDSEdgePointer>,
): Promise<TopoDSShapePointer[]>
Draws the circles of a given radius that pass through a point and just touch a circle.

It is replaced by circlesTangentToTwoWithRadius, which takes a vertex and a curve other than a circle too.
Parameters
- inputs: ConstraintTanCirclesOnCircleAndPntDto<TopoDSEdgePointer>
  The circle edge, the point, the tolerance and the radius of the new circles
Returns Promise<TopoDSShapePointer[]>
The tangent circles
Deprecated
Use circlesTangentToTwoWithRadius with the circle, the point as a vertex (shapes.vertex.vertexFromPoint) and a frame in the circle's plane. It is removed in a future major version and works until then.
Example
```
const circles = await bitbybit.occt.shapes.edge.constraintTanCirclesOnCircleAndPnt({ circle, point: [15, 0, 0], tolerance: 1e-7, radius: 3 });
```
- Defined in bitbybit-docs.d.ts:49008

circlesTangentToThree

circlesTangentToThree(
    inputs: CirclesTangentToThreeDto<
        TopoDSVertexPointer
        | TopoDSEdgePointer,
    >,
): Promise<TopoDSEdgePointer[]>
Draws every circle that touches three edges, or passes through the vertices among them, in the plane of a frame.

Straight edges count as endless lines and arcs as whole circles unless onArgumentsOnly is set; other curves are touched within their ends. A circle that is one of the edges is left out.
Parameters
- inputs: CirclesTangentToThreeDto<TopoDSVertexPointer | TopoDSEdgePointer>
  The three edges or vertices, the plane, the tolerance and whether the circles must touch the edges themselves
Returns Promise<TopoDSEdgePointer[]>
One whole circle per solution
Example
```
const circles = await bitbybit.occt.shapes.edge.circlesTangentToThree({
    shapes: [sideA, sideB, sideC],
    frame: { origin: [0, 0, 0], normal: [0, 1, 0], direction: [1, 0, 0] },
    tolerance: 1e-7,
    onArgumentsOnly: true,
});
```
- Defined in bitbybit-docs.d.ts:49030

circlesTangentToTwoWithRadius

circlesTangentToTwoWithRadius(
    inputs: CirclesTangentToTwoWithRadiusDto<
        TopoDSVertexPointer
        | TopoDSEdgePointer,
    >,
): Promise<TopoDSEdgePointer[]>
Draws every circle of a given radius that touches two edges, or passes through the vertices among them, in the plane of a frame.

Straight edges count as endless lines and arcs as whole circles unless onArgumentsOnly is set; other curves are touched within their ends. A circle that is one of the given edges is left out.
Parameters
- inputs: CirclesTangentToTwoWithRadiusDto<TopoDSVertexPointer | TopoDSEdgePointer>
  The two edges or vertices, the plane, the radius, the tolerance and whether the circles must touch the edges themselves
Returns Promise<TopoDSEdgePointer[]>
One whole circle per solution
Example
```
const fillets = await bitbybit.occt.shapes.edge.circlesTangentToTwoWithRadius({
    shapes: [wall, floor],
    frame: { origin: [0, 0, 0], normal: [0, 1, 0], direction: [1, 0, 0] },
    radius: 2,
    tolerance: 1e-7,
    onArgumentsOnly: true,
});
```
- Defined in bitbybit-docs.d.ts:49054

circlesTangentToTwoCenteredOn

circlesTangentToTwoCenteredOn(
    inputs: CirclesTangentToTwoCenteredOnDto<
        TopoDSVertexPointer
        | TopoDSEdgePointer,
    >,
): Promise<TopoDSEdgePointer[]>
Draws every circle centered on an edge that touches two other edges, or passes through the vertices among them, in the plane of a frame.

Straight edges count as endless lines and arcs as whole circles, the edge of centers too, unless onArgumentsOnly is set, which also keeps each center within centerOn. Other curves are touched within their ends.
Parameters
- inputs: CirclesTangentToTwoCenteredOnDto<TopoDSVertexPointer | TopoDSEdgePointer>
  The two edges or vertices, the edge of centers, the plane, the tolerance and whether the circles must touch the edges themselves
Returns Promise<TopoDSEdgePointer[]>
One whole circle per solution
Example
```
const circles = await bitbybit.occt.shapes.edge.circlesTangentToTwoCenteredOn({
    shapes: [top, bottom],
    centerOn: axis,
    frame: { origin: [0, 0, 0], normal: [0, 1, 0], direction: [1, 0, 0] },
    tolerance: 1e-7,
    onArgumentsOnly: false,
});
```
- Defined in bitbybit-docs.d.ts:49078

linesTangentToTwo

linesTangentToTwo(
inputs: LinesTangentToTwoDto<TopoDSVertexPointer | TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer[]>
Draws every straight line that touches two curved edges, or touches one and passes through a vertex, in the plane of a frame.

Each line runs from the first shape to the second, like a belt between two wheels. Arcs count as whole circles unless onArgumentsOnly is set; straight edges and two vertices are refused.
Parameters
- inputs: LinesTangentToTwoDto<TopoDSVertexPointer | TopoDSEdgePointer>
  The two shapes, the plane, the angular tolerance and whether the lines must touch the edges themselves
Returns Promise<TopoDSEdgePointer[]>
One line per solution, from contact to contact
Example
```
const belt = await bitbybit.occt.shapes.edge.linesTangentToTwo({
    shapes: [wheelA, wheelB],
    frame: { origin: [0, 0, 0], normal: [0, 1, 0], direction: [1, 0, 0] },
    angularTolerance: 1e-6,
    onArgumentsOnly: false,
});
```
- Defined in bitbybit-docs.d.ts:49100

linesTangentAtAngle

linesTangentAtAngle(
inputs: LinesTangentAtAngleDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer[]>
Draws every straight line that touches a curved edge at an angle to a straight reference edge, in the plane of a frame.

The angle, in degrees, turns counterclockwise about the frame's normal. Each line runs from its touch to the reference's line; a parallel one is centered on its touch, as long as the reference.
Parameters
- inputs: LinesTangentAtAngleDto<TopoDSEdgePointer>
  The curve, the reference, the plane, the angle in degrees, the tolerance and whether the lines must touch the edges themselves
Returns Promise<TopoDSEdgePointer[]>
One line per solution, from the touch to the reference
Example
```
const tangents = await bitbybit.occt.shapes.edge.linesTangentAtAngle({
    shape: arc,
    reference: baseLine,
    frame: { origin: [0, 0, 0], normal: [0, 1, 0], direction: [1, 0, 0] },
    angle: 30,
    angularTolerance: 1e-6,
    onArgumentsOnly: false,
});
```
- Defined in bitbybit-docs.d.ts:49125

debug

debugInfo

debugInfo(inputs: ShapeDto<TopoDSEdgePointer>): Promise<EdgeDebugInfo>
Collects diagnostic facts about the curve of an edge: its type and degree, control point and knot counts, whether it is rational, periodic or closed, its parameter range and period, its length and its end points.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The edge to inspect
Returns Promise<EdgeDebugInfo>
The report about the edge's curve
Example
```
const info = await bitbybit.occt.shapes.edge.debugInfo({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:48047

edit

splitEdgeAtParams

splitEdgeAtParams(
inputs: DataOnGeometryAtParamsDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer[]>
Cuts an edge into pieces at places given as fractions from 0 at its start to 1 at its end.

The pieces keep the edge's curve and direction, so the pieces of an arc are arcs. Fractions follow the parameter, not the length; ends and repeats are skipped, so n places inside the edge give n + 1 pieces.
Parameters
- inputs: DataOnGeometryAtParamsDto<TopoDSEdgePointer>
  The edge and the fractions to cut at
Returns Promise<TopoDSEdgePointer[]>
The pieces, in order from the start
Example
```
const [firstHalf, secondHalf] = await bitbybit.occt.shapes.edge.splitEdgeAtParams({ shape: arc, params: [0.5] });
```
- Defined in bitbybit-docs.d.ts:48844

splitEdgeAtLengths

splitEdgeAtLengths(
inputs: DataOnGeometryAtLengthsDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer[]>
Cuts an edge into pieces at places given as lengths along it from its start, in model units.

Each piece runs along the edge's own curve and keeps its direction. Lengths at or past the ends and repeats are skipped, so n lengths inside the edge give n + 1 pieces.
Parameters
- inputs: DataOnGeometryAtLengthsDto<TopoDSEdgePointer>
  The edge and the lengths to cut at
Returns Promise<TopoDSEdgePointer[]>
The pieces, in order from the start
Example
```
const pieces = await bitbybit.occt.shapes.edge.splitEdgeAtLengths({ shape: edge, lengths: [2, 5] });
```
- Defined in bitbybit-docs.d.ts:48860

extendEdge

extendEdge(inputs: ExtendEdgeDto<TopoDSEdgePointer>): Promise<TopoDSEdgePointer>
Lengthens an edge before its start and past its end, carrying its curve on the way it runs.

A line stays a line and an arc an arc, up to a full circle. Other curves become B-splines ending that far along the end's tangent, bending smoothly across the join; one still turning there gains a little more.
Parameters
- inputs: ExtendEdgeDto<TopoDSEdgePointer>
  The edge and the lengths to add at its start and its end
Returns Promise<TopoDSEdgePointer>
A new, longer edge running the same way
Example
```
const longer = await bitbybit.occt.shapes.edge.extendEdge({ shape: edge, atStart: 0, atEnd: 2 });
```
- Defined in bitbybit-docs.d.ts:48877

blendBetweenEdges

blendBetweenEdges(
inputs: BlendBetweenEdgesDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer>
Bridges the gap from the end of one edge to the start of another with a smooth Bezier edge that leaves and arrives along their tangents.

With matchCurvature it also bends as each edge bends at its end. bulge sets how long it holds each tangent; edges whose ends already meet are refused.
Parameters
- inputs: BlendBetweenEdgesDto<TopoDSEdgePointer>
  The edge to leave, the edge to reach and how the blend joins them
Returns Promise<TopoDSEdgePointer>
The blend edge
Example
```
const bridge = await bitbybit.occt.shapes.edge.blendBetweenEdges({ from: first, to: second, matchCurvature: true, bulge: 1 });
const path = await bitbybit.occt.shapes.wire.combineEdgesAndWiresIntoAWire({ shapes: [first, bridge, second] });
```
- Defined in bitbybit-docs.d.ts:48895

extract

pointOnEdgeAtParam

pointOnEdgeAtParam(
inputs: DataOnGeometryAtParamDto<TopoDSEdgePointer>,
): Promise<Point3>
Finds the point a fraction of the way along an edge: 0 is the start, 1 the end, 0.5 the middle of the parameter range.

The fraction follows the curve's own parameter, which for a free-form curve is not evenly spread by length; use pointOnEdgeAtLength for a distance.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSEdgePointer>
  The edge and the fraction from 0 to 1
Returns Promise<Point3>
The point on the edge
Example
```
const middle = await bitbybit.occt.shapes.edge.pointOnEdgeAtParam({ shape: edge, param: 0.5 });
```
- Defined in bitbybit-docs.d.ts:48525

pointsOnEdgesAtParam

pointsOnEdgesAtParam(
inputs: DataOnGeometryesAtParamDto<TopoDSEdgePointer>,
): Promise<Point3[]>
Finds the point at the same fraction along each edge in a list.
Parameters
- inputs: DataOnGeometryesAtParamDto<TopoDSEdgePointer>
  The edges and the fraction from 0 to 1
Returns Promise<Point3[]>
One point per edge, in the same order
Example
```
const middles = await bitbybit.occt.shapes.edge.pointsOnEdgesAtParam({ shapes: edges, param: 0.5 });
```
- Defined in bitbybit-docs.d.ts:48538

edgesToPoints

edgesToPoints(inputs: EdgesToPointsDto<TopoDSShapePointer>): Promise<Point3[][]>
Turns every edge of a shape into a run of points that follows its curve closely enough to draw it, one list per edge.

The deflection settings say how tightly the points hug curved edges; a wire's edges come in their order along the wire.
Parameters
- inputs: EdgesToPointsDto<TopoDSShapePointer>
  The shape and the deflection settings
Returns Promise<Point3[][]>
One list of points per edge
Example
```
const polylines = await bitbybit.occt.shapes.edge.edgesToPoints({
    shape: wire,
    angularDeflection: 0.1,
    curvatureDeflection: 0.1,
    minimumOfPoints: 2,
    uTolerance: 1e-9,
    minimumLength: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:48562

tangentOnEdgeAtParam

tangentOnEdgeAtParam(
inputs: DataOnGeometryAtParamDto<TopoDSEdgePointer>,
): Promise<Vector3>
Finds the direction the edge is heading at a fraction of the way along it, from 0 at the start to 1 at the end.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSEdgePointer>
  The edge and the fraction from 0 to 1
Returns Promise<Vector3>
The tangent direction
Example
```
const tangent = await bitbybit.occt.shapes.edge.tangentOnEdgeAtParam({ shape: arc, param: 0.5 });
```
- Defined in bitbybit-docs.d.ts:48589

tangentsOnEdgesAtParam

tangentsOnEdgesAtParam(
inputs: DataOnGeometryesAtParamDto<TopoDSEdgePointer>,
): Promise<Point3[]>
Finds the direction each edge in a list is heading at the same fraction along it.
Parameters
- inputs: DataOnGeometryesAtParamDto<TopoDSEdgePointer>
  The edges and the fraction from 0 to 1
Returns Promise<Point3[]>
One tangent per edge, in the same order
Example
```
const tangents = await bitbybit.occt.shapes.edge.tangentsOnEdgesAtParam({ shapes: edges, param: 0.5 });
```
- Defined in bitbybit-docs.d.ts:48602

pointOnEdgeAtLength

pointOnEdgeAtLength(
inputs: DataOnGeometryAtLengthDto<TopoDSEdgePointer>,
): Promise<Point3>
Finds the point a given distance along an edge from its start, measured along the curve in model units.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSEdgePointer>
  The edge and the distance from its start
Returns Promise<Point3>
The point on the edge
Example
```
const point = await bitbybit.occt.shapes.edge.pointOnEdgeAtLength({ shape: edge, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:48616

pointsOnEdgesAtLength

pointsOnEdgesAtLength(
inputs: DataOnGeometryesAtLengthDto<TopoDSEdgePointer>,
): Promise<Point3[]>
Finds the point at the same distance from the start along each edge in a list.
Parameters
- inputs: DataOnGeometryesAtLengthDto<TopoDSEdgePointer>
  The edges and the distance from the start
Returns Promise<Point3[]>
One point per edge, in the same order
Example
```
const points = await bitbybit.occt.shapes.edge.pointsOnEdgesAtLength({ shapes: edges, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:48629

tangentOnEdgeAtLength

tangentOnEdgeAtLength(
inputs: DataOnGeometryAtLengthDto<TopoDSEdgePointer>,
): Promise<Vector3>
Finds the direction the edge is heading at a given distance along it from its start, measured along the curve.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSEdgePointer>
  The edge and the distance from its start
Returns Promise<Vector3>
The tangent direction
Example
```
const tangent = await bitbybit.occt.shapes.edge.tangentOnEdgeAtLength({ shape: arc, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:48643

tangentsOnEdgesAtLength

tangentsOnEdgesAtLength(
inputs: DataOnGeometryesAtLengthDto<TopoDSEdgePointer>,
): Promise<Vector3[]>
Finds the direction each edge in a list is heading at the same distance from its start.
Parameters
- inputs: DataOnGeometryesAtLengthDto<TopoDSEdgePointer>
  The edges and the distance from the start
Returns Promise<Vector3[]>
One tangent per edge, in the same order
Example
```
const tangents = await bitbybit.occt.shapes.edge.tangentsOnEdgesAtLength({ shapes: edges, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:48656

startPointOnEdge

startPointOnEdge(inputs: ShapeDto<TopoDSEdgePointer>): Promise<Point3>
Reads the point where an edge starts, in the edge's own direction.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The edge
Returns Promise<Point3>
The start point
Example
```
const start = await bitbybit.occt.shapes.edge.startPointOnEdge({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:48728

startPointsOnEdges

startPointsOnEdges(inputs: ShapesDto<TopoDSEdgePointer>): Promise<Point3[]>
Reads the start point of each edge in a list.
Parameters
- inputs: ShapesDto<TopoDSEdgePointer>
  The edges
Returns Promise<Point3[]>
One start point per edge, in the same order
Example
```
const starts = await bitbybit.occt.shapes.edge.startPointsOnEdges({ shapes: edges });
```
- Defined in bitbybit-docs.d.ts:48741

endPointOnEdge

endPointOnEdge(inputs: ShapeDto<TopoDSEdgePointer>): Promise<Point3>
Reads the point where an edge ends, in the edge's own direction.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The edge
Returns Promise<Point3>
The end point
Example
```
const end = await bitbybit.occt.shapes.edge.endPointOnEdge({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:48754

endPointsOnEdges

endPointsOnEdges(inputs: ShapesDto<TopoDSEdgePointer>): Promise<Point3[]>
Reads the end point of each edge in a list.
Parameters
- inputs: ShapesDto<TopoDSEdgePointer>
  The edges
Returns Promise<Point3[]>
One end point per edge, in the same order
Example
```
const ends = await bitbybit.occt.shapes.edge.endPointsOnEdges({ shapes: edges });
```
- Defined in bitbybit-docs.d.ts:48767

divideEdgeByParamsToPoints

divideEdgeByParamsToPoints(
inputs: DivideDto<TopoDSEdgePointer>,
): Promise<Point3[]>
Places points along an edge at equal steps of its parameter, from start to end.

nrOfDivisions steps give one more point than that; removeStartPoint and removeEndPoint drop the ends. On a free-form curve equal parameter steps are not equal distances; use divideEdgeByEqualDistanceToPoints for those.
Parameters
- inputs: DivideDto<TopoDSEdgePointer>
  The edge, the number of divisions and whether to drop the end points
Returns Promise<Point3[]>
The points along the edge, in order
Example
```
const points = await bitbybit.occt.shapes.edge.divideEdgeByParamsToPoints({ shape: edge, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:48784

divideEdgesByParamsToPoints

divideEdgesByParamsToPoints(
inputs: DivideShapesDto<TopoDSEdgePointer>,
): Promise<Point3[][]>
Places points along each edge in a list at equal steps of its parameter, one list per edge.
Parameters
- inputs: DivideShapesDto<TopoDSEdgePointer>
  The edges, the number of divisions and whether to drop the end points
Returns Promise<Point3[][]>
One list of points per edge, in the same order
Example
```
const points = await bitbybit.occt.shapes.edge.divideEdgesByParamsToPoints({ shapes: edges, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:48797

divideEdgeByEqualDistanceToPoints

divideEdgeByEqualDistanceToPoints(
inputs: DivideDto<TopoDSEdgePointer>,
): Promise<Point3[]>
Places points along an edge at equal distances measured along its curve, from start to end.

nrOfDivisions steps give one more point than that; removeStartPoint and removeEndPoint drop the ends.
Parameters
- inputs: DivideDto<TopoDSEdgePointer>
  The edge, the number of divisions and whether to drop the end points
Returns Promise<Point3[]>
The points along the edge, in order
Example
```
const points = await bitbybit.occt.shapes.edge.divideEdgeByEqualDistanceToPoints({ shape: edge, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:48813

divideEdgesByEqualDistanceToPoints

divideEdgesByEqualDistanceToPoints(
inputs: DivideShapesDto<TopoDSEdgePointer>,
): Promise<Point3[][]>
Places points along each edge in a list at equal distances along its curve, one list per edge.
Parameters
- inputs: DivideShapesDto<TopoDSEdgePointer>
  The edges, the number of divisions and whether to drop the end points
Returns Promise<Point3[][]>
One list of points per edge, in the same order
Example
```
const points = await bitbybit.occt.shapes.edge.divideEdgesByEqualDistanceToPoints({ shapes: edges, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:48827

frames

frameOnEdgeAtParam

frameOnEdgeAtParam(
inputs: FrameOnCurveAtParamDto<TopoDSEdgePointer>,
): Promise<Bit.Inputs.Base.Frame>
Finds a frame on an edge at a parameter, from 0 where the edge starts in its own direction. kind sets how it follows: carried from the start without twisting, across the edge level with up, or in the plane it bends in; Frenet frames throw where the edge runs straight, level ones where it runs along up.
Parameters
- inputs: FrameOnCurveAtParamDto<TopoDSEdgePointer>
  The edge, the fraction along it, the kind of frame and the up vector
Returns Promise<Bit.Inputs.Base.Frame>
The frame at that place
Example
```
const frame = await bitbybit.occt.shapes.edge.frameOnEdgeAtParam({ shape: edge, param: 0.5, kind: Bit.Inputs.OCCT.curveFrameEnum.perpendicular, up: [0, 0, 1] });
```
- Defined in bitbybit-docs.d.ts:48672

frameOnEdgeAtLength

frameOnEdgeAtLength(
inputs: FrameOnCurveAtLengthDto<TopoDSEdgePointer>,
): Promise<Bit.Inputs.Base.Frame>
Finds a frame on an edge at a length from its start, as frameOnEdgeAtParam finds it at a parameter.
Parameters
- inputs: FrameOnCurveAtLengthDto<TopoDSEdgePointer>
  The edge, the length along it, the kind of frame and the up vector
Returns Promise<Bit.Inputs.Base.Frame>
The frame at that place
Example
```
const frame = await bitbybit.occt.shapes.edge.frameOnEdgeAtLength({ shape: edge, length: 2, kind: Bit.Inputs.OCCT.curveFrameEnum.perpendicular, up: [0, 0, 1] });
```
- Defined in bitbybit-docs.d.ts:48686

framesOnEdgeAtParams

framesOnEdgeAtParams(
inputs: FramesOnCurveAtParamsDto<TopoDSEdgePointer>,
): Promise<Bit.Inputs.Base.Frame[]>
Finds frames on an edge at several parameters in one pass. Rotation-minimizing frames are carried along the whole edge from its start, so each is the frame a swept profile would ride on there.
Parameters
- inputs: FramesOnCurveAtParamsDto<TopoDSEdgePointer>
  The edge, the fractions along it, the kind of frame and the up vector
Returns Promise<Bit.Inputs.Base.Frame[]>
One frame per parameter, in the same order
Example
```
const frames = await bitbybit.occt.shapes.edge.framesOnEdgeAtParams({ shape: edge, params: [0, 0.5, 1], kind: Bit.Inputs.OCCT.curveFrameEnum.rotationMinimizing, up: [0, 0, 1] });
```
- Defined in bitbybit-docs.d.ts:48701

framesOnEdgeAtLengths

framesOnEdgeAtLengths(
inputs: FramesOnCurveAtLengthsDto<TopoDSEdgePointer>,
): Promise<Bit.Inputs.Base.Frame[]>
Finds frames on an edge at several lengths from its start in one pass, as framesOnEdgeAtParams finds them at parameters.
Parameters
- inputs: FramesOnCurveAtLengthsDto<TopoDSEdgePointer>
  The edge, the lengths along it, the kind of frame and the up vector
Returns Promise<Bit.Inputs.Base.Frame[]>
One frame per length, in the same order
Example
```
const frames = await bitbybit.occt.shapes.edge.framesOnEdgeAtLengths({ shape: edge, lengths: [0, 1, 2], kind: Bit.Inputs.OCCT.curveFrameEnum.rotationMinimizing, up: [0, 0, 1] });
```
- Defined in bitbybit-docs.d.ts:48715

from

makeEdgeFromGeom2dCurveAndSurface

makeEdgeFromGeom2dCurveAndSurface(
inputs: CurveAndSurfaceDto<Geom2dCurvePointer, GeomSurfacePointer>,
): Promise<TopoDSEdgePointer>
Makes an edge from a 2D curve laid onto a surface: the curve lives in the surface's UV space and the edge follows it across the surface.
Parameters
- inputs: CurveAndSurfaceDto<Geom2dCurvePointer, GeomSurfacePointer>
  The 2D curve and the surface to lay it on
Returns Promise<TopoDSEdgePointer>
The edge on the surface
Example
```
const edge = await bitbybit.occt.shapes.edge.makeEdgeFromGeom2dCurveAndSurface({ curve: curve2d, surface });
```
- Defined in bitbybit-docs.d.ts:48308

from base

fromBaseLine

fromBaseLine(inputs: LineBaseDto): Promise<TopoDSEdgePointer>
Makes a straight edge from a line object of the form { start, end }.
Parameters
- inputs: LineBaseDto
  The line
Returns Promise<TopoDSEdgePointer>
The straight edge
Example
```
const edge = await bitbybit.occt.shapes.edge.fromBaseLine({ line: { start: [0, 0, 0], end: [10, 0, 0] } });
```
- Defined in bitbybit-docs.d.ts:48060

fromBaseLines

fromBaseLines(inputs: LinesBaseDto): Promise<TopoDSEdgePointer[]>
Makes one straight edge per line object of the form { start, end }.
Parameters
- inputs: LinesBaseDto
  The lines
Returns Promise<TopoDSEdgePointer[]>
One edge per line, in the same order
Example
```
const edges = await bitbybit.occt.shapes.edge.fromBaseLines({ lines: [{ start: [0, 0, 0], end: [10, 0, 0] }, { start: [10, 0, 0], end: [10, 10, 0] }] });
```
- Defined in bitbybit-docs.d.ts:48073

fromBaseSegment

fromBaseSegment(inputs: SegmentBaseDto): Promise<TopoDSEdgePointer>
Makes a straight edge from a segment, a pair of points [start, end].
Parameters
- inputs: SegmentBaseDto
  The segment
Returns Promise<TopoDSEdgePointer>
The straight edge
Example
```
const edge = await bitbybit.occt.shapes.edge.fromBaseSegment({ segment: [[0, 0, 0], [10, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:48086

fromBaseSegments

fromBaseSegments(inputs: SegmentsBaseDto): Promise<TopoDSEdgePointer[]>
Makes one straight edge per segment, each a pair of points [start, end].
Parameters
- inputs: SegmentsBaseDto
  The segments
Returns Promise<TopoDSEdgePointer[]>
One edge per segment, in the same order
Example
```
const edges = await bitbybit.occt.shapes.edge.fromBaseSegments({ segments: [[[0, 0, 0], [10, 0, 0]], [[10, 0, 0], [10, 10, 0]]] });
```
- Defined in bitbybit-docs.d.ts:48099

fromPoints

fromPoints(inputs: Bit.Inputs.OCCT.PointsDto): Promise<TopoDSEdgePointer[]>
Joins each point to the next with a straight edge, so a list of points becomes a chain of edges.

The edges are returned loose; shapes.wire.createPolylineWire makes the joined wire directly.
Parameters
- inputs: Bit.Inputs.OCCT.PointsDto
  The points, in order
Returns Promise<TopoDSEdgePointer[]>
One edge per pair of neighboring points
Example
```
const edges = await bitbybit.occt.shapes.edge.fromPoints({ points: [[0, 0, 0], [10, 0, 0], [10, 10, 0]] });
```
- Defined in bitbybit-docs.d.ts:48116

fromBasePolyline

fromBasePolyline(inputs: PolylineBaseDto): Promise<TopoDSEdgePointer[]>
Makes one straight edge per segment of a polyline object; a closed polyline also gets the edge from its last point back to its first.
Parameters
- inputs: PolylineBaseDto
  The polyline
Returns Promise<TopoDSEdgePointer[]>
One edge per segment, in order
Example
```
const edges = await bitbybit.occt.shapes.edge.fromBasePolyline({ polyline: { points: [[0, 0, 0], [10, 0, 0], [10, 10, 0]], isClosed: true } });
```
- Defined in bitbybit-docs.d.ts:48130

fromBaseTriangle

fromBaseTriangle(inputs: TriangleBaseDto): Promise<TopoDSEdgePointer[]>
Makes the three straight edges of a triangle given as three points.
Parameters
- inputs: TriangleBaseDto
  The triangle
Returns Promise<TopoDSEdgePointer[]>
Its three edges
Example
```
const edges = await bitbybit.occt.shapes.edge.fromBaseTriangle({ triangle: [[0, 0, 0], [10, 0, 0], [0, 10, 0]] });
```
- Defined in bitbybit-docs.d.ts:48143

fromBaseMesh

fromBaseMesh(inputs: MeshBaseDto): Promise<TopoDSEdgePointer[]>
Makes the three straight edges of every triangle of a mesh, all in one flat list.

A triangle whose edges cannot be built is skipped with a warning rather than stopping the rest.
Parameters
- inputs: MeshBaseDto
  The mesh as a list of triangles
Returns Promise<TopoDSEdgePointer[]>
The edges of all the triangles
Example
```
const edges = await bitbybit.occt.shapes.edge.fromBaseMesh({ mesh: triangles });
```
- Defined in bitbybit-docs.d.ts:48159

get

getEdge

getEdge(inputs: EdgeIndexDto<TopoDSShapePointer>): Promise<TopoDSEdgePointer>
Picks one edge out of a shape by its position, counting from 0, in the order the kernel walks the shape.

The shape must be an edge, a wire or something built from them; an index beyond the last edge throws an error.
Parameters
- inputs: EdgeIndexDto<TopoDSShapePointer>
  The shape and the 0-based index
Returns Promise<TopoDSEdgePointer>
The edge at that index
Example
```
const first = await bitbybit.occt.shapes.edge.getEdge({ shape: wire, index: 0 });
```
- Defined in bitbybit-docs.d.ts:48325

getEdges

getEdges(inputs: ShapeDto<TopoDSShapePointer>): Promise<TopoDSEdgePointer[]>
Lists every edge of a shape in the order the kernel walks it, which is not the order along a wire; use getEdgesAlongWire for that.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<TopoDSEdgePointer[]>
The edges found in the shape
Example
```
const edges = await bitbybit.occt.shapes.edge.getEdges({ shape: box });
```
- Defined in bitbybit-docs.d.ts:48339

getEdgesAlongWire

getEdgesAlongWire(
inputs: ShapeDto<TopoDSWirePointer>,
): Promise<TopoDSEdgePointer[]>
Lists the edges of a wire in the order they follow each other along it, each oriented to run in the wire's direction.

A single edge is returned as a one-element list.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  The wire
Returns Promise<TopoDSEdgePointer[]>
Its edges in order along the wire
Example
```
const ordered = await bitbybit.occt.shapes.edge.getEdgesAlongWire({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:48355

getCircularEdgesAlongWire

getCircularEdgesAlongWire(
inputs: ShapeDto<TopoDSWirePointer>,
): Promise<TopoDSEdgePointer[]>
Lists only the circular edges of a wire, in the order they follow each other along it.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  The wire
Returns Promise<TopoDSEdgePointer[]>
Its circular edges in order
Example
```
const arcs = await bitbybit.occt.shapes.edge.getCircularEdgesAlongWire({ shape: roundedRectangle });
```
- Defined in bitbybit-docs.d.ts:48368

getLinearEdgesAlongWire

getLinearEdgesAlongWire(
inputs: ShapeDto<TopoDSWirePointer>,
): Promise<TopoDSEdgePointer[]>
Lists only the straight edges of a wire, in the order they follow each other along it.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  The wire
Returns Promise<TopoDSEdgePointer[]>
Its straight edges in order
Example
```
const straights = await bitbybit.occt.shapes.edge.getLinearEdgesAlongWire({ shape: roundedRectangle });
```
- Defined in bitbybit-docs.d.ts:48381

getCornerPointsOfEdgesForShape

getCornerPointsOfEdgesForShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<Point3[]>
Lists the end points of every edge of a shape, with repeats removed, so a corner where several edges meet appears once.

The points come in no particular order.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape whose edges to read: a wire, face, shell or solid
Returns Promise<Point3[]>
The unique end points of the edges
Example
```
const corners = await bitbybit.occt.shapes.edge.getCornerPointsOfEdgesForShape({ shape: box });
```
- Defined in bitbybit-docs.d.ts:48397

getEdgeLength

getEdgeLength(inputs: ShapeDto<TopoDSEdgePointer>): Promise<number>
Measures the length of an edge along its curve, in model units.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The edge
Returns Promise<number>
The length
Example
```
const len = await bitbybit.occt.shapes.edge.getEdgeLength({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:48410

getEdgeLengthsOfShape

getEdgeLengthsOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<number[]>
Measures every edge of a shape along its curve, in model units.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<number[]>
One length per edge, in the order getEdges lists them
Example
```
const lengths = await bitbybit.occt.shapes.edge.getEdgeLengthsOfShape({ shape: box });
```
- Defined in bitbybit-docs.d.ts:48423

getEdgesLengths

getEdgesLengths(inputs: ShapesDto<TopoDSEdgePointer>): Promise<number[]>
Measures each edge in a list along its curve, in model units.
Parameters
- inputs: ShapesDto<TopoDSEdgePointer>
  The edges
Returns Promise<number[]>
One length per edge, in the same order
Example
```
const lengths = await bitbybit.occt.shapes.edge.getEdgesLengths({ shapes: edges });
```
- Defined in bitbybit-docs.d.ts:48436

getEdgeCenterOfMass

getEdgeCenterOfMass(inputs: ShapeDto<TopoDSEdgePointer>): Promise<Point3>
Finds the center of mass of an edge, the balance point of its curve; for a straight edge that is its midpoint, for an arc a point inside the curve.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The edge
Returns Promise<Point3>
The center of mass point
Example
```
const center = await bitbybit.occt.shapes.edge.getEdgeCenterOfMass({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:48450

getEdgesCentersOfMass

getEdgesCentersOfMass(inputs: ShapesDto<TopoDSEdgePointer>): Promise<Point3[]>
Finds the center of mass of each edge in a list.
Parameters
- inputs: ShapesDto<TopoDSEdgePointer>
  The edges
Returns Promise<Point3[]>
One point per edge, in the same order
Example
```
const centers = await bitbybit.occt.shapes.edge.getEdgesCentersOfMass({ shapes: edges });
```
- Defined in bitbybit-docs.d.ts:48463

reversedEdge

reversedEdge(inputs: ShapeDto<TopoDSEdgePointer>): Promise<TopoDSEdgePointer>
Flips the direction of an edge, so its start becomes its end.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The edge
Returns Promise<TopoDSEdgePointer>
A new edge running the other way
Example
```
const back = await bitbybit.occt.shapes.edge.reversedEdge({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:48575

get circular edge

getCircularEdgeCenterPoint

getCircularEdgeCenterPoint(inputs: ShapeDto<TopoDSEdgePointer>): Promise<Point3>
Finds the center of the circle a circular edge lies on.

An edge that is not circular throws an error.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The circular edge
Returns Promise<Point3>
The center point
Example
```
const center = await bitbybit.occt.shapes.edge.getCircularEdgeCenterPoint({ shape: arc });
```
- Defined in bitbybit-docs.d.ts:48478

getCircularEdgeRadius

getCircularEdgeRadius(inputs: ShapeDto<TopoDSEdgePointer>): Promise<number>
Reads the radius of the circle a circular edge lies on.

An edge that is not circular throws an error.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The circular edge
Returns Promise<number>
The radius in model units
Example
```
const radius = await bitbybit.occt.shapes.edge.getCircularEdgeRadius({ shape: arc });
```
- Defined in bitbybit-docs.d.ts:48493

getCircularEdgePlaneDirection

getCircularEdgePlaneDirection(
inputs: ShapeDto<TopoDSEdgePointer>,
): Promise<Vector3>
Reads the normal of the plane a circular edge lies in.

An edge that is not circular throws an error.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The circular edge
Returns Promise<Vector3>
The unit normal of the circle's plane
Example
```
const normal = await bitbybit.occt.shapes.edge.getCircularEdgePlaneDirection({ shape: arc });
```
- Defined in bitbybit-docs.d.ts:48508

is

isEdgeLinear

isEdgeLinear(inputs: ShapeDto<TopoDSEdgePointer>): Promise<boolean>
Tells whether an edge is a straight line.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The edge
Returns Promise<boolean>
True when the edge is straight
Example
```
const straight = await bitbybit.occt.shapes.edge.isEdgeLinear({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:49138

isEdgeCircular

isEdgeCircular(inputs: ShapeDto<TopoDSEdgePointer>): Promise<boolean>
Tells whether an edge lies on a circle, whether a full circle or an arc.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  The edge
Returns Promise<boolean>
True when the edge is circular
Example
```
const round = await bitbybit.occt.shapes.edge.isEdgeCircular({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:49151

primitives

line

line(inputs: Bit.Inputs.OCCT.LineDto): Promise<TopoDSEdgePointer>
Makes a straight edge between two points, the simplest edge there is.
Parameters
- inputs: Bit.Inputs.OCCT.LineDto
  The start and end points
Returns Promise<TopoDSEdgePointer>
The straight edge
Example
```
const edge = await bitbybit.occt.shapes.edge.line({ start: [0, 0, 0], end: [10, 0, 0] });
```
- Defined in bitbybit-docs.d.ts:48172

arcThroughThreePoints

arcThroughThreePoints(inputs: ArcEdgeThreePointsDto): Promise<TopoDSEdgePointer>
Makes a circular arc that starts at the first point, passes through the middle one and ends at the last.
Parameters
- inputs: ArcEdgeThreePointsDto
  The three points
Returns Promise<TopoDSEdgePointer>
The arc edge
Example
```
const arc = await bitbybit.occt.shapes.edge.arcThroughThreePoints({ start: [0, 0, 0], middle: [5, 5, 0], end: [10, 0, 0] });
```
- Defined in bitbybit-docs.d.ts:48186

arcThroughTwoPointsAndTangent

arcThroughTwoPointsAndTangent(
inputs: ArcEdgeTwoPointsTangentDto,
): Promise<TopoDSEdgePointer>
Makes a circular arc from one point to another that leaves the first point in a given direction.

The tangent fixes the plane and the radius of the arc.
Parameters
- inputs: ArcEdgeTwoPointsTangentDto
  The start point, the tangent direction there and the end point
Returns Promise<TopoDSEdgePointer>
The arc edge
Example
```
const arc = await bitbybit.occt.shapes.edge.arcThroughTwoPointsAndTangent({ start: [0, 0, 0], tangentVec: [0, 1, 0], end: [10, 0, 0] });
```
- Defined in bitbybit-docs.d.ts:48202

arcFromCircleAndTwoPoints

arcFromCircleAndTwoPoints(
inputs: ArcEdgeCircleTwoPointsDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer>
Cuts an arc out of a circle edge between two points on it.

sense picks which way round the circle the arc runs from the first point to the second.
Parameters
- inputs: ArcEdgeCircleTwoPointsDto<TopoDSEdgePointer>
  The circle edge, the two points and the direction of travel
Returns Promise<TopoDSEdgePointer>
The arc edge
Example
```
const arc = await bitbybit.occt.shapes.edge.arcFromCircleAndTwoPoints({ circle, start: [10, 0, 0], end: [0, 0, 10], sense: true });
```
- Defined in bitbybit-docs.d.ts:48217

arcFromCircleAndTwoAngles

arcFromCircleAndTwoAngles(
inputs: ArcEdgeCircleTwoAnglesDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer>
Cuts an arc out of a circle edge between two angles, in degrees, measured around the circle from its own start.

sense picks which way round the circle the arc runs from the first angle to the second.
Parameters
- inputs: ArcEdgeCircleTwoAnglesDto<TopoDSEdgePointer>
  The circle edge, the two angles in degrees and the direction of travel
Returns Promise<TopoDSEdgePointer>
The arc edge
Example
```
const quarter = await bitbybit.occt.shapes.edge.arcFromCircleAndTwoAngles({ circle, alphaAngle1: 0, alphaAngle2: 90, sense: true });
```
- Defined in bitbybit-docs.d.ts:48233

arcFromCirclePointAndAngle

arcFromCirclePointAndAngle(
inputs: ArcEdgeCirclePointAngleDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer>
Cuts an arc out of a circle edge that starts at a point on the circle and spans a given angle, in degrees.

sense picks which way round the circle the arc runs.
Parameters
- inputs: ArcEdgeCirclePointAngleDto<TopoDSEdgePointer>
  The circle edge, the start point, the angle in degrees and the direction of travel
Returns Promise<TopoDSEdgePointer>
The arc edge
Example
```
const arc = await bitbybit.occt.shapes.edge.arcFromCirclePointAndAngle({ circle, point: [10, 0, 0], alphaAngle: 45, sense: true });
```
- Defined in bitbybit-docs.d.ts:48249

createCircleEdge

createCircleEdge(inputs: Bit.Inputs.OCCT.CircleDto): Promise<TopoDSEdgePointer>
Makes a full circle as one closed edge, lying in the plane whose normal is direction.
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  The radius, the center and the plane normal
Returns Promise<TopoDSEdgePointer>
The circle edge
Example
```
const circle = await bitbybit.occt.shapes.edge.createCircleEdge({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:48262

createEllipseEdge

createEllipseEdge(
inputs: Bit.Inputs.OCCT.EllipseDto,
): Promise<TopoDSEdgePointer>
Makes a full ellipse as one closed edge, lying in the plane whose normal is direction.

radiusMajor must not be smaller than radiusMinor, or the kernel refuses the ellipse.
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  The center, the plane normal and the two radii
Returns Promise<TopoDSEdgePointer>
The ellipse edge
Example
```
const ellipse = await bitbybit.occt.shapes.edge.createEllipseEdge({ center: [0, 0, 0], direction: [0, 1, 0], radiusMinor: 3, radiusMajor: 6 });
```
- Defined in bitbybit-docs.d.ts:48277

rebuild

rebuildEdgeDegree

rebuildEdgeDegree(
inputs: RebuildCurveDegreeDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer>
Rebuilds the curve of an edge as a B-spline of a given degree, within a tolerance.

Lowering the degree simplifies the curve, raising it gives later operations more freedom; either way the new curve stays within tolerance of the old.
Parameters
- inputs: RebuildCurveDegreeDto<TopoDSEdgePointer>
  The edge, the degree to rebuild to and the tolerance
Returns Promise<TopoDSEdgePointer>
A new edge with the rebuilt curve
Example
```
const simpler = await bitbybit.occt.shapes.edge.rebuildEdgeDegree({ shape: edge, degree: 3, tolerance: 1e-3 });
```
- Defined in bitbybit-docs.d.ts:48000

seam

moveEdgeSeamByParameter

moveEdgeSeamByParameter(
inputs: CurveSeamByParameterDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer>
Moves the seam of a closed periodic edge, the point where it starts and ends, to a given parameter along the curve.

The geometry does not change; only where the edge is considered to begin.
Parameters
- inputs: CurveSeamByParameterDto<TopoDSEdgePointer>
  The periodic edge and the parameter of the new seam
Returns Promise<TopoDSEdgePointer>
A new edge starting at the seam
Example
```
const rotated = await bitbybit.occt.shapes.edge.moveEdgeSeamByParameter({ shape: circle, parameter: 1.57 });
```
- Defined in bitbybit-docs.d.ts:48016

moveEdgeSeamByLength

moveEdgeSeamByLength(
inputs: CurveSeamByLengthDto<TopoDSEdgePointer>,
): Promise<TopoDSEdgePointer>
Moves the seam of a closed periodic edge, the point where it starts and ends, by a distance along the curve from its current start.

The geometry does not change; only where the edge is considered to begin.
Parameters
- inputs: CurveSeamByLengthDto<TopoDSEdgePointer>
  The periodic edge and the distance to move the seam
Returns Promise<TopoDSEdgePointer>
A new edge starting at the seam
Example
```
const rotated = await bitbybit.occt.shapes.edge.moveEdgeSeamByLength({ shape: circle, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:48032

shapes

removeInternalEdges

removeInternalEdges(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Merges faces that lie on the same surface and edges on the same curve, which removes the internal seams a boolean or a fuse leaves behind.

It is shapes.shape.unifySameDomain with edges and faces both unified and B-splines left as they are.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  The shape
Returns Promise<TopoDSShapePointer>
The shape without internal seams
Example
```
const clean = await bitbybit.occt.shapes.edge.removeInternalEdges({ shape: fused });
```
- Defined in bitbybit-docs.d.ts:48294

Class OCCTEdge

Index

Constructors

constraint

debug

edit

extract

frames

from

from base

get

get circular edge

is

primitives

rebuild

seam

shapes

Constructors

constructor

Returns OCCTEdge

constraint

constraintTanLinesFromTwoPtsToCircle

Parameters

Returns Promise<TopoDSShapePointer[]>

Deprecated

Example

constraintTanLinesFromPtToCircle

Parameters

Returns Promise<TopoDSShapePointer[]>

Deprecated

Example

constraintTanLinesOnTwoCircles

Parameters

Returns Promise<TopoDSShapePointer[]>

Deprecated

Example

constraintTanCirclesOnTwoCircles

Parameters

Returns Promise<TopoDSShapePointer[]>

Deprecated

Example

constraintTanCirclesOnCircleAndPnt

Parameters

Returns Promise<TopoDSShapePointer[]>

Deprecated

Example

circlesTangentToThree

Parameters

Returns Promise<TopoDSEdgePointer[]>

Example

circlesTangentToTwoWithRadius

Parameters

Returns Promise<TopoDSEdgePointer[]>

Example

circlesTangentToTwoCenteredOn

Parameters

Returns Promise<TopoDSEdgePointer[]>

Example

linesTangentToTwo

Parameters

Returns Promise<TopoDSEdgePointer[]>

Example

linesTangentAtAngle

Parameters

Returns Promise<TopoDSEdgePointer[]>

Example

debug

debugInfo

Parameters

Returns Promise<EdgeDebugInfo>

Example

edit

splitEdgeAtParams

Parameters

Returns Promise<TopoDSEdgePointer[]>

Example

splitEdgeAtLengths

Parameters

Returns Promise<TopoDSEdgePointer[]>

Example