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 tangent constructions against circles; 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.
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
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:42957

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.
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
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:42979

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.
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
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:43002

constraintTanCirclesOnTwoCircles

constraintTanCirclesOnTwoCircles(
inputs: ConstraintTanCirclesOnTwoCirclesDto<TopoDSEdgePointer>,
): Promise<TopoDSShapePointer[]>
Draws the circles of a given radius that just touch two circles at once.
Parameters
- inputs: ConstraintTanCirclesOnTwoCirclesDto<TopoDSEdgePointer>
  The two circle edges, the tolerance and the radius of the new circles
Returns Promise<TopoDSShapePointer[]>
The tangent circles
Example
```
const circles = await bitbybit.occt.shapes.edge.constraintTanCirclesOnTwoCircles({ circle1, circle2, tolerance: 1e-7, radius: 3 });
```
- Defined in bitbybit-docs.d.ts:43015

constraintTanCirclesOnCircleAndPnt

constraintTanCirclesOnCircleAndPnt(
inputs: ConstraintTanCirclesOnCircleAndPntDto<TopoDSEdgePointer>,
): Promise<TopoDSShapePointer[]>
Draws the circles of a given radius that pass through a point and just touch a circle.
Parameters
- inputs: ConstraintTanCirclesOnCircleAndPntDto<TopoDSEdgePointer>
  The circle edge, the point, the tolerance and the radius of the new circles
Returns Promise<TopoDSShapePointer[]>
The tangent circles
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:43028

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:42212

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:42690

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:42703

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:42727

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:42754

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:42767

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:42781

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:42794

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:42808

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:42821

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:42834

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:42847

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:42860

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:42873

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:42890

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:42903

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:42919

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:42933

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:42473

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:42225

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:42238

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:42251

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:42264

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:42281

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:42295

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:42308

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:42324

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:42490

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:42504

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:42520

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:42533

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:42546

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:42562

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:42575

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:42588

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:42601

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:42615

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:42628

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:42740

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:42643

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:42658

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:42673

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:43041

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:43054

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:42337

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:42351

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:42367

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:42382

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:42398

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:42414

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:42427

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:42442

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:42165

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:42181

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:42197

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:42459

Class OCCTEdge

Index

Constructors

constraint

debug

extract

from

from base

get

get circular edge

is

primitives

rebuild

seam

shapes

Constructors

constructor

Returns OCCTEdge

constraint

constraintTanLinesFromTwoPtsToCircle

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

constraintTanLinesFromPtToCircle

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

constraintTanLinesOnTwoCircles

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

constraintTanCirclesOnTwoCircles

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

constraintTanCirclesOnCircleAndPnt

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

debug

debugInfo

Parameters

Returns Promise<EdgeDebugInfo>

Example

extract

pointOnEdgeAtParam

Parameters

Returns Promise<Point3>

Example

pointsOnEdgesAtParam

Parameters

Returns Promise<Point3[]>

Example

edgesToPoints

Parameters

Returns Promise<Point3[][]>

Example

tangentOnEdgeAtParam

Parameters

Returns Promise<Vector3>

Example

tangentsOnEdgesAtParam

Parameters

Returns Promise<Point3[]>

Example

pointOnEdgeAtLength

Parameters

Returns Promise<Point3>

Example

pointsOnEdgesAtLength

Parameters

Returns Promise<Point3[]>

Example

tangentOnEdgeAtLength

Parameters

Returns Promise<Vector3>

Example

tangentsOnEdgesAtLength

Parameters

Returns Promise<Vector3[]>