Class OCCTWire

OpenCascade 中的线框：首尾相接的边链，可以像路径一样开放，也可以像轮廓一样闭合。可以从点和曲线（折线、B-spline、贝塞尔曲线、插值曲线、螺旋线、螺线）构建它们，构建为现成的平面轮廓（圆、矩形、星形、梁轮廓、文本），这些轮廓位于地平面上，除非 direction 另有指定，或者通过连接和分割现有的边和线框构建；将它们读回为点、切线、长度和中心；将它们映射到面上或投影到形状上。沿线框的参数从起点的 0 到终点的 1，并遵循每条边自身的参数而非距离。闭合线框是 shapes.face 用来填充生成面的对象。

Index

Constructors

constructor

new OCCTWire(): OCCTWire
Returns OCCTWire

beam profiles

createIBeamProfileWire

createIBeamProfileWire(inputs: IBeamProfileDto): Promise<TopoDSWirePointer>
创建工字梁横截面的闭合轮廓：由竖直腹板连接的两个水平翼缘。

width 是翼缘宽度，height 是总高度，webThickness 和 flangeThickness 是壁厚；alignment 指定轮廓盒的哪个点位于 center 上，rotation 使其在平面内转动，以度为单位。它位于地面上，可直接拉伸。
Parameters
- inputs: IBeamProfileDto
  轮廓尺寸、两个厚度、对齐方式、旋转、中心和平面法线
Returns Promise<TopoDSWirePointer>
工字梁轮廓线框
Example
```
const profile = await bitbybit.occt.shapes.wire.createIBeamProfileWire({
    width: 10,
    height: 20,
    webThickness: 2,
    flangeThickness: 3,
    alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
    rotation: 0,
    center: [0, 0, 0],
    direction: [0, 1, 0],
});
```
- Defined in bitbybit-docs.d.ts:46323

createHBeamProfileWire

createHBeamProfileWire(inputs: HBeamProfileDto): Promise<TopoDSWirePointer>
创建 H 形梁横截面的闭合轮廓：由水平腹板连接的两个竖直翼缘，即侧放的工字梁。

width 是总宽度，height 是翼缘高度，webThickness 和 flangeThickness 是壁厚；alignment 指定轮廓盒的哪个点位于 center 上，rotation 使其在平面内转动，以度为单位。
Parameters
- inputs: HBeamProfileDto
  轮廓尺寸、两个厚度、对齐方式、旋转、中心和平面法线
Returns Promise<TopoDSWirePointer>
H 形梁轮廓线框
Example
```
const profile = await bitbybit.occt.shapes.wire.createHBeamProfileWire({
    width: 20,
    height: 10,
    webThickness: 2,
    flangeThickness: 3,
    alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
    rotation: 0,
    center: [0, 0, 0],
    direction: [0, 1, 0],
});
```
- Defined in bitbybit-docs.d.ts:46350

createTBeamProfileWire

createTBeamProfileWire(inputs: TBeamProfileDto): Promise<TopoDSWirePointer>
创建 T 形梁横截面的闭合轮廓：一个水平翼缘，中间垂下一块竖直腹板。

width 是翼缘宽度，height 是总高度，webThickness 和 flangeThickness 是壁厚；alignment 指定轮廓盒的哪个点位于 center 上，rotation 使其在平面内转动，以度为单位。它位于地面上。
Parameters
- inputs: TBeamProfileDto
  轮廓尺寸、两个厚度、对齐方式、旋转、中心和平面法线
Returns Promise<TopoDSWirePointer>
T 形梁轮廓线框
Example
```
const profile = await bitbybit.occt.shapes.wire.createTBeamProfileWire({
    width: 10,
    height: 12,
    webThickness: 2,
    flangeThickness: 2,
    alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
    rotation: 0,
    center: [0, 0, 0],
    direction: [0, 1, 0],
});
```
- Defined in bitbybit-docs.d.ts:46377

createUBeamProfileWire

createUBeamProfileWire(inputs: UBeamProfileDto): Promise<TopoDSWirePointer>
创建 U 形梁（槽钢）横截面的闭合轮廓：一块腹板，两端立起两个宽为 flangeWidth 的翼缘。

width 和 height 是总尺寸，webThickness 和 flangeThickness 是壁厚；alignment 指定轮廓盒的哪个点位于 center 上，rotation 使其在平面内转动，以度为单位。它位于地面上。
Parameters
- inputs: UBeamProfileDto
  轮廓尺寸、厚度、翼缘宽度、对齐方式、旋转、中心和平面法线
Returns Promise<TopoDSWirePointer>
U 形梁轮廓线框
Example
```
const profile = await bitbybit.occt.shapes.wire.createUBeamProfileWire({
    width: 10,
    height: 6,
    webThickness: 1,
    flangeThickness: 1,
    flangeWidth: 3,
    alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
    rotation: 0,
    center: [0, 0, 0],
    direction: [0, 1, 0],
});
```
- Defined in bitbybit-docs.d.ts:46405

build

combineEdgesAndWiresIntoAWire

combineEdgesAndWiresIntoAWire(
inputs: ShapesDto<TopoDSEdgePointer | TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
将首尾相接的边和线框连接成一个线框。

各部分必须相连；有缺口或有游离部分的集合会抛出错误。列表中其他种类的形状被忽略。
Parameters
- inputs: ShapesDto<TopoDSEdgePointer | TopoDSWirePointer>
  要连接的边和线框
Returns Promise<TopoDSWirePointer>
连接后的线框
Example
```
const outline = await bitbybit.occt.shapes.wire.combineEdgesAndWiresIntoAWire({ shapes: [arc, line1, line2] });
```
- Defined in bitbybit-docs.d.ts:45827

createWireFromEdge

createWireFromEdge(
inputs: ShapeDto<TopoDSEdgePointer>,
): Promise<TopoDSWirePointer>
将单条边包装成线框，使其可以用在需要线框的地方。
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  边
Returns Promise<TopoDSWirePointer>
容纳该边的线框
Example
```
const wire = await bitbybit.occt.shapes.wire.createWireFromEdge({ shape: edge });
```
- Defined in bitbybit-docs.d.ts:45840

addEdgesAndWiresToWire

addEdgesAndWiresToWire(
    inputs: ShapeShapesDto<
        TopoDSWirePointer,
        TopoDSEdgePointer
        | TopoDSWirePointer,
    >,
): Promise<TopoDSWirePointer>
用与线框首尾相接的更多边和线框来延长它。

各部分必须与线框或彼此相连；缺口会抛出错误。列表中其他种类的形状被忽略。
Parameters
- inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSEdgePointer | TopoDSWirePointer>
  要扩展的线框以及要添加的边和线框
Returns Promise<TopoDSWirePointer>
扩展后的线框
Example
```
const longer = await bitbybit.occt.shapes.wire.addEdgesAndWiresToWire({ shape: wire, shapes: [nextEdge, nextWire] });
```
- Defined in bitbybit-docs.d.ts:45856

debug

debugInfo

debugInfo(inputs: ShapeDto<TopoDSWirePointer>): Promise<WireDebugInfo>
收集关于线框的诊断信息：它有多少条边、是否闭合、其总长度，以及每条边由 shapes.edge.debugInfo 给出的曲线报告。

空的或 null 的线框给出标记为无效且计数为零的报告。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  要检查的线框
Returns Promise<WireDebugInfo>
包含边数、闭合标志、长度以及每条边一个条目的报告
Example
```
const info = await bitbybit.occt.shapes.wire.debugInfo({ shape: wire });
console.log(info.nbEdges, info.closed, info.totalLength);
```
- Defined in bitbybit-docs.d.ts:45300

edit

closeOpenWire

closeOpenWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<TopoDSWirePointer>
用从终点回到起点的直边闭合开放线框。

两端已相接的线框原样返回。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  要闭合的线框
Returns Promise<TopoDSWirePointer>
闭合线框
Example
```
const closedWire = await bitbybit.occt.shapes.wire.closeOpenWire({ shape: openWire });
```
- Defined in bitbybit-docs.d.ts:46717

extract

splitOnPoints

splitOnPoints(
inputs: SplitWireOnPointsDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer[]>
在给定的点处将线框切成几段。

切割前每个点都被移到线框上最近的位置，因此它不必精确位于线框上；重复的点被忽略。各段按沿线框从起点到终点的顺序返回。
Parameters
- inputs: SplitWireOnPointsDto<TopoDSWirePointer>
  线框和切割点
Returns Promise<TopoDSWirePointer[]>
线框的各段，按顺序排列
Example
```
const pieces = await bitbybit.occt.shapes.wire.splitOnPoints({ shape: wire, points: [[3, 0, 0], [7, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:45511

wiresToPoints

wiresToPoints(inputs: WiresToPointsDto<TopoDSShapePointer>): Promise<Point3[][]>
将形状的每个线框转成一串足以描绘其曲线的点，每个线框一个列表。

偏差设置决定点贴合弯曲边的紧密程度；一条边结束、下一条边开始处的共享点只出现一次。
Parameters
- inputs: WiresToPointsDto<TopoDSShapePointer>
  形状和挠度设置
Returns Promise<Point3[][]>
每个线框一个点列表
Example
```
const polylines = await bitbybit.occt.shapes.wire.wiresToPoints({
    shape: wire,
    angularDeflection: 0.1,
    curvatureDeflection: 0.1,
    minimumOfPoints: 2,
    uTolerance: 1e-9,
    minimumLength: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:45535

divideWireByParamsToPoints

divideWireByParamsToPoints(
inputs: DivideDto<TopoDSWirePointer>,
): Promise<Point3[]>
从起点到终点，以参数的等步长沿线框放置点。

nrOfDivisions 步给出比该数多一个的点；removeStartPoint 和 removeEndPoint 丢弃两端。参数遵循每条边自身的曲线参数，因此等步长并不是等距离；需要等距离时使用 divideWireByEqualDistanceToPoints。
Parameters
- inputs: DivideDto<TopoDSWirePointer>
  线框、分段数以及是否去掉端点
Returns Promise<Point3[]>
沿线框的点，按顺序排列
Example
```
const points = await bitbybit.occt.shapes.wire.divideWireByParamsToPoints({ shape: wire, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:45873

divideWireByEqualDistanceToPoints

divideWireByEqualDistanceToPoints(
inputs: DivideDto<TopoDSWirePointer>,
): Promise<Point3[]>
从起点到终点，以沿其曲线测量的等距离沿线框放置点。

nrOfDivisions 步给出比该数多一个的点；removeStartPoint 和 removeEndPoint 丢弃两端。
Parameters
- inputs: DivideDto<TopoDSWirePointer>
  线框、分段数以及是否去掉端点
Returns Promise<Point3[]>
沿线框的点，按顺序排列
Example
```
const points = await bitbybit.occt.shapes.wire.divideWireByEqualDistanceToPoints({ shape: wire, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:45902

pointOnWireAtParam

pointOnWireAtParam(
inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>,
): Promise<Point3>
找出线框上某一分数位置处的点：0 是起点，1 是终点。

分数遵循各边的参数而不是距离，因此 0.5 并不总是按长度的中点；需要按距离时使用 pointOnWireAtLength。
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  线框和 0 到 1 的比例
Returns Promise<Point3>
线框上的点
Example
```
const point = await bitbybit.occt.shapes.wire.pointOnWireAtParam({ shape: wire, param: 0.25 });
```
- Defined in bitbybit-docs.d.ts:45931

pointOnWireAtLength

pointOnWireAtLength(
inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>,
): Promise<Point3>
找出线框上距其起点给定距离处的点，沿其曲线以模型单位测量。
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  线框和距其起点的距离
Returns Promise<Point3>
线框上的点
Example
```
const point = await bitbybit.occt.shapes.wire.pointOnWireAtLength({ shape: wire, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:45945

pointsOnWireAtLengths

pointsOnWireAtLengths(
inputs: DataOnGeometryAtLengthsDto<TopoDSWirePointer>,
): Promise<Point3[]>
找出线框上距其起点多个距离处的点，沿其曲线以模型单位测量。
Parameters
- inputs: DataOnGeometryAtLengthsDto<TopoDSWirePointer>
  线框和距其起点的各个距离
Returns Promise<Point3[]>
每个距离一个点，顺序相同
Example
```
const points = await bitbybit.occt.shapes.wire.pointsOnWireAtLengths({ shape: wire, lengths: [1, 2.5, 4] });
```
- Defined in bitbybit-docs.d.ts:45959

pointsOnWireAtEqualLength

pointsOnWireAtEqualLength(
inputs: PointsOnWireAtEqualLengthDto<TopoDSWirePointer>,
): Promise<Point3[]>
从线框起点开始每隔 length 个模型单位放置一个点，能放多少放多少。

includeFirst 保留起点处的点，includeLast 不论间距如何都追加终点，tryNext 请求在最后一个放得下的点之外再多放一步的一个点。
Parameters
- inputs: PointsOnWireAtEqualLengthDto<TopoDSWirePointer>
  线框、间距以及要包含哪些端点
Returns Promise<Point3[]>
沿线框的点，按顺序排列
Example
```
const points = await bitbybit.occt.shapes.wire.pointsOnWireAtEqualLength({ shape: wire, length: 2, tryNext: false, includeFirst: true, includeLast: false });
```
- Defined in bitbybit-docs.d.ts:45975

pointsOnWireAtPatternOfLengths

pointsOnWireAtPatternOfLengths(
inputs: PointsOnWireAtPatternOfLengthsDto<TopoDSWirePointer>,
): Promise<Point3[]>
沿线框按重复的间隔模式放置点，例如 1, 3, 1, 3，直到线框用完。

lengths 是以模型单位表示、从起点开始重复的间隔模式；includeFirst 保留起点，includeLast 追加终点，tryNext 请求在最后一个点之后的下一个间隔处再多放一个点。
Parameters
- inputs: PointsOnWireAtPatternOfLengthsDto<TopoDSWirePointer>
  线框、间隔模式以及要包含哪些端点
Returns Promise<Point3[]>
沿线框的点，按顺序排列
Example
```
const points = await bitbybit.occt.shapes.wire.pointsOnWireAtPatternOfLengths({ shape: wire, lengths: [1, 3], tryNext: false, includeFirst: true, includeLast: false });
```
- Defined in bitbybit-docs.d.ts:45993

tangentOnWireAtParam

tangentOnWireAtParam(
inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>,
): Promise<Vector3>
找出线框在某一分数位置处的前进方向，从起点的 0 到终点的 1。

分数遵循各边的参数而不是距离。
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  线框和 0 到 1 的比例
Returns Promise<Vector3>
切线方向
Example
```
const tangent = await bitbybit.occt.shapes.wire.tangentOnWireAtParam({ shape: wire, param: 0.5 });
```
- Defined in bitbybit-docs.d.ts:46009

tangentOnWireAtLength

tangentOnWireAtLength(
inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>,
): Promise<Vector3>
找出线框在距其起点给定距离处的前进方向，沿其曲线以模型单位测量。
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  线框和距其起点的距离
Returns Promise<Vector3>
切线方向
Example
```
const tangent = await bitbybit.occt.shapes.wire.tangentOnWireAtLength({ shape: wire, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:46023

derivativesOnWireAtLength

derivativesOnWireAtLength(
inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>,
): Promise<[Vector3, Vector3, Vector3]>
计算线框曲线在距其起点给定距离处的一阶、二阶和三阶导数。

一阶导数是带速度的切线，二阶表示曲线如何弯曲，三阶表示该弯曲如何变化；全部相对于曲线的参数。距离沿曲线以模型单位测量。
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  线框和距其起点的距离
Returns Promise<[Vector3, Vector3, Vector3]>
三个导数向量，从一阶到三阶
Example
```
const [first, second, third] = await bitbybit.occt.shapes.wire.derivativesOnWireAtLength({ shape: wire, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:46041

derivativesOnWireAtParam

derivativesOnWireAtParam(
inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>,
): Promise<[Vector3, Vector3, Vector3]>
计算线框曲线在某一分数位置处的一阶、二阶和三阶导数，从起点的 0 到终点的 1。

一阶导数是带速度的切线，二阶表示曲线如何弯曲，三阶表示该弯曲如何变化；全部相对于曲线的参数。
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  线框和 0 到 1 的比例
Returns Promise<[Vector3, Vector3, Vector3]>
三个导数向量，从一阶到三阶
Example
```
const [first, second, third] = await bitbybit.occt.shapes.wire.derivativesOnWireAtParam({ shape: wire, param: 0.5 });
```
- Defined in bitbybit-docs.d.ts:46058

startPointOnWire

startPointOnWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<Point3>
读取线框开始的点，按线框自身的方向。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  线框
Returns Promise<Point3>
起点
Example
```
const start = await bitbybit.occt.shapes.wire.startPointOnWire({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:46071

midPointOnWire

midPointOnWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<Point3>
找出线框参数范围一半处的点。

参数遵循各边自身的曲线而不是距离，因此在边长不等的线框上这并不总是按长度的中点；pointOnWireAtLength 配合 getWireLength 的一半可给出那个点。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  线框
Returns Promise<Point3>
参数 0.5 处的点
Example
```
const middle = await bitbybit.occt.shapes.wire.midPointOnWire({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:46088

endPointOnWire

endPointOnWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<Point3>
读取线框结束的点，按线框自身的方向。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  线框
Returns Promise<Point3>
终点
Example
```
const end = await bitbybit.occt.shapes.wire.endPointOnWire({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:46101

extract from wires

divideWiresByParamsToPoints

divideWiresByParamsToPoints(
inputs: DivideShapesDto<TopoDSWirePointer>,
): Promise<Point3[][]>
用相同的设置对多个线框运行 divideWireByParamsToPoints。
Parameters
- inputs: DivideShapesDto<TopoDSWirePointer>
  线框、分段数以及是否去掉端点
Returns Promise<Point3[][]>
每个线框一个点列表，顺序相同
Example
```
const lists = await bitbybit.occt.shapes.wire.divideWiresByParamsToPoints({ shapes: wires, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:45886

divideWiresByEqualDistanceToPoints

divideWiresByEqualDistanceToPoints(
inputs: DivideShapesDto<TopoDSWirePointer>,
): Promise<Point3[][]>
用相同的设置对多个线框运行 divideWireByEqualDistanceToPoints。
Parameters
- inputs: DivideShapesDto<TopoDSWirePointer>
  线框、分段数以及是否去掉端点
Returns Promise<Point3[][]>
每个线框一个点列表，顺序相同
Example
```
const lists = await bitbybit.occt.shapes.wire.divideWiresByEqualDistanceToPoints({ shapes: wires, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:45915

from base

fromBaseLine

fromBaseLine(inputs: LineBaseDto): Promise<TopoDSWirePointer>
由形如 { start, end } 的直线对象创建直的单边线框。
Parameters
- inputs: LineBaseDto
  直线
Returns Promise<TopoDSWirePointer>
直线框
Example
```
const wire = await bitbybit.occt.shapes.wire.fromBaseLine({ line: { start: [0, 0, 0], end: [10, 0, 0] } });
```
- Defined in bitbybit-docs.d.ts:45313

fromBaseLines

fromBaseLines(inputs: LinesBaseDto): Promise<TopoDSWirePointer[]>
为每个形如 { start, end } 的直线对象创建一个直的单边线框。
Parameters
- inputs: LinesBaseDto
  直线
Returns Promise<TopoDSWirePointer[]>
每条直线一个线框，顺序相同
Example
```
const wires = await bitbybit.occt.shapes.wire.fromBaseLines({ lines: [{ start: [0, 0, 0], end: [10, 0, 0] }, { start: [10, 0, 0], end: [10, 10, 0] }] });
```
- Defined in bitbybit-docs.d.ts:45326

fromBaseSegment

fromBaseSegment(inputs: SegmentBaseDto): Promise<TopoDSWirePointer>
由线段（一对点 [start, end]）创建直的单边线框。
Parameters
- inputs: SegmentBaseDto
  线段
Returns Promise<TopoDSWirePointer>
直线框
Example
```
const wire = await bitbybit.occt.shapes.wire.fromBaseSegment({ segment: [[0, 0, 0], [10, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:45339

fromBaseSegments

fromBaseSegments(inputs: SegmentsBaseDto): Promise<TopoDSWirePointer[]>
为每条线段（各为一对点 [start, end]）创建一个直的单边线框。
Parameters
- inputs: SegmentsBaseDto
  线段
Returns Promise<TopoDSWirePointer[]>
每条线段一个线框，顺序相同
Example
```
const wires = await bitbybit.occt.shapes.wire.fromBaseSegments({ segments: [[[0, 0, 0], [10, 0, 0]], [[10, 0, 0], [10, 10, 0]]] });
```
- Defined in bitbybit-docs.d.ts:45352

fromPoints

fromPoints(inputs: Bit.Inputs.OCCT.PointsDto): Promise<TopoDSWirePointer>
将一列点按顺序用直边连接成一个线框。

少于两个点会抛出错误。当最后一个点与第一个点重复时，该重复点被丢弃，线框闭合回到第一个点；否则线框保持开放。要得到不重复点的闭合轮廓，请使用 createPolygonWire。
Parameters
- inputs: Bit.Inputs.OCCT.PointsDto
  按顺序排列的点
Returns Promise<TopoDSWirePointer>
经过这些点的线框
Example
```
const path = await bitbybit.occt.shapes.wire.fromPoints({ points: [[0, 0, 0], [10, 0, 0], [10, 10, 0]] });
const outline = await bitbybit.occt.shapes.wire.fromPoints({ points: [[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:45370

fromBasePolyline

fromBasePolyline(inputs: PolylineBaseDto): Promise<TopoDSWirePointer>
由折线对象创建线框，每段一条直边；标记为闭合的折线还会得到从其最后一个点回到第一个点的边。
Parameters
- inputs: PolylineBaseDto
  折线
Returns Promise<TopoDSWirePointer>
线框
Example
```
const outline = await bitbybit.occt.shapes.wire.fromBasePolyline({ polyline: { points: [[0, 0, 0], [10, 0, 0], [10, 0, 10]], isClosed: true } });
```
- Defined in bitbybit-docs.d.ts:45384

fromBaseTriangle

fromBaseTriangle(inputs: TriangleBaseDto): Promise<TopoDSWirePointer>
由以三个点给出的三角形创建闭合的三边线框。
Parameters
- inputs: TriangleBaseDto
  三角形
Returns Promise<TopoDSWirePointer>
闭合线框
Example
```
const outline = await bitbybit.occt.shapes.wire.fromBaseTriangle({ triangle: [[0, 0, 0], [10, 0, 0], [0, 0, 10]] });
```
- Defined in bitbybit-docs.d.ts:45397

fromBaseMesh

fromBaseMesh(inputs: MeshBaseDto): Promise<TopoDSWirePointer[]>
为网格的每个三角形创建一个闭合的三边线框。

无法构建其线框的三角形会带着警告被跳过，而不是中止其余部分。
Parameters
- inputs: MeshBaseDto
  以三角形列表表示的网格
Returns Promise<TopoDSWirePointer[]>
每个能够构建的三角形一个线框
Example
```
const outlines = await bitbybit.occt.shapes.wire.fromBaseMesh({ mesh: triangles });
```
- Defined in bitbybit-docs.d.ts:45413

get

getWire

getWire(inputs: ShapeIndexDto<TopoDSShapePointer>): Promise<TopoDSWirePointer>
按位置从形状中选取一个线框，从 0 开始计数，顺序为内核遍历形状的顺序。

形状必须是线框或由线框构建的东西；超出最后一个线框的索引会抛出错误。
Parameters
- inputs: ShapeIndexDto<TopoDSShapePointer>
  形状和从 0 开始的索引
Returns Promise<TopoDSWirePointer>
该索引处的线框
Example
```
const outer = await bitbybit.occt.shapes.wire.getWire({ shape: face, index: 0 });
```
- Defined in bitbybit-docs.d.ts:46556

getWires

getWires(inputs: ShapeDto<TopoDSShapePointer>): Promise<TopoDSWirePointer[]>
按内核遍历的顺序列出形状的每个线框。
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  形状
Returns Promise<TopoDSWirePointer[]>
形状中找到的线框
Example
```
const wires = await bitbybit.occt.shapes.wire.getWires({ shape: face });
```
- Defined in bitbybit-docs.d.ts:46569

getWireCenterOfMass

getWireCenterOfMass(inputs: ShapeDto<TopoDSWirePointer>): Promise<Point3>
找出线框的质心，即其曲线的平衡点；对于圆这是其圆心，不在线框本身上。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  线框
Returns Promise<Point3>
质心点
Example
```
const center = await bitbybit.occt.shapes.wire.getWireCenterOfMass({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:46583

getWiresCentersOfMass

getWiresCentersOfMass(inputs: ShapesDto<TopoDSWirePointer>): Promise<Point3[]>
找出列表中每个线框的质心。
Parameters
- inputs: ShapesDto<TopoDSWirePointer>
  线框
Returns Promise<Point3[]>
每个线框一个点，顺序相同
Example
```
const centers = await bitbybit.occt.shapes.wire.getWiresCentersOfMass({ shapes: wires });
```
- Defined in bitbybit-docs.d.ts:46596

reversedWire

reversedWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<TopoDSWirePointer>
翻转线框的方向，使其起点变为终点。

各边保留自己的顺序和方向标志；线框整体被标记为反转，这是大多数操作所读取的。reversedWireFromReversedEdges 则逐边重建线框。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  线框
Returns Promise<TopoDSWirePointer>
一个方向相反的新线框
Example
```
const back = await bitbybit.occt.shapes.wire.reversedWire({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:46613

reversedWireFromReversedEdges

reversedWireFromReversedEdges(
inputs: ShapeDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
通过反转每条边并按相反顺序重新连接来翻转线框的方向。

结果是彻底反向的线框，某些操作在单纯的 reversedWire 标志不够用时需要它。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  线框
Returns Promise<TopoDSWirePointer>
一个方向相反的新线框
Example
```
const back = await bitbybit.occt.shapes.wire.reversedWireFromReversedEdges({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:46630

isWireClosed

isWireClosed(inputs: ShapeDto<TopoDSWirePointer>): Promise<boolean>
判断线框是否闭合，即其起点和终点在很小的容差内重合。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  线框
Returns Promise<boolean>
当两端相接时为 true
Example
```
const wireIsClosed = await bitbybit.occt.shapes.wire.isWireClosed({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:46644

getWireLength

getWireLength(inputs: ShapeDto<TopoDSWirePointer>): Promise<number>
沿曲线测量线框的长度，以模型单位表示。
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  线框
Returns Promise<number>
长度
Example
```
const len = await bitbybit.occt.shapes.wire.getWireLength({ shape: wire });
```
- Defined in bitbybit-docs.d.ts:46657

getWiresLengths

getWiresLengths(inputs: ShapesDto<TopoDSWirePointer>): Promise<number[]>
沿曲线测量列表中每个线框的长度，以模型单位表示。
Parameters
- inputs: ShapesDto<TopoDSWirePointer>
  线框
Returns Promise<number[]>
每个线框一个长度，顺序相同
Example
```
const lengths = await bitbybit.occt.shapes.wire.getWiresLengths({ shapes: wires });
```
- Defined in bitbybit-docs.d.ts:46670

multiple

createPolygons

createPolygons(
inputs: PolygonsDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
为每个点列表创建一个闭合多边形线框，与 createPolygonWire 所做的相同。

returnCompound 为 true 时，线框被打包成一个复合体形状而不是列表。
Parameters
- inputs: PolygonsDto
  多边形以及是否将它们打包为一个复合体
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
按顺序排列的线框，或容纳它们的一个复合体
Example
```
const outlines = await bitbybit.occt.shapes.wire.createPolygons({
    polygons: [{ points: [[0, 0, 0], [5, 0, 0], [5, 0, 5]] }, { points: [[10, 0, 0], [15, 0, 0], [15, 0, 5]] }],
    returnCompound: false,
});
```
- Defined in bitbybit-docs.d.ts:45447

createLines

createLines(
inputs: Bit.Inputs.OCCT.LinesDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
为每个直线定义创建一个直的单边线框。

returnCompound 为 true 时，线框被打包成一个复合体形状而不是列表。
Parameters
- inputs: Bit.Inputs.OCCT.LinesDto
  直线以及是否将它们打包为一个复合体
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
按顺序排列的线框，或容纳它们的一个复合体
Example
```
const lines = await bitbybit.occt.shapes.wire.createLines({
    lines: [{ start: [0, 0, 0], end: [10, 0, 0] }, { start: [0, 0, 5], end: [10, 0, 5] }],
    returnCompound: false,
});
```
- Defined in bitbybit-docs.d.ts:45494

createPolylines

createPolylines(
inputs: Bit.Inputs.OCCT.PolylinesDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
为每个点列表创建一个开放折线线框，与 createPolylineWire 所做的相同。

returnCompound 为 true 时，线框被打包成一个复合体形状而不是列表。
Parameters
- inputs: Bit.Inputs.OCCT.PolylinesDto
  折线以及是否将它们打包为一个复合体
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
按顺序排列的线框，或容纳它们的一个复合体
Example
```
const paths = await bitbybit.occt.shapes.wire.createPolylines({
    polylines: [{ points: [[0, 0, 0], [5, 0, 0], [5, 0, 5]] }, { points: [[10, 0, 0], [15, 0, 0]] }],
    returnCompound: false,
});
```
- Defined in bitbybit-docs.d.ts:45658

createBezierWires

createBezierWires(
inputs: BezierWiresDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
为每个定义创建一个 Bezier 线框，与 createBezier 所做的相同。

returnCompound 为 true 时，线框被打包成一个复合体形状而不是列表。
Parameters
- inputs: BezierWiresDto
  贝塞尔定义以及是否将它们打包为一个复合体
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
按顺序排列的线框，或容纳它们的一个复合体
Example
```
const curves = await bitbybit.occt.shapes.wire.createBezierWires({
    bezierWires: [{ points: [[0, 0, 0], [5, 0, 10], [10, 0, 0]], closed: false }, { points: [[0, 0, 5], [5, 0, 15], [10, 0, 5]], closed: false }],
    returnCompound: false,
});
```
- Defined in bitbybit-docs.d.ts:45716

interpolateWires

interpolateWires(
inputs: InterpolateWiresDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
为每个定义创建一个插值的 B-spline 线框，与 interpolatePoints 所做的相同。

returnCompound 为 true 时，线框被打包成一个复合体形状而不是列表。
Parameters
- inputs: InterpolateWiresDto
  插值定义以及是否将它们打包为一个复合体
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
按顺序排列的线框，或容纳它们的一个复合体
Example
```
const curves = await bitbybit.occt.shapes.wire.interpolateWires({
    interpolations: [{ points: [[0, 0, 0], [5, 0, 5], [10, 0, 0]], periodic: false, tolerance: 1e-7 }, { points: [[0, 0, 5], [5, 0, 10], [10, 0, 5]], periodic: false, tolerance: 1e-7 }],
    returnCompound: false,
});
```
- Defined in bitbybit-docs.d.ts:45775

createBSplines

createBSplines(
inputs: BSplinesDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
为每个定义创建一个逼近的 B-spline 线框，与 createBSpline 所做的相同。

returnCompound 为 true 时，线框被打包成一个复合体形状而不是列表。
Parameters
- inputs: BSplinesDto
  B-spline 定义以及是否将它们打包为一个复合体
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
按顺序排列的线框，或容纳它们的一个复合体
Example
```
const curves = await bitbybit.occt.shapes.wire.createBSplines({
    bSplines: [{ points: [[0, 0, 0], [5, 0, 5], [10, 0, 0]], closed: false }, { points: [[0, 0, 5], [5, 0, 10], [10, 0, 5]], closed: false }],
    returnCompound: false,
});
```
- Defined in bitbybit-docs.d.ts:45811

place

placeWireOnFace

placeWireOnFace(
inputs: WireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>,
): Promise<TopoDSWirePointer>
将绘制在地平面上的平面线框映射到面的曲面上，就像把图案包在它上面一样。

线框的 Z 坐标被读作 U，X 坐标被读作 V，采用面的真实 UV 值，即 shapes.face.getUMinBound 及其同类方法报告的值；能放入这些边界内的图案会落在面上。
Parameters
- inputs: WireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  地平面上的线框和面
Returns Promise<TopoDSWirePointer>
位于面的曲面上的线框
Example
```
const onSurface = await bitbybit.occt.shapes.wire.placeWireOnFace({ wire: flatWire, face: cylinderFace });
```
- Defined in bitbybit-docs.d.ts:46688

placeWiresOnFace

placeWiresOnFace(
inputs: WiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>,
): Promise<TopoDSWirePointer[]>
将绘制在地平面上的多个平面线框映射到面的曲面上，与 placeWireOnFace 对一个线框所做的相同。
Parameters
- inputs: WiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  地平面上的线框和面
Returns Promise<TopoDSWirePointer[]>
位于面的曲面上的线框，顺序相同
Example
```
const onSurface = await bitbybit.occt.shapes.wire.placeWiresOnFace({ wires: flatWires, face: cylinderFace });
```
- Defined in bitbybit-docs.d.ts:46702

project

project(
inputs: ProjectWireDto<TopoDSWirePointer, TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer>
沿某方向将线框投射到形状上，就像将其影子投到曲面上。

结果是投射与形状各面相交处曲线的复合体，可能同时出现在其近侧和远侧。可通过 shapes.face.createFaceFromWireOnFace 用它切割面，或将其用作路径。
Parameters
- inputs: ProjectWireDto<TopoDSWirePointer, TopoDSShapePointer>
  线框、投影目标形状和方向
Returns Promise<TopoDSCompoundPointer>
投影曲线的复合体
Example
```
const shadow = await bitbybit.occt.shapes.wire.project({ wire: circle, shape: sphere, direction: [0, -1, 0] });
```
- Defined in bitbybit-docs.d.ts:46734

projectWires

projectWires(
inputs: ProjectWiresDto<TopoDSWirePointer, TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer[]>
沿一个方向将多个线框投射到形状上，与 project 对一个线框所做的相同。
Parameters
- inputs: ProjectWiresDto<TopoDSWirePointer, TopoDSShapePointer>
  线框、投影目标形状和方向
Returns Promise<TopoDSCompoundPointer[]>
每个线框一个投影曲线复合体，顺序相同
Example
```
const shadows = await bitbybit.occt.shapes.wire.projectWires({ wires: [circle, square], shape: sphere, direction: [0, -1, 0] });
```
- Defined in bitbybit-docs.d.ts:46747

primitives

createCircleWire

createCircleWire(inputs: Bit.Inputs.OCCT.CircleDto): Promise<TopoDSWirePointer>
创建一个完整的圆作为闭合的单边线框，位于法线为 direction 的平面内；默认的 [0, 1, 0] 将其平放在地面上。
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  半径、中心和平面法线
Returns Promise<TopoDSWirePointer>
圆线框
Example
```
const circle = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:46115

hexagonsInGrid

hexagonsInGrid(inputs: HexagonsInGridDto): Promise<TopoDSWirePointer[]>
在地平面上用闭合六边形线框的网格填充一个矩形，以原点为中心。

六边形被缩放，使 nrHexagonsInWidth 个横跨 width，nrHexagonsInHeight 个横跨 height。缩放、圆角和包含模式逐个六边形读取并重复；扩展标志将外侧行拉伸到边缘之外以覆盖矩形。
Parameters
- inputs: HexagonsInGridDto
  矩形尺寸、六边形数量、延伸标志和可选的图案
Returns Promise<TopoDSWirePointer[]>
每个六边形一个线框，逐行排列
Example
```
const cells = await bitbybit.occt.shapes.wire.hexagonsInGrid({
    width: 20,
    height: 10,
    nrHexagonsInWidth: 8,
    nrHexagonsInHeight: 4,
    flatTop: false,
    scalePatternWidth: [0.9],
    scalePatternHeight: [0.9],
});
```
- Defined in bitbybit-docs.d.ts:46141

createSquareWire

createSquareWire(inputs: Bit.Inputs.OCCT.SquareDto): Promise<TopoDSWirePointer>
创建以 center 为中心的闭合正方形线框。

direction 是其平面的法线：默认的 [0, 1, 0] 将其平放在地面上。
Parameters
- inputs: Bit.Inputs.OCCT.SquareDto
  边长、中心和平面法线
Returns Promise<TopoDSWirePointer>
正方形线框
Example
```
const square = await bitbybit.occt.shapes.wire.createSquareWire({ size: 10, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:46156

createStarWire

createStarWire(inputs: Bit.Inputs.OCCT.StarDto): Promise<TopoDSWirePointer>
创建带 numRays 个角的闭合星形线框。

角伸到 outerRadius，角之间的凹口到 innerRadius；offsetOuterEdges 将角尖抬出平面该距离，形成 3D 星形，half 保留前一半的角作为开放线框。除非 direction 另有指定，否则它平放在地面上。
Parameters
- inputs: Bit.Inputs.OCCT.StarDto
  两个半径、角数、中心、平面法线和选项
Returns Promise<TopoDSWirePointer>
星形线框
Example
```
const star = await bitbybit.occt.shapes.wire.createStarWire({ outerRadius: 5, innerRadius: 2, numRays: 5, center: [0, 0, 0], direction: [0, 1, 0], offsetOuterEdges: 0, half: false });
```
- Defined in bitbybit-docs.d.ts:46174

createChristmasTreeWire

createChristmasTreeWire(inputs: ChristmasTreeDto): Promise<TopoDSWirePointer>
创建形如风格化圣诞树的闭合线框：nrSkirts 层树枝，从距树干线 outerDist 收窄到 innerDist，立于 trunkHeight 和 trunkWidth 的树干上。

与此处其他平面形状不同，它在 XY 平面内竖立，树尖沿 Y；direction 是树干到树尖的方向，rotation 使其绕该轴旋转，以度为单位。
Parameters
- inputs: ChristmasTreeDto
  树的比例、树干尺寸、选项、原点以及从树干到树尖的方向
Returns Promise<TopoDSWirePointer>
圣诞树线框
Example
```
const tree = await bitbybit.occt.shapes.wire.createChristmasTreeWire({
    height: 10,
    innerDist: 1.5,
    outerDist: 4,
    nrSkirts: 4,
    trunkHeight: 1.5,
    trunkWidth: 1,
    half: false,
    rotation: 0,
    origin: [0, 0, 0],
    direction: [0, 1, 0],
});
```
- Defined in bitbybit-docs.d.ts:46203

createNGonWire

createNGonWire(inputs: NGonWireDto): Promise<TopoDSWirePointer>
创建带 nrCorners 个角的闭合正多边形线框，所有角都在半径为 radius 的圆上。

direction 是平面的法线；默认的 [0, 1, 0] 将其平放在地面上。
Parameters
- inputs: NGonWireDto
  角数、半径、中心和平面法线
Returns Promise<TopoDSWirePointer>
多边形线框
Example
```
const hexagon = await bitbybit.occt.shapes.wire.createNGonWire({ nrCorners: 6, radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:46218

createParallelogramWire

createParallelogramWire(inputs: ParallelogramDto): Promise<TopoDSWirePointer>
创建闭合平行四边形线框：一个 width 乘 height 的矩形，其边倾斜 angle 度。

aroundCenter 为 true 时形状以 center 为中心；否则从该点开始并向正方向延伸。direction 是平面法线；默认的 [0, 1, 0] 将其平放在地面上。
Parameters
- inputs: ParallelogramDto
  宽度、高度、倾斜角度、是否居中、中心和平面法线
Returns Promise<TopoDSWirePointer>
平行四边形线框
Example
```
const shape = await bitbybit.occt.shapes.wire.createParallelogramWire({ width: 10, height: 5, angle: 30, aroundCenter: true, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:46236

createHeartWire

createHeartWire(inputs: Heart2DDto): Promise<TopoDSWirePointer>
创建由两个光滑半边组成、大致能放入边长为 sizeApprox 的正方形的闭合心形线框。

rotation 使其在平面内转动，以度为单位。direction 是平面法线；默认的 [0, 1, 0] 将其平放在地面上。
Parameters
- inputs: Heart2DDto
  近似尺寸、旋转、中心和平面法线
Returns Promise<TopoDSWirePointer>
心形线框
Example
```
const heart = await bitbybit.occt.shapes.wire.createHeartWire({ sizeApprox: 10, rotation: 0, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:46253

createRectangleWire

createRectangleWire(
inputs: Bit.Inputs.OCCT.RectangleDto,
): Promise<TopoDSWirePointer>
创建以 center 为中心的闭合矩形线框。

在地平面上 width 沿 X，length 沿 Z；direction 是平面的法线，默认的 [0, 1, 0] 使线框平放在地面上。
Parameters
- inputs: Bit.Inputs.OCCT.RectangleDto
  宽度、长度、中心和平面法线
Returns Promise<TopoDSWirePointer>
矩形线框
Example
```
const rectangle = await bitbybit.occt.shapes.wire.createRectangleWire({ width: 20, length: 10, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:46269

createLPolygonWire

createLPolygonWire(inputs: LPolygonDto): Promise<TopoDSWirePointer>
创建闭合的 L 形线框：两条在角处相接的矩形腿。

第一条腿有 widthFirst 和 lengthFirst，第二条有 widthSecond 和 lengthSecond；align 将角放在腿的外侧、内侧或中间，rotation 使形状在其平面内转动，以度为单位。除非 direction 另有指定，否则它平放在地面上。
Parameters
- inputs: LPolygonDto
  两条边的尺寸、对齐方式、旋转、中心和平面法线
Returns Promise<TopoDSWirePointer>
L 形线框
Example
```
const outline = await bitbybit.occt.shapes.wire.createLPolygonWire({
    widthFirst: 2,
    lengthFirst: 10,
    widthSecond: 2,
    lengthSecond: 6,
    align: Bit.Inputs.OCCT.directionEnum.outside,
    rotation: 0,
    center: [0, 0, 0],
    direction: [0, 1, 0],
});
```
- Defined in bitbybit-docs.d.ts:46296

createEllipseWire

createEllipseWire(
inputs: Bit.Inputs.OCCT.EllipseDto,
): Promise<TopoDSWirePointer>
创建一个完整的椭圆作为闭合的单边线框，位于法线为 direction 的平面内。

radiusMajor 不得小于 radiusMinor，否则内核拒绝该椭圆；默认方向 [0, 1, 0] 将其平放在地面上。
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  中心、平面法线和两个半径
Returns Promise<TopoDSWirePointer>
椭圆线框
Example
```
const ellipse = await bitbybit.occt.shapes.wire.createEllipseWire({ center: [0, 0, 0], direction: [0, 1, 0], radiusMinor: 3, radiusMajor: 6 });
```
- Defined in bitbybit-docs.d.ts:46422

createHelixWire

createHelixWire(inputs: HelixWireDto): Promise<TopoDSWirePointer>
创建螺旋线线框，即半径恒为 radius、每圈上升 pitch 个模型单位、直到达到 height 的螺旋。

它从 center 旁开始并沿 direction 上升；clockwise 反转绕向。螺旋线由 tolerance 内的光滑曲线逼近。半径、螺距或高度为 0 或更小时给出 null 线框。
Parameters
- inputs: HelixWireDto
  半径、螺距、高度、底部中心、轴方向、旋向和容差
Returns Promise<TopoDSWirePointer>
螺旋线线框
Example
```
const spring = await bitbybit.occt.shapes.wire.createHelixWire({ radius: 2, pitch: 1, height: 10, center: [0, 0, 0], direction: [0, 1, 0], clockwise: false, tolerance: 1e-4 });
```
- Defined in bitbybit-docs.d.ts:46440

createHelixWireByTurns

createHelixWireByTurns(inputs: HelixWireByTurnsDto): Promise<TopoDSWirePointer>
像 createHelixWire 一样创建螺旋线线框，但按 numTurns 而不是高度确定大小：螺旋每圈上升 pitch 个模型单位，共 numTurns 圈。
Parameters
- inputs: HelixWireByTurnsDto
  半径、螺距、圈数、底部中心、轴方向、旋向和容差
Returns Promise<TopoDSWirePointer>
螺旋线线框
Example
```
const spring = await bitbybit.occt.shapes.wire.createHelixWireByTurns({ radius: 2, pitch: 1, numTurns: 5, center: [0, 0, 0], direction: [0, 1, 0], clockwise: false, tolerance: 1e-4 });
```
- Defined in bitbybit-docs.d.ts:46454

createTaperedHelixWire

createTaperedHelixWire(inputs: TaperedHelixWireDto): Promise<TopoDSWirePointer>
创建锥形螺旋线线框，其半径从底部的 startRadius 均匀变化到顶部的 endRadius，每圈上升 pitch 个模型单位，直到达到 height。

它从 center 旁开始并沿 direction 上升；clockwise 反转绕向。曲线在 tolerance 内逼近。
Parameters
- inputs: TaperedHelixWireDto
  起始和结束半径、螺距、高度、底部中心、轴方向、旋向和容差
Returns Promise<TopoDSWirePointer>
锥形螺旋线线框
Example
```
const cone = await bitbybit.occt.shapes.wire.createTaperedHelixWire({ startRadius: 3, endRadius: 0.5, pitch: 1, height: 8, center: [0, 0, 0], direction: [0, 1, 0], clockwise: false, tolerance: 1e-4 });
```
- Defined in bitbybit-docs.d.ts:46471

createFlatSpiralWire

createFlatSpiralWire(inputs: FlatSpiralWireDto): Promise<TopoDSWirePointer>
在法线为 direction 的平面内创建平面螺线线框：numTurns 圈，半径从 startRadius 均匀增长到 endRadius。

默认方向 [0, 1, 0] 将其平放在地面上；clockwise 反转绕向，曲线在 tolerance 内逼近。
Parameters
- inputs: FlatSpiralWireDto
  起始和结束半径、圈数、中心、平面法线、旋向和容差
Returns Promise<TopoDSWirePointer>
螺线线框
Example
```
const spiral = await bitbybit.occt.shapes.wire.createFlatSpiralWire({ startRadius: 0.5, endRadius: 5, numTurns: 4, center: [0, 0, 0], direction: [0, 1, 0], clockwise: false, tolerance: 1e-4 });
```
- Defined in bitbybit-docs.d.ts:46488

textWires

textWires(inputs: TextWiresDto): Promise<TopoDSWirePointer[]>
用单线 Hershey simplex 字体在地平面上将文本写成笔画线框，每个笔画一个开放折线线框。

height 是大写字母的高度，以模型单位表示，lineSpacing 和 letterSpacing 是它的倍数，align 对齐长度不同的行，centerOnOrigin 将文本块移到原点。
Parameters
- inputs: TextWiresDto
  文本、其大小和间距、对齐方式和放置选项
Returns Promise<TopoDSWirePointer[]>
每个笔画一个线框，按书写顺序排列
Example
```
const strokes = await bitbybit.occt.shapes.wire.textWires({
    text: "Hello",
    height: 5,
    lineSpacing: 1.5,
    letterSpacing: 0,
    align: Bit.Inputs.Base.horizontalAlignEnum.left,
    centerOnOrigin: true,
});
```
- Defined in bitbybit-docs.d.ts:46513

textWiresWithData

textWiresWithData(
inputs: TextWiresDto,
): Promise<TextWiresDataDto<TopoDSCompoundPointer>>
像 textWires 一样将文本写成笔画线框，并将它们打包成复合体，同时附带文本块的尺寸。

结果带有 compound，包含整段文本；characters，按书写顺序每个字符一个复合体；width 和 height，为文本块沿 X 和沿 Z 的范围；以及 center，为文本块的中点。
Parameters
- inputs: TextWiresDto
  文本、其大小和间距、对齐方式和放置选项
Returns Promise<TextWiresDataDto<TopoDSCompoundPointer>>
文本复合体、各字符复合体和测得的尺寸
Example
```
const text = await bitbybit.occt.shapes.wire.textWiresWithData({
    text: "Hi",
    height: 5,
    lineSpacing: 1.5,
    letterSpacing: 0,
    align: Bit.Inputs.Base.horizontalAlignEnum.left,
    centerOnOrigin: false,
});
console.log(text.width, text.height, text.characters.length);
```
- Defined in bitbybit-docs.d.ts:46539

rebuild

rebuildWireDegree

rebuildWireDegree(
inputs: RebuildCurveDegreeDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
在容差内将线框的每条边重建为给定阶数的 B-spline，并将结果重新连接成线框。

降低阶数会简化曲线，提高阶数则给后续操作更多自由；无论哪种，每条新曲线都保持在与旧曲线相差 tolerance 以内。
Parameters
- inputs: RebuildCurveDegreeDto<TopoDSWirePointer>
  线框、要重建到的阶数和容差
Returns Promise<TopoDSWirePointer>
带有重建边的新线框
Example
```
const simpler = await bitbybit.occt.shapes.wire.rebuildWireDegree({ shape: wire, degree: 3, tolerance: 1e-3 });
```
- Defined in bitbybit-docs.d.ts:45247

seam

moveWireSeamByParameter

moveWireSeamByParameter(
inputs: CurveSeamByParameterDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
将闭合周期性线框的接缝（即其起点和终点所在的点）移动到其曲线上的给定参数处。

几何不变；只有线框被视为开始的位置改变。适用于圆等单边线框：每条周期性边都被移动，非周期性的边保持原样。
Parameters
- inputs: CurveSeamByParameterDto<TopoDSWirePointer>
  周期性的线框和新接缝的参数
Returns Promise<TopoDSWirePointer>
从接缝处开始的新线框
Example
```
const rotated = await bitbybit.occt.shapes.wire.moveWireSeamByParameter({ shape: circle, parameter: 1.57 });
```
- Defined in bitbybit-docs.d.ts:45265

moveWireSeamByLength

moveWireSeamByLength(
inputs: CurveSeamByLengthDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
将闭合周期性线框的接缝（即其起点和终点所在的点）从当前起点沿曲线移动一段距离。

几何不变；只有线框被视为开始的位置改变。适用于圆等单边线框：每条周期性边都被移动，非周期性的边保持原样。
Parameters
- inputs: CurveSeamByLengthDto<TopoDSWirePointer>
  周期性的线框和接缝移动的距离
Returns Promise<TopoDSWirePointer>
从接缝处开始的新线框
Example
```
const rotated = await bitbybit.occt.shapes.wire.moveWireSeamByLength({ shape: circle, length: 2.5 });
```
- Defined in bitbybit-docs.d.ts:45283

via points

createPolygonWire

createPolygonWire(inputs: PolygonDto): Promise<TopoDSWirePointer>
创建经过一列角点的直边闭合线框，添加从最后一个点回到第一个点的边。

这些点不必在同一平面内；不过平面需要平面的轮廓。
Parameters
- inputs: PolygonDto
  按顺序排列的角点
Returns Promise<TopoDSWirePointer>
闭合线框
Example
```
const square = await bitbybit.occt.shapes.wire.createPolygonWire({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10], [0, 0, 10]] });
```
- Defined in bitbybit-docs.d.ts:45429

createLineWire

createLineWire(inputs: Bit.Inputs.OCCT.LineDto): Promise<TopoDSWirePointer>
在两点之间创建直的单边线框。
Parameters
- inputs: Bit.Inputs.OCCT.LineDto
  起点和终点
Returns Promise<TopoDSWirePointer>
直线框
Example
```
const line = await bitbybit.occt.shapes.wire.createLineWire({ start: [0, 0, 0], end: [10, 0, 0] });
```
- Defined in bitbybit-docs.d.ts:45460

createLineWireWithExtensions

createLineWireWithExtensions(
inputs: LineWithExtensionsDto,
): Promise<TopoDSWirePointer>
在两点之间创建直的单边线框，并将其延长到两点之外。

extensionStart 和 extensionEnd 是以模型单位表示、沿直线加在起点和终点之外的距离；两点必须不同，否则抛出错误。
Parameters
- inputs: LineWithExtensionsDto
  起点和终点以及两个延长长度
Returns Promise<TopoDSWirePointer>
延长后的直线框
Example
```
const longer = await bitbybit.occt.shapes.wire.createLineWireWithExtensions({ start: [0, 0, 0], end: [10, 0, 0], extensionStart: 2, extensionEnd: 5 });
```
- Defined in bitbybit-docs.d.ts:45476

createPolylineWire

createPolylineWire(
inputs: Bit.Inputs.OCCT.PolylineDto,
): Promise<TopoDSWirePointer>
创建按顺序经过一列点的直边开放线框。

线框不闭合；createPolygonWire 会添加回到第一个点的边。
Parameters
- inputs: Bit.Inputs.OCCT.PolylineDto
  按顺序排列的点
Returns Promise<TopoDSWirePointer>
开放线框
Example
```
const path = await bitbybit.occt.shapes.wire.createPolylineWire({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10]] });
```
- Defined in bitbybit-docs.d.ts:45550

createBezier

createBezier(inputs: BezierDto): Promise<TopoDSWirePointer>
创建由控制点引导的光滑 Bezier 线框：它从第一个点开始，在最后一个点结束，并被中间的点吸引但不经过它们。

closed 再次追加第一个点使两端相接；periodic 则构建在接缝处光滑的闭合曲线。degree 限制有多少相邻点影响每一部分。
Parameters
- inputs: BezierDto
  控制点以及闭合和阶数选项
Returns Promise<TopoDSWirePointer>
贝塞尔线框
Example
```
const curve = await bitbybit.occt.shapes.wire.createBezier({ points: [[0, 0, 0], [5, 0, 10], [10, 0, -10], [15, 0, 0]], closed: false, periodic: false });
```
- Defined in bitbybit-docs.d.ts:45675

createBezierWeights

createBezierWeights(inputs: BezierWeightsDto): Promise<TopoDSWirePointer>
像 createBezier 一样创建 Bezier 线框，每个控制点带一个权重，表示它吸引曲线的强度。

大于 1 的权重将曲线拉向其点，小于 1 则放松。权重必须与点匹配：数量相同，或当 closed 为 true 且 periodic 为 false 时多一个，因为第一个点会重复。
Parameters
- inputs: BezierWeightsDto
  控制点、其权重以及闭合和阶数选项
Returns Promise<TopoDSWirePointer>
带权重的贝塞尔线框
Example
```
const curve = await bitbybit.occt.shapes.wire.createBezierWeights({
    points: [[0, 0, 0], [5, 0, 10], [10, 0, 0]],
    weights: [1, 3, 1],
    closed: false,
    periodic: false,
});
```
- Defined in bitbybit-docs.d.ts:45698

interpolatePoints

interpolatePoints(inputs: InterpolationDto): Promise<TopoDSWirePointer>
创建按顺序经过每个点的光滑 B-spline 线框。

periodic 闭合曲线使其在接缝处光滑，这能得到形状优美的环。parametrization 控制点之间的间距：当点不均匀时，centripetal 能抑制尖点和过冲。startTangent 和 endTangent，或每个点一个 tangents 条目，强制曲线在该处的方向。
Parameters
- inputs: InterpolationDto
  点、是否闭合曲线、容差、参数化方式和可选的切线
Returns Promise<TopoDSWirePointer>
经过这些点的 B-spline 线框
Example
```
const loop = await bitbybit.occt.shapes.wire.interpolatePoints({
    points: [[0, 0, 0], [10, 0, 5], [10, 0, 15], [0, 0, 10]],
    periodic: true,
    tolerance: 1e-7,
    parametrization: Bit.Inputs.OCCT.bSplineParametrizationEnum.centripetal,
});
```
- Defined in bitbybit-docs.d.ts:45739

interpolatePointsSymmetric

interpolatePointsSymmetric(
inputs: InterpolateSymmetricDto,
): Promise<TopoDSWirePointer>
创建经过这些点的闭合光滑 B-spline 线框，只要点是镜像对称的，其形状也是镜像对称的，没有看起来奇怪的起点或终点。

普通的周期性 interpolatePoints 对正方形或三角形等对称输入在接缝处可能显得歪斜；此变体不会。如果无法对这些点进行插值，它会以错误失败。
Parameters
- inputs: InterpolateSymmetricDto
  点和容差
Returns Promise<TopoDSWirePointer>
闭合的对称 B-spline 线框
Example
```
const rounded = await bitbybit.occt.shapes.wire.interpolatePointsSymmetric({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10], [0, 0, 10]], tolerance: 1e-7 });
```
- Defined in bitbybit-docs.d.ts:45757

createBSpline

createBSpline(inputs: BSplineDto): Promise<TopoDSWirePointer>
创建逼近一列点的光滑 B-spline 线框：它紧密地跟随这些点，但不必精确经过每一个。

closed 再次追加第一个点使两端相接。拟合使用 3 到 8 之间的阶数和 0.001 模型单位的容差；当曲线必须经过这些点时使用 interpolatePoints。
Parameters
- inputs: BSplineDto
  点以及是否闭合曲线
Returns Promise<TopoDSWirePointer>
B-spline 线框
Example
```
const curve = await bitbybit.occt.shapes.wire.createBSpline({ points: [[0, 0, 0], [5, 0, 5], [10, 0, 0], [15, 0, 5]], closed: false });
```
- Defined in bitbybit-docs.d.ts:45793

via wires

createZigZagBetweenTwoWires

createZigZagBetweenTwoWires(
inputs: ZigZagBetweenTwoWiresDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
绘制在两个线框之间来回弹跳的锯齿线：两者被分成相同数量的点，一条折线交替访问它们。

nrZigZags 设置弹跳次数；inverse 从第二个线框开始；divideByEqualDistance 按长度而不是按参数分布点；zigZagsPerEdge 为 true 时每条边有自己的锯齿，因此边的数量必须匹配。
Parameters
- inputs: ZigZagBetweenTwoWiresDto<TopoDSWirePointer>
  两个线框、锯齿数量和间距选项
Returns Promise<TopoDSWirePointer>
锯齿线框
Example
```
const zigzag = await bitbybit.occt.shapes.wire.createZigZagBetweenTwoWires({ wire1: lower, wire2: upper, nrZigZags: 20, inverse: false, divideByEqualDistance: true, zigZagsPerEdge: false });
```
- Defined in bitbybit-docs.d.ts:45568

createWiresBetweenStartEndPointsOfWiresAndEdges

createWiresBetweenStartEndPointsOfWiresAndEdges(
    inputs: WiresBetweenStartEndPointsOfWiresAndEdgesDto<
        TopoDSEdgePointer
        | TopoDSWirePointer,
    >,
): Promise<TopoDSWirePointer[]>
将多个线框或边的起点连接成一个新线框，将它们的终点连接成另一个。

wireType 使它们成为折线或光滑插值曲线，closed 将最后一个点连回第一个点，tolerance 用于插值。少于两个形状会抛出错误。
Parameters
- inputs: WiresBetweenStartEndPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  线框或边、要构建的线框类型、是否闭合以及容差
Returns Promise<TopoDSWirePointer[]>
两个线框：一个经过各起点，一个经过各终点
Example
```
const [starts, ends] = await bitbybit.occt.shapes.wire.createWiresBetweenStartEndPointsOfWiresAndEdges({
    shapes: [wireA, wireB, wireC],
    wireType: Bit.Inputs.OCCT.wireFromPointsTypeEnum.interpolated,
    closed: false,
    tolerance: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:45591

createWiresBetweenSubdividedPointsOfWiresAndEdges

createWiresBetweenSubdividedPointsOfWiresAndEdges(
    inputs: WiresBetweenSubdividedPointsOfWiresAndEdgesDto<
        TopoDSEdgePointer
        | TopoDSWirePointer,
    >,
): Promise<TopoDSWirePointer[]>
将多个线框或边分成相同数量的点，并将每个位置上的点连接成一个新线框，就像梯子的横档。

nrOfDivisions 步给出比该数多一个的横档；divideByEqualDistance 按长度而不是按参数分布点；wireType 使横档成为折线或光滑曲线，closed 将每条连接成环。
Parameters
- inputs: WiresBetweenSubdividedPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  线框或边、分段数、间距、要构建的线框类型、是否闭合以及容差
Returns Promise<TopoDSWirePointer[]>
每个分割点一个线框，沿形状顺序排列
Example
```
const rungs = await bitbybit.occt.shapes.wire.createWiresBetweenSubdividedPointsOfWiresAndEdges({
    shapes: [rail1, rail2],
    nrOfDivisions: 10,
    divideByEqualDistance: true,
    wireType: Bit.Inputs.OCCT.wireFromPointsTypeEnum.polyline,
    closed: false,
    tolerance: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:45616

createWireFromTwoCirclesTan

createWireFromTwoCirclesTan(
inputs: WireFromTwoCirclesTanDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
绘制绕位于同一平面内的两个圆的闭合轮廓，用切线连接它们：皮带或胶囊形状。

keepLines 选择外切线（皮带）或交叉的内切线；circleRemainders 选择每个圆的哪段圆弧保留在轮廓中。每个圆线框必须由单条边构成。
Parameters
- inputs: WireFromTwoCirclesTanDto<TopoDSWirePointer>
  两个圆线框、要保留的切线和圆弧，以及容差
Returns Promise<TopoDSWirePointer>
闭合的轮廓线框
Example
```
const belt = await bitbybit.occt.shapes.wire.createWireFromTwoCirclesTan({
    circle1,
    circle2,
    keepLines: Bit.Inputs.OCCT.twoSidesStrictEnum.outside,
    circleRemainders: Bit.Inputs.OCCT.fourSidesStrictEnum.outside,
    tolerance: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:45640

Class OCCTWire

Index

Constructors

beam profiles

build

debug

edit

extract

extract from wires

from base

get

multiple

place

primitives

rebuild

seam

via points

via wires

Constructors

constructor

Returns OCCTWire

beam profiles

createIBeamProfileWire

Parameters

Returns Promise<TopoDSWirePointer>

Example

createHBeamProfileWire

Parameters

Returns Promise<TopoDSWirePointer>

Example

createTBeamProfileWire

Parameters

Returns Promise<TopoDSWirePointer>

Example

createUBeamProfileWire

Parameters

Returns Promise<TopoDSWirePointer>

Example

build

combineEdgesAndWiresIntoAWire

Parameters

Returns Promise<TopoDSWirePointer>

Example

createWireFromEdge

Parameters

Returns Promise<TopoDSWirePointer>

Example

addEdgesAndWiresToWire

Parameters

Returns Promise<TopoDSWirePointer>

Example

debug

debugInfo

Parameters

Returns Promise<WireDebugInfo>

Example

edit

closeOpenWire

Parameters

Returns Promise<TopoDSWirePointer>

Example

extract

splitOnPoints

Parameters

Returns Promise<TopoDSWirePointer[]>

Example

wiresToPoints

Parameters

Returns Promise<Point3[][]>

Example

divideWireByParamsToPoints

Parameters

Returns Promise<Point3[]>

Example

divideWireByEqualDistanceToPoints

Parameters

Returns Promise<Point3[]>

Example

pointOnWireAtParam

Parameters