Class OCCTWire

Fios em OpenCascade: cadeias de arestas unidas de ponta a ponta, abertas como um caminho ou fechadas como um contorno. Construa-os a partir de pontos e curvas (polilinhas, B-splines, Beziers, interpolações, hélices, espirais), como contornos planos prontos (círculos, retângulos, estrelas, perfis de viga, texto) que assentam no plano do chão a menos que direction diga o contrário, ou unindo e dividindo arestas e fios existentes; leia-os de volta como pontos, tangentes, comprimentos e centros; mapeie-os sobre faces ou projete-os sobre formas. Os parâmetros ao longo de um fio vão de 0 no seu início a 1 no seu fim e seguem o parâmetro próprio de cada aresta, não a distância. Um fio fechado é o que shapes.face preenche para criar uma face.

Index

Constructors

constructor

new OCCTWire(): OCCTWire
Returns OCCTWire

beam profiles

createIBeamProfileWire

createIBeamProfileWire(inputs: IBeamProfileDto): Promise<TopoDSWirePointer>
Cria o contorno fechado da secção transversal de uma viga em I: dois banzos horizontais unidos por uma alma vertical.

width é a largura do banzo, height a altura total, webThickness e flangeThickness as espessuras das paredes; alignment diz qual ponto da caixa do perfil fica em center, rotation roda-o no seu plano, em graus. Assenta no chão, pronto a extrudir.
Parameters
- inputs: IBeamProfileDto
  O tamanho do perfil, as duas espessuras, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio de contorno da viga em I
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>
Cria o contorno fechado da secção transversal de uma viga em H: dois banzos verticais unidos por uma alma horizontal, uma viga em I deitada de lado.

width é a largura total, height a altura do banzo, webThickness e flangeThickness as espessuras das paredes; alignment diz qual ponto da caixa do perfil fica em center, rotation roda-o no seu plano, em graus.
Parameters
- inputs: HBeamProfileDto
  O tamanho do perfil, as duas espessuras, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio de contorno da viga em 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>
Cria o contorno fechado da secção transversal de uma viga em T: um banzo horizontal com uma alma vertical pendurada do seu meio.

width é a largura do banzo, height a altura total, webThickness e flangeThickness as espessuras das paredes; alignment diz qual ponto da caixa do perfil fica em center, rotation roda-o no seu plano, em graus. Assenta no chão.
Parameters
- inputs: TBeamProfileDto
  O tamanho do perfil, as duas espessuras, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio de contorno da viga em 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>
Cria o contorno fechado da secção transversal de uma viga em U, um canal: uma alma com dois banzos de flangeWidth erguidos a partir das suas extremidades.

width e height são o tamanho total, webThickness e flangeThickness as espessuras das paredes; alignment diz qual ponto da caixa do perfil fica em center, rotation roda-o no seu plano, em graus. Assenta no chão.
Parameters
- inputs: UBeamProfileDto
  O tamanho do perfil, as espessuras, a largura do banzo, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio de contorno da viga em 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>
Une arestas e fios que se tocam ponta a ponta num só fio.

Os troços têm de se ligar; um conjunto com uma folga ou um troço solto lança um erro. Formas de outros tipos na lista são ignoradas.
Parameters
- inputs: ShapesDto<TopoDSEdgePointer | TopoDSWirePointer>
  As arestas e os fios a unir
Returns Promise<TopoDSWirePointer>
O fio unido
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>
Envolve uma única aresta num fio, para que possa ir onde se espera um fio.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  A aresta
Returns Promise<TopoDSWirePointer>
O fio que contém essa aresta
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>
Prolonga um fio com mais arestas e fios que o tocam ponta a ponta.

Os troços têm de se ligar ao fio ou uns aos outros; uma folga lança um erro. Formas de outros tipos na lista são ignoradas.
Parameters
- inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSEdgePointer | TopoDSWirePointer>
  O fio a prolongar e as arestas e fios a adicionar
Returns Promise<TopoDSWirePointer>
O fio prolongado
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>
Recolhe factos de diagnóstico sobre um fio: quantas arestas tem, se é fechado, o seu comprimento total e, para cada aresta, o relatório de curva que shapes.edge.debugInfo dá.

Um fio vazio ou nulo dá um relatório marcado como inválido com contagens a zero.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio a inspecionar
Returns Promise<WireDebugInfo>
O relatório com o número de arestas, o indicador de fechado, o comprimento e uma entrada por aresta
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>
Fecha um fio aberto com uma aresta reta do seu ponto final de volta ao seu ponto inicial.

Um fio cujas extremidades já se encontram é devolvido tal como está.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio a fechar
Returns Promise<TopoDSWirePointer>
O fio fechado
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[]>
Corta um fio em pedaços nos pontos dados.

Cada ponto é movido para o sítio mais próximo no fio antes de cortar, por isso não precisa de assentar exatamente nele; pontos repetidos são ignorados. Os pedaços voltam por ordem ao longo do fio, do seu início ao seu fim.
Parameters
- inputs: SplitWireOnPointsDto<TopoDSWirePointer>
  O fio e os pontos onde cortar
Returns Promise<TopoDSWirePointer[]>
Os troços do fio, por ordem
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[][]>
Transforma cada fio de uma forma numa sequência de pontos que segue as suas curvas de perto o suficiente para o desenhar, uma lista por fio.

As definições de deflexão dizem quão apertados os pontos abraçam as arestas curvas; onde uma aresta termina e a seguinte começa o ponto partilhado aparece uma vez.
Parameters
- inputs: WiresToPointsDto<TopoDSShapePointer>
  A forma e as definições de deflexão
Returns Promise<Point3[][]>
Uma lista de pontos por fio
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[]>
Coloca pontos ao longo de um fio em passos iguais do seu parâmetro, do início ao fim.

nrOfDivisions passos dão mais um ponto do que isso; removeStartPoint e removeEndPoint retiram as extremidades. O parâmetro segue o parâmetro de curva próprio de cada aresta, por isso passos iguais não são distâncias iguais; use divideWireByEqualDistanceToPoints para essas.
Parameters
- inputs: DivideDto<TopoDSWirePointer>
  O fio, o número de divisões e se deve descartar os pontos extremos
Returns Promise<Point3[]>
Os pontos ao longo do fio, por ordem
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[]>
Coloca pontos ao longo de um fio a distâncias iguais medidas ao longo das suas curvas, do início ao fim.

nrOfDivisions passos dão mais um ponto do que isso; removeStartPoint e removeEndPoint retiram as extremidades.
Parameters
- inputs: DivideDto<TopoDSWirePointer>
  O fio, o número de divisões e se deve descartar os pontos extremos
Returns Promise<Point3[]>
Os pontos ao longo do fio, por ordem
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>
Encontra o ponto a uma fração do caminho ao longo de um fio: 0 é o início, 1 o fim.

A fração segue os parâmetros das arestas, não a distância, por isso 0.5 nem sempre é o meio por comprimento; use pointOnWireAtLength para uma distância.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  O fio e a fração de 0 a 1
Returns Promise<Point3>
O ponto no fio
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>
Encontra o ponto a uma dada distância ao longo de um fio a partir do seu início, medida ao longo das suas curvas em unidades do modelo.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  O fio e a distância desde o seu início
Returns Promise<Point3>
O ponto no fio
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[]>
Encontra os pontos a várias distâncias ao longo de um fio a partir do seu início, medidas ao longo das suas curvas em unidades do modelo.
Parameters
- inputs: DataOnGeometryAtLengthsDto<TopoDSWirePointer>
  O fio e as distâncias desde o seu início
Returns Promise<Point3[]>
Um ponto por distância, pela mesma ordem
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[]>
Coloca pontos ao longo de um fio a cada length unidades do modelo a partir do seu início, tantos quantos couberem.

includeFirst mantém o ponto no início, includeLast acrescenta o ponto final seja qual for o espaçamento, e tryNext pede mais um ponto um passo além do último que coube.
Parameters
- inputs: PointsOnWireAtEqualLengthDto<TopoDSWirePointer>
  O fio, o espaçamento e quais os pontos extremos a incluir
Returns Promise<Point3[]>
Os pontos ao longo do fio, por ordem
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[]>
Coloca pontos ao longo de um fio segundo um padrão repetido de intervalos, como 1, 3, 1, 3, até o fio acabar.

lengths é o padrão de intervalos em unidades do modelo, repetido a partir do início; includeFirst mantém o ponto inicial, includeLast acrescenta o ponto final, e tryNext pede mais um ponto no intervalo seguinte além do último.
Parameters
- inputs: PointsOnWireAtPatternOfLengthsDto<TopoDSWirePointer>
  O fio, o padrão de intervalos e quais os pontos extremos a incluir
Returns Promise<Point3[]>
Os pontos ao longo do fio, por ordem
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>
Encontra a direção em que o fio segue a uma fração do caminho ao longo dele, de 0 no início a 1 no fim.

A fração segue os parâmetros das arestas, não a distância.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  O fio e a fração de 0 a 1
Returns Promise<Vector3>
A direção da tangente
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>
Encontra a direção em que o fio segue a uma dada distância do seu início, medida ao longo das suas curvas em unidades do modelo.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  O fio e a distância desde o seu início
Returns Promise<Vector3>
A direção da tangente
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]>
Calcula a primeira, a segunda e a terceira derivadas da curva de um fio a uma dada distância do seu início.

A primeira derivada é a tangente com a sua velocidade, a segunda diz como a curva se curva, a terceira como essa curvatura muda; todas são em relação ao parâmetro da curva. A distância é medida ao longo das curvas em unidades do modelo.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  O fio e a distância desde o seu início
Returns Promise<[Vector3, Vector3, Vector3]>
Os três vetores de derivada, da primeira à terceira
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]>
Calcula a primeira, a segunda e a terceira derivadas da curva de um fio a uma fração do caminho ao longo dele, de 0 no início a 1 no fim.

A primeira derivada é a tangente com a sua velocidade, a segunda diz como a curva se curva, a terceira como essa curvatura muda; todas são em relação ao parâmetro da curva.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  O fio e a fração de 0 a 1
Returns Promise<[Vector3, Vector3, Vector3]>
Os três vetores de derivada, da primeira à terceira
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>
Lê o ponto onde um fio começa, na direção própria do fio.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio
Returns Promise<Point3>
O ponto inicial
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>
Encontra o ponto a meio do intervalo de parâmetro de um fio.

O parâmetro segue as curvas próprias das arestas, não a distância, por isso num fio de arestas desiguais isto nem sempre é o meio por comprimento; pointOnWireAtLength com metade de getWireLength dá isso.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio
Returns Promise<Point3>
O ponto no parâmetro 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>
Lê o ponto onde um fio termina, na direção própria do fio.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio
Returns Promise<Point3>
O ponto final
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[][]>
Executa divideWireByParamsToPoints em vários fios com as mesmas definições.
Parameters
- inputs: DivideShapesDto<TopoDSWirePointer>
  Os fios, o número de divisões e se deve descartar os pontos extremos
Returns Promise<Point3[][]>
Uma lista de pontos por fio, pela mesma ordem
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[][]>
Executa divideWireByEqualDistanceToPoints em vários fios com as mesmas definições.
Parameters
- inputs: DivideShapesDto<TopoDSWirePointer>
  Os fios, o número de divisões e se deve descartar os pontos extremos
Returns Promise<Point3[][]>
Uma lista de pontos por fio, pela mesma ordem
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>
Cria um fio reto de uma só aresta a partir de um objeto linha da forma { start, end }.
Parameters
- inputs: LineBaseDto
  A linha
Returns Promise<TopoDSWirePointer>
O fio reto
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[]>
Cria um fio reto de uma só aresta por objeto linha da forma { start, end }.
Parameters
- inputs: LinesBaseDto
  As linhas
Returns Promise<TopoDSWirePointer[]>
Um fio por linha, pela mesma ordem
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>
Cria um fio reto de uma só aresta a partir de um segmento, um par de pontos [start, end].
Parameters
- inputs: SegmentBaseDto
  O segmento
Returns Promise<TopoDSWirePointer>
O fio reto
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[]>
Cria um fio reto de uma só aresta por segmento, cada um um par de pontos [start, end].
Parameters
- inputs: SegmentsBaseDto
  Os segmentos
Returns Promise<TopoDSWirePointer[]>
Um fio por segmento, pela mesma ordem
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>
Une uma lista de pontos por ordem com arestas retas num só fio.

Menos de dois pontos lançam um erro. Quando o último ponto repete o primeiro, a repetição é descartada e o fio é fechado de volta ao primeiro ponto; caso contrário o fio fica aberto. Para um contorno fechado sem repetir um ponto use createPolygonWire.
Parameters
- inputs: Bit.Inputs.OCCT.PointsDto
  Os pontos, por ordem
Returns Promise<TopoDSWirePointer>
O fio que passa pelos pontos
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>
Cria um fio a partir de um objeto polilinha, uma aresta reta por segmento; uma polilinha marcada como fechada recebe também a aresta do seu último ponto de volta ao primeiro.
Parameters
- inputs: PolylineBaseDto
  A polilinha
Returns Promise<TopoDSWirePointer>
O fio
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>
Cria um fio fechado de três arestas a partir de um triângulo dado como três pontos.
Parameters
- inputs: TriangleBaseDto
  O triângulo
Returns Promise<TopoDSWirePointer>
O fio fechado
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[]>
Cria um fio fechado de três arestas por triângulo de uma malha.

Um triângulo cujo fio não possa ser construído é saltado com um aviso em vez de parar o resto.
Parameters
- inputs: MeshBaseDto
  A malha como uma lista de triângulos
Returns Promise<TopoDSWirePointer[]>
Um fio por triângulo que foi possível construir
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>
Escolhe um fio de uma forma pela sua posição, a contar de 0, pela ordem em que o kernel percorre a forma.

A forma tem de ser um fio ou algo construído a partir de fios; um índice para lá do último fio lança um erro.
Parameters
- inputs: ShapeIndexDto<TopoDSShapePointer>
  A forma e o índice a começar em 0
Returns Promise<TopoDSWirePointer>
O fio nesse índice
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[]>
Lista todos os fios de uma forma pela ordem em que o kernel a percorre.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  A forma
Returns Promise<TopoDSWirePointer[]>
Os fios encontrados na forma
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>
Encontra o centro de massa de um fio, o ponto de equilíbrio das suas curvas; para um círculo é o seu centro, fora do próprio fio.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio
Returns Promise<Point3>
O ponto do centro de massa
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[]>
Encontra o centro de massa de cada fio de uma lista.
Parameters
- inputs: ShapesDto<TopoDSWirePointer>
  Os fios
Returns Promise<Point3[]>
Um ponto por fio, pela mesma ordem
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>
Inverte a direção de um fio, de modo que o seu início se torna o seu fim.

As arestas mantêm a sua própria ordem e indicadores de direção; o fio como um todo é marcado como invertido, que é o que a maioria das operações lê. reversedWireFromReversedEdges reconstrói em vez disso o fio aresta a aresta.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio
Returns Promise<TopoDSWirePointer>
Um novo fio no sentido contrário
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>
Inverte a direção de um fio invertendo cada aresta e unindo-as de novo pela ordem oposta.

O resultado é um fio que corre no sentido contrário de uma ponta à outra, o que algumas operações precisam onde o simples indicador de reversedWire não basta.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio
Returns Promise<TopoDSWirePointer>
Um novo fio no sentido contrário
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>
Indica se um fio é fechado, o que acontece quando os seus pontos inicial e final coincidem dentro de uma pequena tolerância.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio
Returns Promise<boolean>
True quando as extremidades se encontram
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>
Mede o comprimento de um fio ao longo das suas curvas, em unidades do modelo.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  O fio
Returns Promise<number>
O comprimento
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[]>
Mede o comprimento de cada fio de uma lista ao longo das suas curvas, em unidades do modelo.
Parameters
- inputs: ShapesDto<TopoDSWirePointer>
  Os fios
Returns Promise<number[]>
Um comprimento por fio, pela mesma ordem
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[]>
Cria um fio de polígono fechado por lista de pontos, tal como createPolygonWire faz.

Com returnCompound verdadeiro os fios são agrupados numa só forma composta em vez de uma lista.
Parameters
- inputs: PolygonsDto
  Os polígonos e se deve agrupá-los num composto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Os fios por ordem, ou um composto que os contém
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[]>
Cria um fio reto de uma só aresta por definição de linha.

Com returnCompound verdadeiro os fios são agrupados numa só forma composta em vez de uma lista.
Parameters
- inputs: Bit.Inputs.OCCT.LinesDto
  As linhas e se deve agrupá-las num composto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Os fios por ordem, ou um composto que os contém
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[]>
Cria um fio de polilinha aberto por lista de pontos, tal como createPolylineWire faz.

Com returnCompound verdadeiro os fios são agrupados numa só forma composta em vez de uma lista.
Parameters
- inputs: Bit.Inputs.OCCT.PolylinesDto
  As polilinhas e se deve agrupá-las num composto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Os fios por ordem, ou um composto que os contém
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[]>
Cria um fio de Bezier por definição, tal como createBezier faz.

Com returnCompound verdadeiro os fios são agrupados numa só forma composta em vez de uma lista.
Parameters
- inputs: BezierWiresDto
  As definições de Bezier e se deve agrupá-las num composto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Os fios por ordem, ou um composto que os contém
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[]>
Cria um fio B-spline interpolado por definição, tal como interpolatePoints faz.

Com returnCompound verdadeiro os fios são agrupados numa só forma composta em vez de uma lista.
Parameters
- inputs: InterpolateWiresDto
  As definições de interpolação e se deve agrupá-las num composto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Os fios por ordem, ou um composto que os contém
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[]>
Cria um fio B-spline de aproximação por definição, tal como createBSpline faz.

Com returnCompound verdadeiro os fios são agrupados numa só forma composta em vez de uma lista.
Parameters
- inputs: BSplinesDto
  As definições de B-spline e se deve agrupá-las num composto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Os fios por ordem, ou um composto que os contém
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>
Mapeia um fio plano desenhado no plano do chão sobre a superfície de uma face, como se o desenho fosse enrolado à volta dela.

A coordenada Z do fio é lida como U e a sua coordenada X como V, nos valores UV reais da face, que shapes.face.getUMinBound e os seus irmãos reportam; um desenho que caiba dentro desses limites aterra na face.
Parameters
- inputs: WireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  O fio no plano do chão e a face
Returns Promise<TopoDSWirePointer>
O fio assente na superfície da face
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[]>
Mapeia vários fios planos desenhados no plano do chão sobre a superfície de uma face, tal como placeWireOnFace faz para um.
Parameters
- inputs: WiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Os fios no plano do chão e a face
Returns Promise<TopoDSWirePointer[]>
Os fios assentes na superfície da face, pela mesma ordem
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>
Projeta um fio sobre uma forma ao longo de uma direção, como lançar a sua sombra sobre a superfície.

O resultado é um composto das curvas onde a projeção encontra as faces da forma, que podem estar tanto no seu lado próximo como no lado distante. Corte uma face com ele através de shapes.face.createFaceFromWireOnFace ou use-o como um trajeto.
Parameters
- inputs: ProjectWireDto<TopoDSWirePointer, TopoDSShapePointer>
  O fio, a forma sobre a qual projetar e a direção
Returns Promise<TopoDSCompoundPointer>
Um composto das curvas projetadas
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[]>
Projeta vários fios sobre uma forma ao longo de uma direção, tal como project faz para um.
Parameters
- inputs: ProjectWiresDto<TopoDSWirePointer, TopoDSShapePointer>
  Os fios, a forma sobre a qual projetar e a direção
Returns Promise<TopoDSCompoundPointer[]>
Um composto de curvas projetadas por fio, pela mesma ordem
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>
Cria um círculo completo como um fio fechado de uma só aresta, assente no plano cuja normal é direction; a predefinição [0, 1, 0] deita-o plano no chão.
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  O raio, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio circular
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[]>
Preenche um retângulo no plano do chão com uma grelha de fios hexagonais fechados, centrada na origem.

Os hexágonos são escalados para que nrHexagonsInWidth caibam ao longo de width e nrHexagonsInHeight ao longo de height. Os padrões de escala, arredondamento e inclusão são lidos hexágono a hexágono e repetem-se; os indicadores de extensão esticam as filas exteriores para lá das margens para cobrir o retângulo.
Parameters
- inputs: HexagonsInGridDto
  O tamanho do retângulo, as contagens de hexágonos, os indicadores de extensão e os padrões opcionais
Returns Promise<TopoDSWirePointer[]>
Um fio por hexágono, linha a linha
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>
Cria um fio quadrado fechado centrado em center.

direction é a normal do seu plano: a predefinição [0, 1, 0] deita-o plano no chão.
Parameters
- inputs: Bit.Inputs.OCCT.SquareDto
  O comprimento do lado, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio quadrado
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>
Cria um fio fechado em forma de estrela com numRays pontas.

As pontas chegam a outerRadius e os entalhes entre elas a innerRadius; offsetOuterEdges levanta as pontas dos raios para fora do plano por essa distância, criando uma estrela 3D, e half mantém a primeira metade dos raios como um fio aberto. Assenta plano no chão a menos que direction diga o contrário.
Parameters
- inputs: Bit.Inputs.OCCT.StarDto
  Os dois raios, o número de pontas, o centro, a normal do plano e as opções
Returns Promise<TopoDSWirePointer>
O fio em estrela
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>
Cria um fio fechado com a forma de uma árvore de Natal estilizada: nrSkirts camadas de ramos, estreitando de outerDist para innerDist a partir da linha do tronco, sobre um tronco de trunkHeight e trunkWidth.

Ao contrário das outras formas planas aqui, fica de pé no plano XY, com a ponta ao longo de Y; direction é a direção do tronco para a ponta, rotation roda-a em torno desse eixo, em graus.
Parameters
- inputs: ChristmasTreeDto
  As proporções da árvore, o tamanho do tronco, as opções, a origem e a direção do tronco para o topo
Returns Promise<TopoDSWirePointer>
O fio em árvore
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>
Cria um fio de polígono regular fechado com nrCorners cantos, todos sobre um círculo de radius.

direction é a normal do plano; a predefinição [0, 1, 0] deita-o plano no chão.
Parameters
- inputs: NGonWireDto
  O número de cantos, o raio, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio poligonal
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>
Cria um fio de paralelogramo fechado: um retângulo de width e height cujos lados se inclinam angle graus.

Com aroundCenter verdadeiro a forma é centrada em center; caso contrário parte daí e estende-se nas direções positivas. direction é a normal do plano; a predefinição [0, 1, 0] deita-o plano no chão.
Parameters
- inputs: ParallelogramDto
  A largura, a altura, o ângulo de inclinação, se deve centrá-lo, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio em paralelogramo
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>
Cria um fio fechado em forma de coração com duas metades suaves que cabe aproximadamente num quadrado de sizeApprox.

rotation roda-o no seu plano, em graus. direction é a normal do plano; a predefinição [0, 1, 0] deita-o plano no chão.
Parameters
- inputs: Heart2DDto
  O tamanho aproximado, a rotação, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio em coração
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>
Cria um fio de retângulo fechado centrado em center.

No plano do chão width corre ao longo de X e length ao longo de Z; direction é a normal do plano, e a predefinição [0, 1, 0] mantém o fio plano no chão.
Parameters
- inputs: Bit.Inputs.OCCT.RectangleDto
  A largura, o comprimento, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio retangular
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>
Cria um fio fechado em forma de L: duas pernas retangulares unidas num canto.

A primeira perna tem widthFirst e lengthFirst, a segunda widthSecond e lengthSecond; align coloca o canto no exterior, no interior ou no meio das pernas, e rotation roda a forma no seu plano, em graus. Assenta plano no chão a menos que direction diga o contrário.
Parameters
- inputs: LPolygonDto
  Os dois tamanhos das abas, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSWirePointer>
O fio em forma de 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>
Cria uma elipse completa como um fio fechado de uma só aresta, assente no plano cuja normal é direction.

radiusMajor não pode ser menor do que radiusMinor, ou o kernel recusa a elipse; a direção predefinida [0, 1, 0] deita-a plana no chão.
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  O centro, a normal do plano e os dois raios
Returns Promise<TopoDSWirePointer>
O fio elíptico
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>
Cria um fio de hélice, uma espiral de radius constante que sobe pitch unidades do modelo por volta até atingir height.

Começa ao lado de center e sobe ao longo de direction; clockwise inverte o enrolamento. A hélice é aproximada por uma curva suave dentro de tolerance. Um raio, passo ou altura de 0 ou menos dá um fio nulo.
Parameters
- inputs: HelixWireDto
  O raio, o passo, a altura, o centro da base, a direção do eixo, o sentido de enrolamento e a tolerância
Returns Promise<TopoDSWirePointer>
O fio em hélice
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>
Cria um fio de hélice como createHelixWire, mas dimensionado por numTurns em vez de uma altura: a espiral sobe pitch unidades do modelo por volta, numTurns vezes.
Parameters
- inputs: HelixWireByTurnsDto
  O raio, o passo, o número de voltas, o centro da base, a direção do eixo, o sentido de enrolamento e a tolerância
Returns Promise<TopoDSWirePointer>
O fio em hélice
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>
Cria um fio de hélice cónica cujo raio muda uniformemente de startRadius na base para endRadius no topo, subindo pitch unidades do modelo por volta até atingir height.

Começa ao lado de center e sobe ao longo de direction; clockwise inverte o enrolamento. A curva é aproximada dentro de tolerance.
Parameters
- inputs: TaperedHelixWireDto
  Os raios inicial e final, o passo, a altura, o centro da base, a direção do eixo, o sentido de enrolamento e a tolerância
Returns Promise<TopoDSWirePointer>
O fio em hélice cónica
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>
Cria um fio de espiral plana no plano cuja normal é direction: numTurns voltas cujo raio cresce uniformemente de startRadius para endRadius.

A direção predefinida [0, 1, 0] deita-a plana no chão; clockwise inverte o enrolamento, e a curva é aproximada dentro de tolerance.
Parameters
- inputs: FlatSpiralWireDto
  Os raios inicial e final, o número de voltas, o centro, a normal do plano, o sentido de enrolamento e a tolerância
Returns Promise<TopoDSWirePointer>
O fio em espiral
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[]>
Escreve texto como fios de traço no plano do chão no tipo de letra Hershey simplex de linha única, um fio de polilinha aberto por traço de caneta.

height é a altura de uma letra maiúscula em unidades do modelo, lineSpacing e letterSpacing são múltiplos dela, align alinha linhas de comprimento diferente, e centerOnOrigin move o bloco para a origem.
Parameters
- inputs: TextWiresDto
  O texto, o seu tamanho e espaçamento, o alinhamento e as opções de colocação
Returns Promise<TopoDSWirePointer[]>
Um fio por traço, pela ordem de escrita
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>>
Escreve texto como fios de traço como textWires e agrupa-os em compostos, com o tamanho do bloco ao lado.

O resultado traz compound com o texto inteiro, characters com um composto por carácter pela ordem de escrita, width e height como a extensão do bloco ao longo de X e ao longo de Z, e center como o meio do bloco.
Parameters
- inputs: TextWiresDto
  O texto, o seu tamanho e espaçamento, o alinhamento e as opções de colocação
Returns Promise<TextWiresDataDto<TopoDSCompoundPointer>>
O composto do texto, os compostos dos caracteres e o tamanho medido
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>
Reconstrói cada aresta de um fio como uma B-spline de um dado grau, dentro de uma tolerância, e une os resultados de volta num fio.

Baixar o grau simplifica as curvas, subi-lo dá mais liberdade às operações posteriores; de qualquer modo cada nova curva fica dentro de tolerance da antiga.
Parameters
- inputs: RebuildCurveDegreeDto<TopoDSWirePointer>
  O fio, o grau para o qual reconstruir e a tolerância
Returns Promise<TopoDSWirePointer>
Um novo fio com as arestas reconstruídas
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>
Move a costura de um fio periódico fechado, o ponto onde começa e termina, para um dado parâmetro ao longo da sua curva.

A geometria não muda; só onde se considera que o fio começa. Destinado a fios de uma só aresta como círculos: cada aresta periódica é movida, as arestas que não são periódicas ficam como estão.
Parameters
- inputs: CurveSeamByParameterDto<TopoDSWirePointer>
  O fio periódico e o parâmetro da nova costura
Returns Promise<TopoDSWirePointer>
Um novo fio que começa na costura
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>
Move a costura de um fio periódico fechado, o ponto onde começa e termina, uma distância ao longo da curva a partir do seu início atual.

A geometria não muda; só onde se considera que o fio começa. Destinado a fios de uma só aresta como círculos: cada aresta periódica é movida, as arestas que não são periódicas ficam como estão.
Parameters
- inputs: CurveSeamByLengthDto<TopoDSWirePointer>
  O fio periódico e a distância a deslocar a costura
Returns Promise<TopoDSWirePointer>
Um novo fio que começa na costura
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>
Cria um fio fechado de arestas retas através de uma lista de pontos de canto, adicionando a aresta do último ponto de volta ao primeiro.

Os pontos não precisam de assentar num só plano; uma face plana precisa contudo de um contorno planar.
Parameters
- inputs: PolygonDto
  Os pontos dos cantos, por ordem
Returns Promise<TopoDSWirePointer>
O fio fechado
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>
Cria um fio reto de uma só aresta entre dois pontos.
Parameters
- inputs: Bit.Inputs.OCCT.LineDto
  Os pontos inicial e final
Returns Promise<TopoDSWirePointer>
O fio reto
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>
Cria um fio reto de uma só aresta entre dois pontos e prolonga-o para lá de cada um deles.

extensionStart e extensionEnd são distâncias em unidades do modelo acrescentadas para lá do início e do fim ao longo da linha; os dois pontos têm de ser diferentes ou é lançado um erro.
Parameters
- inputs: LineWithExtensionsDto
  Os pontos inicial e final e os dois comprimentos de prolongamento
Returns Promise<TopoDSWirePointer>
O fio reto prolongado
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>
Cria um fio aberto de arestas retas através de uma lista de pontos, por ordem.

O fio não é fechado; createPolygonWire adiciona a aresta de volta ao primeiro ponto.
Parameters
- inputs: Bit.Inputs.OCCT.PolylineDto
  Os pontos, por ordem
Returns Promise<TopoDSWirePointer>
O fio aberto
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>
Cria um fio de Bezier suave guiado por pontos de controlo: começa no primeiro ponto, termina no último e é puxado para os intermédios sem passar por eles.

closed acrescenta de novo o primeiro ponto para que as extremidades se encontrem; periodic constrói em vez disso uma curva fechada que é suave ao longo da costura. degree limita quantos vizinhos moldam cada parte.
Parameters
- inputs: BezierDto
  Os pontos de controlo e as opções de fecho e de grau
Returns Promise<TopoDSWirePointer>
O fio de Bezier
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>
Cria um fio de Bezier como createBezier, com um peso por ponto de controlo que diz quão fortemente ele puxa a curva.

Um peso acima de 1 atrai a curva para o seu ponto, abaixo de 1 deixa-a ir. Os pesos têm de corresponder aos pontos: a mesma contagem, ou mais um quando closed é verdadeiro e periodic falso, pois o primeiro ponto repete-se.
Parameters
- inputs: BezierWeightsDto
  Os pontos de controlo, os seus pesos e as opções de fecho e de grau
Returns Promise<TopoDSWirePointer>
O fio de Bezier ponderado
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>
Cria um fio B-spline suave que passa por todos os pontos por ordem.

periodic fecha a curva de modo que é suave ao longo da costura, o que dá laços bem formados. parametrization controla o espaçamento entre pontos: centripetal resiste a bicos e ultrapassagens quando os pontos são irregulares. startTangent e endTangent, ou uma entrada de tangents por ponto, forçam a direção da curva nesse sítio.
Parameters
- inputs: InterpolationDto
  Os pontos, se deve fechar a curva, a tolerância, a parametrização e tangentes opcionais
Returns Promise<TopoDSWirePointer>
O fio B-spline que passa pelos pontos
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>
Cria um fio B-spline fechado e suave através dos pontos cuja forma é simétrica em espelho sempre que os pontos o são, sem um ponto inicial ou final de aspeto estranho.

Um interpolatePoints periódico simples pode parecer torto na sua costura para entradas simétricas como um quadrado ou um triângulo; esta variante não. Falha com um erro se os pontos não puderem ser interpolados.
Parameters
- inputs: InterpolateSymmetricDto
  Os pontos e a tolerância
Returns Promise<TopoDSWirePointer>
O fio B-spline simétrico fechado
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>
Cria um fio B-spline suave que aproxima uma lista de pontos: segue-os de perto mas não precisa de passar exatamente por cada um.

closed acrescenta de novo o primeiro ponto para que as extremidades se encontrem. O ajuste usa um grau entre 3 e 8 e uma tolerância de 0.001 unidades do modelo; use interpolatePoints quando a curva tiver de passar pelos pontos.
Parameters
- inputs: BSplineDto
  Os pontos e se deve fechar a curva
Returns Promise<TopoDSWirePointer>
O fio 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>
Desenha uma linha em ziguezague que salta entre dois fios: ambos são divididos no mesmo número de pontos e uma polilinha visita-os alternadamente.

nrZigZags define o número de saltos; inverse começa no segundo fio; divideByEqualDistance espaça os pontos por comprimento em vez de por parâmetro; com zigZagsPerEdge verdadeiro cada aresta recebe o seu próprio ziguezague, por isso as contagens de arestas têm de coincidir.
Parameters
- inputs: ZigZagBetweenTwoWiresDto<TopoDSWirePointer>
  Os dois fios, o número de ziguezagues e as opções de espaçamento
Returns Promise<TopoDSWirePointer>
O fio em ziguezague
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[]>
Liga os pontos iniciais de vários fios ou arestas num novo fio e os seus pontos finais noutro.

wireType torna-os polilinhas ou curvas interpoladas suaves, closed une o último ponto de volta ao primeiro, e tolerance é usada para a interpolação. Menos de duas formas lançam um erro.
Parameters
- inputs: WiresBetweenStartEndPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  Os fios ou arestas, o tipo de fio a construir, se deve fechá-lo e a tolerância
Returns Promise<TopoDSWirePointer[]>
Dois fios: um pelos pontos iniciais, outro pelos pontos finais
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[]>
Divide vários fios ou arestas no mesmo número de pontos e liga os pontos em cada posição num novo fio, como os degraus de uma escada.

nrOfDivisions passos dão mais um degrau do que isso; divideByEqualDistance espaça os pontos por comprimento em vez de por parâmetro; wireType torna os degraus polilinhas ou curvas suaves, closed fecha cada um num laço.
Parameters
- inputs: WiresBetweenSubdividedPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  Os fios ou arestas, o número de divisões, o espaçamento, o tipo de fio a construir, se deve fechá-lo e a tolerância
Returns Promise<TopoDSWirePointer[]>
Um fio por ponto de divisão, por ordem ao longo das formas
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>
Desenha um contorno fechado à volta de dois círculos que assentam num só plano, unindo-os com linhas tangentes: uma forma de correia ou de cápsula.

keepLines escolhe as linhas tangentes exteriores (a correia) ou as interiores que se cruzam; circleRemainders escolhe qual arco de cada círculo fica no contorno. Cada fio de círculo tem de consistir numa única aresta.
Parameters
- inputs: WireFromTwoCirclesTanDto<TopoDSWirePointer>
  Os dois fios circulares, quais as linhas tangentes e arcos a manter, e a tolerância
Returns Promise<TopoDSWirePointer>
O fio de contorno fechado
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