Class OCCTEdge

OpenCascade में एजेस: दो वर्टिसेस के बीच एकल कर्व, सीधे, वृत्ताकार, दीर्घवृत्ताकार या मुक्त-रूप। उन्हें पॉइंट और लाइनों से, आर्क, वृत्त और दीर्घवृत्त के रूप में, या वृत्तों के विरुद्ध स्पर्शरेखा निर्माणों के रूप में बनाएँ; उन्हें पॉइंट, लंबाइयों, स्पर्शरेखाओं और केंद्रों के रूप में वापस पढ़ें; और किसी भी शेप से एजेस चुनें। एजेस सिरे से सिरा जुड़कर वायर बनते हैं, जिन्हें shapes.wire संभालता है। एज के साथ पैरामीटर उसके आरंभ पर 0 से उसके अंत पर 1 तक चलते हैं; कोण डिग्री में हैं।

Index

Constructors

constructor

new OCCTEdge(): OCCTEdge
Returns OCCTEdge

constraint

constraintTanLinesFromTwoPtsToCircle

constraintTanLinesFromTwoPtsToCircle(
inputs: ConstraintTanLinesFromTwoPtsToCircleDto<TopoDSEdgePointer>,
): Promise<TopoDSShapePointer[]>
दो पॉइंट से वे सीधी लाइनें खींचता है जो वृत्त को बस छूती हैं, हर पॉइंट से एक स्पर्शरेखा।

positionResult वृत्त के एक ओर के हल या उन सभी को रखता है, और circleRemainder छूने वाले पॉइंट के बीच वृत्त का टुकड़ा जोड़ता है।
Parameters
- inputs: ConstraintTanLinesFromTwoPtsToCircleDto<TopoDSEdgePointer>
  वृत्त एज, दोनों पॉइंट, टॉलरेंस और कौन-से समाधान रखने हैं
Returns Promise<TopoDSShapePointer[]>
स्पर्शरेखा लाइनें, और माँगे जाने पर वृत्त का टुकड़ा
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[]>
एक पॉइंट से वे दो सीधी लाइनें खींचता है जो वृत्त को बस छूती हैं।

positionResult वृत्त के एक ओर का हल या दोनों रखता है, और circleRemainder छूने वाले पॉइंट के बीच वृत्त का टुकड़ा जोड़ता है।
Parameters
- inputs: ConstraintTanLinesFromPtToCircleDto<TopoDSEdgePointer>
  वृत्त एज, पॉइंट, टॉलरेंस और कौन-से समाधान रखने हैं
Returns Promise<TopoDSShapePointer[]>
स्पर्शरेखा लाइनें, और माँगे जाने पर वृत्त का टुकड़ा
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[]>
वे सीधी लाइनें खींचता है जो दो वृत्तों को एक साथ बस छूती हैं, जैसे दो पुली के चारों ओर बेल्ट।

positionResult एक ओर की लाइनें या उन सभी को रखता है, और circleRemainders छूने वाले पॉइंट के बीच वृत्तों के बाहरी या भीतरी टुकड़े जोड़ता है, जो बेल्ट की आकृति पूरी करता है।
Parameters
- inputs: ConstraintTanLinesOnTwoCirclesDto<TopoDSEdgePointer>
  दोनों वृत्त एजेस, टॉलरेंस और कौन-से समाधान और वृत्त के टुकड़े रखने हैं
Returns Promise<TopoDSShapePointer[]>
स्पर्शरेखा लाइनें, और माँगे जाने पर वृत्त के टुकड़े
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[]>
दी गई त्रिज्या के वे वृत्त खींचता है जो दो वृत्तों को एक साथ बस छूते हैं।
Parameters
- inputs: ConstraintTanCirclesOnTwoCirclesDto<TopoDSEdgePointer>
  दोनों वृत्त एजेस, टॉलरेंस और नए वृत्तों की त्रिज्या
Returns Promise<TopoDSShapePointer[]>
स्पर्शी वृत्त
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[]>
दी गई त्रिज्या के वे वृत्त खींचता है जो एक पॉइंट से गुज़रते हैं और एक वृत्त को बस छूते हैं।
Parameters
- inputs: ConstraintTanCirclesOnCircleAndPntDto<TopoDSEdgePointer>
  वृत्त एज, पॉइंट, टॉलरेंस और नए वृत्तों की त्रिज्या
Returns Promise<TopoDSShapePointer[]>
स्पर्शी वृत्त
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>
एज के वक्र के बारे में निदान तथ्य इकट्ठा करता है: उसका प्रकार और डिग्री, कंट्रोल पॉइंट और नॉट की गिनती, क्या वह रैशनल, आवर्ती या बंद है, उसकी पैरामीटर रेंज और अवधि, उसकी लंबाई और उसके अंतिम पॉइंट।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  जाँचा जाने वाला एज
Returns Promise<EdgeDebugInfo>
एज के कर्व के बारे में रिपोर्ट
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>
एज पर एक अंश की दूरी पर स्थित पॉइंट खोजता है: 0 शुरुआत है, 1 अंत, 0.5 पैरामीटर रेंज का मध्य।

अंश वक्र के अपने पैरामीटर का अनुसरण करता है, जो फ़्री-फ़ॉर्म वक्र के लिए लंबाई के हिसाब से समान रूप से नहीं फैला होता; दूरी के लिए pointOnEdgeAtLength का उपयोग करें।
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSEdgePointer>
  एज और 0 से 1 तक का अंश
Returns Promise<Point3>
एज पर स्थित पॉइंट
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[]>
सूची के हर एज पर एक ही अंश की दूरी पर स्थित पॉइंट खोजता है।
Parameters
- inputs: DataOnGeometryesAtParamDto<TopoDSEdgePointer>
  एजेस और 0 से 1 तक का अंश
Returns Promise<Point3[]>
प्रत्येक एज के लिए एक पॉइंट, उसी क्रम में
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[][]>
शेप के हर एज को पॉइंट की ऐसी शृंखला में बदलता है जो उसे ड्रॉ करने लायक बारीकी से उसके वक्र का अनुसरण करती है, प्रति एज एक सूची।

डिफ़्लेक्शन सेटिंग बताती हैं कि पॉइंट वक्र एजेस से कितनी कसकर चिपकते हैं; वायर के एजेस वायर के साथ अपने क्रम में आते हैं।
Parameters
- inputs: EdgesToPointsDto<TopoDSShapePointer>
  शेप और डिफ्लेक्शन सेटिंग्स
Returns Promise<Point3[][]>
प्रत्येक एज के लिए पॉइंट की एक सूची
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>
वह दिशा खोजता है जिसमें एज एक अंश की दूरी पर जा रहा है, शुरुआत में 0 से अंत में 1 तक।
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSEdgePointer>
  एज और 0 से 1 तक का अंश
Returns Promise<Vector3>
स्पर्शरेखा दिशा
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[]>
वह दिशा खोजता है जिसमें सूची का हर एज एक ही अंश की दूरी पर जा रहा है।
Parameters
- inputs: DataOnGeometryesAtParamDto<TopoDSEdgePointer>
  एजेस और 0 से 1 तक का अंश
Returns Promise<Point3[]>
प्रत्येक एज के लिए एक स्पर्शरेखा, उसी क्रम में
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>
एज पर उसकी शुरुआत से दी गई दूरी पर स्थित पॉइंट खोजता है, वक्र के साथ मॉडल इकाइयों में मापी गई।
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSEdgePointer>
  एज और उसके आरंभ से दूरी
Returns Promise<Point3>
एज पर स्थित पॉइंट
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[]>
सूची के हर एज पर शुरुआत से एक ही दूरी पर स्थित पॉइंट खोजता है।
Parameters
- inputs: DataOnGeometryesAtLengthDto<TopoDSEdgePointer>
  एजेस और आरंभ से दूरी
Returns Promise<Point3[]>
प्रत्येक एज के लिए एक पॉइंट, उसी क्रम में
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>
वह दिशा खोजता है जिसमें एज अपनी शुरुआत से दी गई दूरी पर जा रहा है, वक्र के साथ मापी गई।
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSEdgePointer>
  एज और उसके आरंभ से दूरी
Returns Promise<Vector3>
स्पर्शरेखा दिशा
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[]>
वह दिशा खोजता है जिसमें सूची का हर एज अपनी शुरुआत से एक ही दूरी पर जा रहा है।
Parameters
- inputs: DataOnGeometryesAtLengthDto<TopoDSEdgePointer>
  एजेस और आरंभ से दूरी
Returns Promise<Vector3[]>
प्रत्येक एज के लिए एक स्पर्शरेखा, उसी क्रम में
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>
वह पॉइंट पढ़ता है जहाँ एज शुरू होता है, एज की अपनी दिशा में।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  एज
Returns Promise<Point3>
आरंभ पॉइंट
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[]>
सूची के हर एज का शुरुआती पॉइंट पढ़ता है।
Parameters
- inputs: ShapesDto<TopoDSEdgePointer>
  एजेस
Returns Promise<Point3[]>
प्रत्येक एज के लिए एक आरंभ पॉइंट, उसी क्रम में
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>
वह पॉइंट पढ़ता है जहाँ एज खत्म होता है, एज की अपनी दिशा में।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  एज
Returns Promise<Point3>
अंत पॉइंट
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[]>
सूची के हर एज का अंतिम पॉइंट पढ़ता है।
Parameters
- inputs: ShapesDto<TopoDSEdgePointer>
  एजेस
Returns Promise<Point3[]>
प्रत्येक एज के लिए एक अंत पॉइंट, उसी क्रम में
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[]>
एज के साथ उसके पैरामीटर के समान चरणों पर पॉइंट रखता है, शुरुआत से अंत तक।

nrOfDivisions चरण उससे एक अधिक पॉइंट देते हैं; removeStartPoint और removeEndPoint सिरे हटाते हैं। फ़्री-फ़ॉर्म वक्र पर समान पैरामीटर चरण समान दूरियाँ नहीं होते; उनके लिए divideEdgeByEqualDistanceToPoints का उपयोग करें।
Parameters
- inputs: DivideDto<TopoDSEdgePointer>
  एज, विभाजनों की संख्या और क्या अंत पॉइंट छोड़ने हैं
Returns Promise<Point3[]>
एज के साथ के पॉइंट, क्रम में
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[][]>
सूची के हर एज के साथ उसके पैरामीटर के समान चरणों पर पॉइंट रखता है, प्रति एज एक सूची।
Parameters
- inputs: DivideShapesDto<TopoDSEdgePointer>
  एजेस, विभाजनों की संख्या और क्या अंत पॉइंट छोड़ने हैं
Returns Promise<Point3[][]>
प्रत्येक एज के लिए पॉइंट की एक सूची, उसी क्रम में
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[]>
एज के साथ उसके वक्र पर मापी गई समान दूरियों पर पॉइंट रखता है, शुरुआत से अंत तक।

nrOfDivisions चरण उससे एक अधिक पॉइंट देते हैं; removeStartPoint और removeEndPoint सिरे हटाते हैं।
Parameters
- inputs: DivideDto<TopoDSEdgePointer>
  एज, विभाजनों की संख्या और क्या अंत पॉइंट छोड़ने हैं
Returns Promise<Point3[]>
एज के साथ के पॉइंट, क्रम में
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[][]>
सूची के हर एज के साथ उसके वक्र पर समान दूरियों पर पॉइंट रखता है, प्रति एज एक सूची।
Parameters
- inputs: DivideShapesDto<TopoDSEdgePointer>
  एजेस, विभाजनों की संख्या और क्या अंत पॉइंट छोड़ने हैं
Returns Promise<Point3[][]>
प्रत्येक एज के लिए पॉइंट की एक सूची, उसी क्रम में
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>
सतह पर बिछाए गए 2D वक्र से एज बनाता है: वक्र सतह के UV स्पेस में रहता है और एज सतह के आर-पार उसका अनुसरण करता है।
Parameters
- inputs: CurveAndSurfaceDto<Geom2dCurvePointer, GeomSurfacePointer>
  2D कर्व और वह सतह जिस पर उसे रखना है
Returns Promise<TopoDSEdgePointer>
सतह पर एज
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>
{ start, end } रूप के लाइन ऑब्जेक्ट से सीधा एज बनाता है।
Parameters
- inputs: LineBaseDto
  लाइन
Returns Promise<TopoDSEdgePointer>
सीधा एज
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[]>
{ start, end } रूप के हर लाइन ऑब्जेक्ट के लिए एक सीधा एज बनाता है।
Parameters
- inputs: LinesBaseDto
  लाइनें
Returns Promise<TopoDSEdgePointer[]>
प्रत्येक लाइन के लिए एक एज, उसी क्रम में
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>
खंड, पॉइंट के युग्म [start, end], से सीधा एज बनाता है।
Parameters
- inputs: SegmentBaseDto
  सेगमेंट
Returns Promise<TopoDSEdgePointer>
सीधा एज
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[]>
हर खंड, हर एक पॉइंट का युग्म [start, end], के लिए एक सीधा एज बनाता है।
Parameters
- inputs: SegmentsBaseDto
  सेगमेंट
Returns Promise<TopoDSEdgePointer[]>
प्रत्येक सेगमेंट के लिए एक एज, उसी क्रम में
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[]>
हर पॉइंट को अगले से एक सीधे एज से जोड़ता है, ताकि पॉइंट की सूची एजेस की शृंखला बन जाए।

एजेस ढीले लौटाए जाते हैं; shapes.wire.createPolylineWire सीधे जुड़ा हुआ वायर बनाता है।
Parameters
- inputs: Bit.Inputs.OCCT.PointsDto
  पॉइंट, क्रम में
Returns Promise<TopoDSEdgePointer[]>
पड़ोसी पॉइंट के प्रत्येक जोड़े के लिए एक एज
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[]>
पॉलीलाइन ऑब्जेक्ट के हर खंड के लिए एक सीधा एज बनाता है; बंद पॉलीलाइन को उसके अंतिम पॉइंट से वापस पहले तक का एज भी मिलता है।
Parameters
- inputs: PolylineBaseDto
  पॉलीलाइन
Returns Promise<TopoDSEdgePointer[]>
प्रत्येक सेगमेंट के लिए एक एज, क्रम में
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[]>
तीन पॉइंट के रूप में दिए गए त्रिभुज के तीन सीधे एजेस बनाता है।
Parameters
- inputs: TriangleBaseDto
  त्रिभुज
Returns Promise<TopoDSEdgePointer[]>
उसके तीन एजेस
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[]>
मेश के हर त्रिभुज के तीन सीधे एजेस बनाता है, सभी एक सपाट सूची में।

जिस त्रिभुज के एजेस नहीं बनाए जा सकते उसे बाकी को रोकने के बजाय चेतावनी के साथ छोड़ दिया जाता है।
Parameters
- inputs: MeshBaseDto
  मेश, त्रिभुजों की सूची के रूप में
Returns Promise<TopoDSEdgePointer[]>
सभी त्रिभुजों के एजेस
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>
शेप में से एक एज उसकी स्थिति से चुनता है, 0 से गिनते हुए, उस क्रम में जिसमें कर्नेल शेप पर चलता है।

शेप एज, वायर या उनसे बनी कोई चीज़ होना चाहिए; अंतिम एज से आगे का इंडेक्स त्रुटि फेंकता है।
Parameters
- inputs: EdgeIndexDto<TopoDSShapePointer>
  शेप और 0-आधारित इंडेक्स
Returns Promise<TopoDSEdgePointer>
उस इंडेक्स पर एज
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[]>
शेप के हर एज को उस क्रम में सूचीबद्ध करता है जिसमें कर्नेल उस पर चलता है, जो वायर के साथ का क्रम नहीं है; उसके लिए getEdgesAlongWire का उपयोग करें।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<TopoDSEdgePointer[]>
शेप में मिले एजेस
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[]>
वायर के एजेस को उस क्रम में सूचीबद्ध करता है जिसमें वे उसके साथ एक-दूसरे के पीछे आते हैं, हर एक वायर की दिशा में चलने के लिए ओरिएंट किया हुआ।

एक अकेला एज एक-तत्व सूची के रूप में लौटाया जाता है।
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  वायर
Returns Promise<TopoDSEdgePointer[]>
वायर के साथ क्रम में उसके एजेस
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[]>
वायर के केवल वृत्तीय एजेस को उस क्रम में सूचीबद्ध करता है जिसमें वे उसके साथ एक-दूसरे के पीछे आते हैं।
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  वायर
Returns Promise<TopoDSEdgePointer[]>
क्रम में उसके वृत्ताकार एजेस
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[]>
वायर के केवल सीधे एजेस को उस क्रम में सूचीबद्ध करता है जिसमें वे उसके साथ एक-दूसरे के पीछे आते हैं।
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  वायर
Returns Promise<TopoDSEdgePointer[]>
क्रम में उसके सीधे एजेस
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[]>
शेप के हर एज के अंतिम पॉइंट सूचीबद्ध करता है, दोहराव हटाकर, ताकि वह कोना जहाँ कई एजेस मिलते हैं एक बार दिखे।

पॉइंट किसी विशेष क्रम में नहीं आते।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  वह शेप जिसके एजेस पढ़ने हैं: वायर, फेस, शैल या सॉलिड
Returns Promise<Point3[]>
एजेस के अद्वितीय अंत पॉइंट
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>
एज की लंबाई उसके वक्र के साथ, मॉडल इकाइयों में मापता है।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  एज
Returns Promise<number>
लंबाई
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[]>
शेप के हर एज को उसके वक्र के साथ, मॉडल इकाइयों में मापता है।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<number[]>
प्रत्येक एज के लिए एक लंबाई, उसी क्रम में जिसमें getEdges उन्हें सूचीबद्ध करता है
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[]>
सूची के हर एज को उसके वक्र के साथ, मॉडल इकाइयों में मापता है।
Parameters
- inputs: ShapesDto<TopoDSEdgePointer>
  एजेस
Returns Promise<number[]>
प्रत्येक एज के लिए एक लंबाई, उसी क्रम में
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>
एज का द्रव्यमान केंद्र, उसके वक्र का संतुलन बिंदु, खोजता है; सीधे एज के लिए वह उसका मध्य बिंदु है, चाप के लिए वक्र के भीतर का एक पॉइंट।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  एज
Returns Promise<Point3>
द्रव्यमान केंद्र का पॉइंट
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[]>
सूची के हर एज का द्रव्यमान केंद्र खोजता है।
Parameters
- inputs: ShapesDto<TopoDSEdgePointer>
  एजेस
Returns Promise<Point3[]>
प्रत्येक एज के लिए एक पॉइंट, उसी क्रम में
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>
एज की दिशा पलटता है, ताकि उसकी शुरुआत उसका अंत बन जाए।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  एज
Returns Promise<TopoDSEdgePointer>
विपरीत दिशा में जाने वाला एक नया एज
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>
उस वृत्त का केंद्र खोजता है जिस पर वृत्तीय एज स्थित है।

जो एज वृत्तीय नहीं है वह त्रुटि फेंकता है।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  वृत्ताकार एज
Returns Promise<Point3>
केंद्र पॉइंट
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>
उस वृत्त की त्रिज्या पढ़ता है जिस पर वृत्तीय एज स्थित है।

जो एज वृत्तीय नहीं है वह त्रुटि फेंकता है।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  वृत्ताकार एज
Returns Promise<number>
त्रिज्या, मॉडल इकाइयों में
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>
उस प्लेन का नॉर्मल पढ़ता है जिसमें वृत्तीय एज स्थित है।

जो एज वृत्तीय नहीं है वह त्रुटि फेंकता है।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  वृत्ताकार एज
Returns Promise<Vector3>
वृत्त के प्लेन का इकाई नॉर्मल
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>
बताता है कि एज सीधी रेखा है या नहीं।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  एज
Returns Promise<boolean>
true जब एज सीधा हो
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>
बताता है कि एज वृत्त पर स्थित है या नहीं, चाहे पूरा वृत्त हो या चाप।
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  एज
Returns Promise<boolean>
true जब एज वृत्ताकार हो
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>
दो पॉइंट के बीच सीधा एज बनाता है, सबसे सरल एज जो हो सकता है।
Parameters
- inputs: Bit.Inputs.OCCT.LineDto
  आरंभ और अंत पॉइंट
Returns Promise<TopoDSEdgePointer>
सीधा एज
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>
एक वृत्तीय चाप बनाता है जो पहले पॉइंट से शुरू होता है, बीच वाले से गुज़रता है और अंतिम पर खत्म होता है।
Parameters
- inputs: ArcEdgeThreePointsDto
  तीन पॉइंट
Returns Promise<TopoDSEdgePointer>
आर्क एज
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>
एक पॉइंट से दूसरे तक वृत्तीय चाप बनाता है जो पहले पॉइंट को दी गई दिशा में छोड़ता है।

स्पर्शरेखा चाप का प्लेन और त्रिज्या तय करती है।
Parameters
- inputs: ArcEdgeTwoPointsTangentDto
  आरंभ पॉइंट, वहाँ की स्पर्शरेखा दिशा और अंत पॉइंट
Returns Promise<TopoDSEdgePointer>
आर्क एज
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>
वृत्त एज में से उस पर स्थित दो पॉइंट के बीच एक चाप काटता है।

sense चुनता है कि चाप पहले पॉइंट से दूसरे तक वृत्त के किस ओर से चलता है।
Parameters
- inputs: ArcEdgeCircleTwoPointsDto<TopoDSEdgePointer>
  वृत्त एज, दोनों पॉइंट और चलने की दिशा
Returns Promise<TopoDSEdgePointer>
आर्क एज
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>
वृत्त एज में से दो कोणों के बीच एक चाप काटता है, डिग्री में, वृत्त की अपनी शुरुआत से उसके चारों ओर मापे गए।

sense चुनता है कि चाप पहले कोण से दूसरे तक वृत्त के किस ओर से चलता है।
Parameters
- inputs: ArcEdgeCircleTwoAnglesDto<TopoDSEdgePointer>
  वृत्त एज, दोनों कोण डिग्री में और चलने की दिशा
Returns Promise<TopoDSEdgePointer>
आर्क एज
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>
वृत्त एज में से एक चाप काटता है जो वृत्त पर स्थित एक पॉइंट से शुरू होता है और दिया गया कोण, डिग्री में, फैलाता है।

sense चुनता है कि चाप वृत्त के किस ओर से चलता है।
Parameters
- inputs: ArcEdgeCirclePointAngleDto<TopoDSEdgePointer>
  वृत्त एज, आरंभ पॉइंट, कोण डिग्री में और चलने की दिशा
Returns Promise<TopoDSEdgePointer>
आर्क एज
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>
पूरा वृत्त एक बंद एज के रूप में बनाता है, उस प्लेन में स्थित जिसका नॉर्मल direction है।
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  त्रिज्या, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSEdgePointer>
वृत्त एज
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>
पूरा दीर्घवृत्त एक बंद एज के रूप में बनाता है, उस प्लेन में स्थित जिसका नॉर्मल direction है।

radiusMajor radiusMinor से छोटा नहीं होना चाहिए, अन्यथा कर्नेल दीर्घवृत्त को अस्वीकार करता है।
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  केंद्र, प्लेन का नॉर्मल और दो त्रिज्याएँ
Returns Promise<TopoDSEdgePointer>
दीर्घवृत्त एज
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>
एज के वक्र को दी गई डिग्री के B-spline के रूप में, एक टॉलरेंस के भीतर, फिर से बनाता है।

डिग्री घटाना वक्र को सरल करता है, बढ़ाना बाद के ऑपरेशनों को अधिक स्वतंत्रता देता है; दोनों ही स्थितियों में नया वक्र पुराने के tolerance के भीतर रहता है।
Parameters
- inputs: RebuildCurveDegreeDto<TopoDSEdgePointer>
  एज, वह डिग्री जिस पर पुनर्निर्माण करना है और टॉलरेंस
Returns Promise<TopoDSEdgePointer>
पुनर्निर्मित कर्व वाला एक नया एज
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>
बंद आवर्ती एज की सीम, वह पॉइंट जहाँ वह शुरू और खत्म होता है, को वक्र पर दिए गए पैरामीटर तक ले जाता है।

ज्यामिति नहीं बदलती; केवल यह कि एज कहाँ से शुरू माना जाता है।
Parameters
- inputs: CurveSeamByParameterDto<TopoDSEdgePointer>
  आवर्ती एज और नई सीम का पैरामीटर
Returns Promise<TopoDSEdgePointer>
सीम से शुरू होने वाला एक नया एज
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>
बंद आवर्ती एज की सीम, वह पॉइंट जहाँ वह शुरू और खत्म होता है, को उसकी वर्तमान शुरुआत से वक्र के साथ एक दूरी तक ले जाता है।

ज्यामिति नहीं बदलती; केवल यह कि एज कहाँ से शुरू माना जाता है।
Parameters
- inputs: CurveSeamByLengthDto<TopoDSEdgePointer>
  आवर्ती एज और सीम को खिसकाने की दूरी
Returns Promise<TopoDSEdgePointer>
सीम से शुरू होने वाला एक नया एज
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>
एक ही सतह पर स्थित फेसेस और एक ही वक्र पर स्थित एजेस को मिलाता है, जो बूलियन या फ़्यूज़ द्वारा छोड़ी गई आंतरिक सीमों को हटाता है।

यह shapes.shape.unifySameDomain है जिसमें एजेस और फेसेस दोनों एकीकृत हैं और B-spline जैसे हैं वैसे छोड़े गए हैं।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<TopoDSShapePointer>
आंतरिक सीमों के बिना शेप
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[]>