Class OCCTWire

Alambres en OpenCascade: cadenas de aristas unidas extremo con extremo, abiertas como un camino o cerradas como un contorno. Constrúyelos a partir de puntos y curvas (polilíneas, B-splines, Beziers, interpolaciones, hélices, espirales), como contornos planos ya hechos (círculos, rectángulos, estrellas, perfiles de viga, texto) que se apoyan en el plano del suelo a menos que direction diga otra cosa, o uniendo y dividiendo aristas y alambres existentes; léelos de vuelta como puntos, tangentes, longitudes y centros; proyéctalos sobre caras o sobre formas. Los parámetros a lo largo de un alambre van de 0 en su inicio a 1 en su final y siguen el parámetro propio de cada arista, no la distancia. Un alambre cerrado es lo que shapes.face rellena para crear una cara.

Index

Constructors

constructor

new OCCTWire(): OCCTWire
Returns OCCTWire

beam profiles

createIBeamProfileWire

createIBeamProfileWire(inputs: IBeamProfileDto): Promise<TopoDSWirePointer>
Hace el contorno cerrado de la sección transversal de una viga en I: dos alas horizontales unidas por un alma vertical.

width es la anchura del ala, height la altura total, webThickness y flangeThickness los grosores de pared; alignment dice qué punto de la caja del perfil se sitúa en center, rotation lo gira en su plano, en grados. Está en el suelo, listo para extruir.
Parameters
- inputs: IBeamProfileDto
  El tamaño del perfil, los dos espesores, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre de contorno de viga en 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>
Hace el contorno cerrado de la sección transversal de una viga en H: dos alas verticales unidas por un alma horizontal, una viga en I tumbada.

width es la anchura total, height la altura del ala, webThickness y flangeThickness los grosores de pared; alignment dice qué punto de la caja del perfil se sitúa en center, rotation lo gira en su plano, en grados.
Parameters
- inputs: HBeamProfileDto
  El tamaño del perfil, los dos espesores, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre de contorno de viga en 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>
Hace el contorno cerrado de la sección transversal de una viga en T: un ala horizontal con un alma vertical que cuelga de su centro.

width es la anchura del ala, height la altura total, webThickness y flangeThickness los grosores de pared; alignment dice qué punto de la caja del perfil se sitúa en center, rotation lo gira en su plano, en grados. Está en el suelo.
Parameters
- inputs: TBeamProfileDto
  El tamaño del perfil, los dos espesores, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre de contorno de viga en 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>
Hace el contorno cerrado de la sección transversal de una viga en U, un canal: un alma con dos alas de flangeWidth levantadas desde sus extremos.

width y height son el tamaño total, webThickness y flangeThickness los grosores de pared; alignment dice qué punto de la caja del perfil se sitúa en center, rotation lo gira en su plano, en grados. Está en el suelo.
Parameters
- inputs: UBeamProfileDto
  El tamaño del perfil, los espesores, la anchura del ala, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre de contorno de viga en 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 aristas y alambres que se tocan extremo con extremo en un solo alambre.

Las piezas deben conectarse; un conjunto con un hueco o una pieza suelta lanza un error. Las formas de otros tipos en la lista se ignoran.
Parameters
- inputs: ShapesDto<TopoDSEdgePointer | TopoDSWirePointer>
  Las aristas y alambres que unir
Returns Promise<TopoDSWirePointer>
El alambre 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>
Envuelve una sola arista en un alambre, para que pueda ir donde se espera un alambre.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  La arista
Returns Promise<TopoDSWirePointer>
El alambre que contiene esa arista
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 un alambre con más aristas y alambres que lo tocan extremo con extremo.

Las piezas deben conectarse al alambre o entre sí; un hueco lanza un error. Las formas de otros tipos en la lista se ignoran.
Parameters
- inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSEdgePointer | TopoDSWirePointer>
  El alambre que extender y las aristas y alambres que añadir
Returns Promise<TopoDSWirePointer>
El alambre extendido
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>
Recopila datos de diagnóstico sobre un alambre: cuántas aristas tiene, si está cerrado, su longitud total y, para cada arista, el informe de curva que da shapes.edge.debugInfo.

Un alambre vacío o null da un informe marcado como no válido con recuentos a cero.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre que inspeccionar
Returns Promise<WireDebugInfo>
El informe con el número de aristas, el indicador de cerrado, la longitud y una entrada por arista
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>
Cierra un alambre abierto con una arista recta de su punto final de vuelta a su punto inicial.

Un alambre cuyos extremos ya se encuentran se devuelve tal cual.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre que cerrar
Returns Promise<TopoDSWirePointer>
El alambre cerrado
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 un alambre en trozos en los puntos dados.

Cada punto se mueve al lugar más cercano del alambre antes de cortar, así que no tiene por qué estar exactamente sobre él; los puntos repetidos se ignoran. Los trozos vuelven en orden a lo largo del alambre, de su inicio a su final.
Parameters
- inputs: SplitWireOnPointsDto<TopoDSWirePointer>
  El alambre y los puntos por los que cortar
Returns Promise<TopoDSWirePointer[]>
Los trozos del alambre, en orden
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[][]>
Convierte cada alambre de una forma en una serie de puntos que sigue sus curvas lo bastante de cerca para dibujarlo, una lista por alambre.

Los ajustes de desviación dicen cuán ceñidos siguen los puntos las aristas curvas; donde una arista termina y empieza la siguiente el punto compartido aparece una vez.
Parameters
- inputs: WiresToPointsDto<TopoDSShapePointer>
  La forma y los ajustes de deflexión
Returns Promise<Point3[][]>
Una lista de puntos por alambre
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 puntos a lo largo de un alambre a pasos iguales de su parámetro, del inicio al final.

nrOfDivisions pasos dan un punto más que eso; removeStartPoint y removeEndPoint descartan los extremos. El parámetro sigue el parámetro de curva propio de cada arista, así que los pasos iguales no son distancias iguales; usa divideWireByEqualDistanceToPoints para esas.
Parameters
- inputs: DivideDto<TopoDSWirePointer>
  El alambre, el número de divisiones y si descartar los puntos extremos
Returns Promise<Point3[]>
Los puntos a lo largo del alambre, en orden
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 puntos a lo largo de un alambre a distancias iguales medidas a lo largo de sus curvas, del inicio al final.

nrOfDivisions pasos dan un punto más que eso; removeStartPoint y removeEndPoint descartan los extremos.
Parameters
- inputs: DivideDto<TopoDSWirePointer>
  El alambre, el número de divisiones y si descartar los puntos extremos
Returns Promise<Point3[]>
Los puntos a lo largo del alambre, en orden
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>
Encuentra el punto a una fracción del recorrido de un alambre: 0 es el inicio, 1 el final.

La fracción sigue los parámetros de las aristas, no la distancia, así que 0.5 no siempre es el medio por longitud; usa pointOnWireAtLength para una distancia.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  El alambre y la fracción de 0 a 1
Returns Promise<Point3>
El punto en el alambre
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>
Encuentra el punto a una distancia dada a lo largo de un alambre desde su inicio, medida a lo largo de sus curvas en unidades del modelo.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  El alambre y la distancia desde su inicio
Returns Promise<Point3>
El punto en el alambre
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[]>
Encuentra los puntos a varias distancias a lo largo de un alambre desde su inicio, medidas a lo largo de sus curvas en unidades del modelo.
Parameters
- inputs: DataOnGeometryAtLengthsDto<TopoDSWirePointer>
  El alambre y las distancias desde su inicio
Returns Promise<Point3[]>
Un punto por distancia, en el mismo orden
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 puntos a lo largo de un alambre cada length unidades del modelo desde su inicio, tantos como quepan.

includeFirst conserva el punto del inicio, includeLast añade el punto final sea cual sea el espaciado, y tryNext pide un punto más un paso más allá del último que cupo.
Parameters
- inputs: PointsOnWireAtEqualLengthDto<TopoDSWirePointer>
  El alambre, el espaciado y qué puntos extremos incluir
Returns Promise<Point3[]>
Los puntos a lo largo del alambre, en orden
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 puntos a lo largo de un alambre según un patrón repetido de huecos, como 1, 3, 1, 3, hasta que el alambre se acaba.

lengths es el patrón de huecos en unidades del modelo, repetido desde el inicio; includeFirst conserva el punto inicial, includeLast añade el punto final, y tryNext pide un punto más en el siguiente hueco tras el último.
Parameters
- inputs: PointsOnWireAtPatternOfLengthsDto<TopoDSWirePointer>
  El alambre, el patrón de huecos y qué puntos extremos incluir
Returns Promise<Point3[]>
Los puntos a lo largo del alambre, en orden
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>
Encuentra la dirección en la que avanza el alambre a una fracción de su recorrido, de 0 en el inicio a 1 en el final.

La fracción sigue los parámetros de las aristas, no la distancia.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  El alambre y la fracción de 0 a 1
Returns Promise<Vector3>
La dirección 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>
Encuentra la dirección en la que avanza el alambre a una distancia dada desde su inicio, medida a lo largo de sus curvas en unidades del modelo.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  El alambre y la distancia desde su inicio
Returns Promise<Vector3>
La dirección 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 la primera, segunda y tercera derivadas de la curva de un alambre a una distancia dada desde su inicio.

La primera derivada es la tangente con su velocidad, la segunda dice cómo se curva la curva, la tercera cómo cambia esa curvatura; todas son respecto al parámetro de la curva. La distancia se mide a lo largo de las curvas en unidades del modelo.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  El alambre y la distancia desde su inicio
Returns Promise<[Vector3, Vector3, Vector3]>
Los tres vectores derivada, de la primera a la tercera
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 la primera, segunda y tercera derivadas de la curva de un alambre a una fracción de su recorrido, de 0 en el inicio a 1 en el final.

La primera derivada es la tangente con su velocidad, la segunda dice cómo se curva la curva, la tercera cómo cambia esa curvatura; todas son respecto al parámetro de la curva.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  El alambre y la fracción de 0 a 1
Returns Promise<[Vector3, Vector3, Vector3]>
Los tres vectores derivada, de la primera a la tercera
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>
Lee el punto donde empieza un alambre, en la dirección propia del alambre.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre
Returns Promise<Point3>
El punto 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>
Encuentra el punto a mitad del rango de parámetro de un alambre.

El parámetro sigue las curvas propias de las aristas, no la distancia, así que en un alambre de aristas desiguales esto no siempre es el medio por longitud; pointOnWireAtLength con la mitad de getWireLength da eso.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre
Returns Promise<Point3>
El punto en el 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>
Lee el punto donde termina un alambre, en la dirección propia del alambre.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre
Returns Promise<Point3>
El punto 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[][]>
Ejecuta divideWireByParamsToPoints sobre varios alambres con los mismos ajustes.
Parameters
- inputs: DivideShapesDto<TopoDSWirePointer>
  Los alambres, el número de divisiones y si descartar los puntos extremos
Returns Promise<Point3[][]>
Una lista de puntos por alambre, en el mismo orden
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[][]>
Ejecuta divideWireByEqualDistanceToPoints sobre varios alambres con los mismos ajustes.
Parameters
- inputs: DivideShapesDto<TopoDSWirePointer>
  Los alambres, el número de divisiones y si descartar los puntos extremos
Returns Promise<Point3[][]>
Una lista de puntos por alambre, en el mismo orden
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>
Hace un alambre recto de una sola arista a partir de un objeto de línea de la forma { start, end }.
Parameters
- inputs: LineBaseDto
  La línea
Returns Promise<TopoDSWirePointer>
El alambre recto
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[]>
Hace un alambre recto de una sola arista por cada objeto de línea de la forma { start, end }.
Parameters
- inputs: LinesBaseDto
  Las líneas
Returns Promise<TopoDSWirePointer[]>
Un alambre por línea, en el mismo orden
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>
Hace un alambre recto de una sola arista a partir de un segmento, un par de puntos [start, end].
Parameters
- inputs: SegmentBaseDto
  El segmento
Returns Promise<TopoDSWirePointer>
El alambre recto
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[]>
Hace un alambre recto de una sola arista por cada segmento, cada uno un par de puntos [start, end].
Parameters
- inputs: SegmentsBaseDto
  Los segmentos
Returns Promise<TopoDSWirePointer[]>
Un alambre por segmento, en el mismo orden
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 una lista de puntos en orden con aristas rectas en un solo alambre.

Menos de dos puntos lanzan un error. Cuando el último punto repite el primero, la repetición se descarta y el alambre se cierra de vuelta al primer punto; si no, el alambre queda abierto. Para un contorno cerrado sin repetir un punto use createPolygonWire.
Parameters
- inputs: Bit.Inputs.OCCT.PointsDto
  Los puntos, en orden
Returns Promise<TopoDSWirePointer>
El alambre que pasa por los puntos
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>
Hace un alambre a partir de un objeto de polilínea, una arista recta por segmento; una polilínea marcada como cerrada recibe también la arista de su último punto de vuelta al primero.
Parameters
- inputs: PolylineBaseDto
  La polilínea
Returns Promise<TopoDSWirePointer>
El alambre
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>
Hace un alambre cerrado de tres aristas a partir de un triángulo dado como tres puntos.
Parameters
- inputs: TriangleBaseDto
  El triángulo
Returns Promise<TopoDSWirePointer>
El alambre cerrado
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[]>
Hace un alambre cerrado de tres aristas por cada triángulo de una malla.

Un triángulo cuyo alambre no puede construirse se salta con un aviso en lugar de detener el resto.
Parameters
- inputs: MeshBaseDto
  La malla como lista de triángulos
Returns Promise<TopoDSWirePointer[]>
Un alambre por cada triángulo que se pudo 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>
Elige un alambre de una forma por su posición, contando desde 0, en el orden en que el núcleo recorre la forma.

La forma debe ser un alambre o algo construido a partir de alambres; un índice más allá del último alambre lanza un error.
Parameters
- inputs: ShapeIndexDto<TopoDSShapePointer>
  La forma y el índice, empezando en 0
Returns Promise<TopoDSWirePointer>
El alambre en ese í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 cada alambre de una forma en el orden en que lo recorre el núcleo.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forma
Returns Promise<TopoDSWirePointer[]>
Los alambres encontrados en la 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>
Encuentra el centro de masas de un alambre, el punto de equilibrio de sus curvas; para un círculo es su centro, fuera del propio alambre.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre
Returns Promise<Point3>
El punto del centro de masas
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[]>
Encuentra el centro de masas de cada alambre de una lista.
Parameters
- inputs: ShapesDto<TopoDSWirePointer>
  Los alambres
Returns Promise<Point3[]>
Un punto por alambre, en el mismo orden
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>
Invierte la dirección de un alambre, de modo que su inicio se convierte en su final.

Las aristas conservan su propio orden y sus indicadores de dirección; el alambre en conjunto se marca como invertido, que es lo que leen la mayoría de operaciones. reversedWireFromReversedEdges reconstruye el alambre arista a arista en su lugar.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre
Returns Promise<TopoDSWirePointer>
Un nuevo alambre que recorre el sentido contrario
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>
Invierte la dirección de un alambre invirtiendo cada arista y uniéndolas de nuevo en el orden contrario.

El resultado es un alambre que va en sentido contrario de principio a fin, lo que algunas operaciones necesitan cuando el simple indicador de reversedWire no basta.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre
Returns Promise<TopoDSWirePointer>
Un nuevo alambre que recorre el sentido contrario
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 si un alambre está cerrado, que es cuando sus puntos inicial y final coinciden dentro de una pequeña tolerancia.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre
Returns Promise<boolean>
True cuando los extremos se encuentran
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>
Mide la longitud de un alambre a lo largo de sus curvas, en unidades del modelo.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  El alambre
Returns Promise<number>
La longitud
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[]>
Mide la longitud de cada alambre de una lista a lo largo de sus curvas, en unidades del modelo.
Parameters
- inputs: ShapesDto<TopoDSWirePointer>
  Los alambres
Returns Promise<number[]>
Una longitud por alambre, en el mismo orden
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[]>
Hace un alambre poligonal cerrado por cada lista de puntos, como hace createPolygonWire.

Con returnCompound en true los alambres se empaquetan en una sola forma compuesta en lugar de una lista.
Parameters
- inputs: PolygonsDto
  Los polígonos y si empaquetarlos en un compuesto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Los alambres en orden, o un compuesto que los contiene
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[]>
Hace un alambre recto de una sola arista por cada definición de línea.

Con returnCompound en true los alambres se empaquetan en una sola forma compuesta en lugar de una lista.
Parameters
- inputs: Bit.Inputs.OCCT.LinesDto
  Las líneas y si empaquetarlas en un compuesto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Los alambres en orden, o un compuesto que los contiene
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[]>
Hace un alambre de polilínea abierto por cada lista de puntos, como hace createPolylineWire.

Con returnCompound en true los alambres se empaquetan en una sola forma compuesta en lugar de una lista.
Parameters
- inputs: Bit.Inputs.OCCT.PolylinesDto
  Las polilíneas y si empaquetarlas en un compuesto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Los alambres en orden, o un compuesto que los contiene
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[]>
Hace un alambre Bezier por cada definición, como hace createBezier.

Con returnCompound en true los alambres se empaquetan en una sola forma compuesta en lugar de una lista.
Parameters
- inputs: BezierWiresDto
  Las definiciones de Bezier y si empaquetarlas en un compuesto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Los alambres en orden, o un compuesto que los contiene
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[]>
Hace un alambre B-spline interpolado por cada definición, como hace interpolatePoints.

Con returnCompound en true los alambres se empaquetan en una sola forma compuesta en lugar de una lista.
Parameters
- inputs: InterpolateWiresDto
  Las definiciones de interpolación y si empaquetarlas en un compuesto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Los alambres en orden, o un compuesto que los contiene
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[]>
Hace un alambre B-spline de aproximación por cada definición, como hace createBSpline.

Con returnCompound en true los alambres se empaquetan en una sola forma compuesta en lugar de una lista.
Parameters
- inputs: BSplinesDto
  Las definiciones de B-spline y si empaquetarlas en un compuesto
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Los alambres en orden, o un compuesto que los contiene
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>
Proyecta un alambre plano dibujado en el plano del suelo sobre la superficie de una cara, como si el dibujo se envolviera alrededor de ella.

La coordenada Z del alambre se lee como U y su coordenada X como V, en los valores UV reales de la cara, que shapes.face.getUMinBound y sus hermanos informan; un dibujo que cabe dentro de esos límites aterriza en la cara.
Parameters
- inputs: WireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  El alambre en el plano del suelo y la cara
Returns Promise<TopoDSWirePointer>
El alambre tendido sobre la superficie de la cara
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[]>
Proyecta varios alambres planos dibujados en el plano del suelo sobre la superficie de una cara, como hace placeWireOnFace con uno.
Parameters
- inputs: WiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Los alambres en el plano del suelo y la cara
Returns Promise<TopoDSWirePointer[]>
Los alambres tendidos sobre la superficie de la cara, en el mismo orden
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>
Proyecta un alambre sobre una forma a lo largo de una dirección, como proyectar su sombra sobre la superficie.

El resultado es un compuesto de las curvas donde la proyección se encuentra con las caras de la forma, que pueden estar tanto en su lado cercano como en el lejano. Corta una cara con él mediante shapes.face.createFaceFromWireOnFace o úsalo como ruta.
Parameters
- inputs: ProjectWireDto<TopoDSWirePointer, TopoDSShapePointer>
  El alambre, la forma sobre la que proyectar y la dirección
Returns Promise<TopoDSCompoundPointer>
Un compuesto de las curvas proyectadas
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[]>
Proyecta varios alambres sobre una forma a lo largo de una dirección, como hace project con uno.
Parameters
- inputs: ProjectWiresDto<TopoDSWirePointer, TopoDSShapePointer>
  Los alambres, la forma sobre la que proyectar y la dirección
Returns Promise<TopoDSCompoundPointer[]>
Un compuesto de curvas proyectadas por alambre, en el mismo orden
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>
Hace un círculo completo como un alambre cerrado de una sola arista, situado en el plano cuya normal es direction; el valor predeterminado [0, 1, 0] lo tumba en el suelo.
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  El radio, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre 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[]>
Rellena un rectángulo en el plano del suelo con una cuadrícula de alambres hexagonales cerrados, centrada en el origen.

Los hexágonos se escalan para que nrHexagonsInWidth quepan a lo ancho de width y nrHexagonsInHeight a lo largo de height. Los patrones de escala, redondeo e inclusión se leen hexágono a hexágono y se repiten; los indicadores de extensión estiran las filas exteriores más allá de los bordes para cubrir el rectángulo.
Parameters
- inputs: HexagonsInGridDto
  El tamaño del rectángulo, los números de hexágonos, los indicadores de extensión y los patrones opcionales
Returns Promise<TopoDSWirePointer[]>
Un alambre por hexágono, fila por fila
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>
Hace un alambre cuadrado cerrado centrado en center.

direction es la normal de su plano: el valor predeterminado [0, 1, 0] lo tumba en el suelo.
Parameters
- inputs: Bit.Inputs.OCCT.SquareDto
  La longitud del lado, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre cuadrado
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>
Hace un alambre cerrado en forma de estrella con numRays puntas.

Las puntas llegan a outerRadius y las muescas entre ellas a innerRadius; offsetOuterEdges levanta las puntas de los rayos fuera del plano esa distancia, haciendo una estrella 3D, y half conserva la primera mitad de los rayos como un alambre abierto. Está tumbado en el suelo salvo que direction diga lo contrario.
Parameters
- inputs: Bit.Inputs.OCCT.StarDto
  Los dos radios, el número de puntas, el centro, la normal del plano y las opciones
Returns Promise<TopoDSWirePointer>
El alambre de estrella
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>
Hace un alambre cerrado con forma de árbol de Navidad estilizado: nrSkirts capas de ramas, que se estrechan de outerDist a innerDist respecto a la línea del tronco, sobre un tronco de trunkHeight y trunkWidth.

A diferencia de las otras formas planas de aquí, se levanta erguido en el plano XY, con la punta a lo largo de Y; direction es la dirección del tronco a la punta, rotation lo gira alrededor de ese eje, en grados.
Parameters
- inputs: ChristmasTreeDto
  Las proporciones del árbol, el tamaño del tronco, las opciones, el origen y la dirección del tronco a la punta
Returns Promise<TopoDSWirePointer>
El alambre del árbol
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>
Hace un alambre de polígono regular cerrado con nrCorners esquinas, todas sobre un círculo de radius.

direction es la normal del plano; el valor predeterminado [0, 1, 0] lo tumba en el suelo.
Parameters
- inputs: NGonWireDto
  El número de esquinas, el radio, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre 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>
Hace un alambre de paralelogramo cerrado: un rectángulo de width y height cuyos lados se inclinan angle grados.

Con aroundCenter en true la forma se centra en center; en caso contrario empieza ahí y se extiende en las direcciones positivas. direction es la normal del plano; el valor predeterminado [0, 1, 0] lo tumba en el suelo.
Parameters
- inputs: ParallelogramDto
  La anchura, la altura, el ángulo de inclinación, si centrarlo, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre de 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>
Hace un alambre cerrado en forma de corazón de dos mitades suaves que cabe aproximadamente en un cuadrado de sizeApprox.

rotation lo gira en su plano, en grados. direction es la normal del plano; el valor predeterminado [0, 1, 0] lo tumba en el suelo.
Parameters
- inputs: Heart2DDto
  El tamaño aproximado, la rotación, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre de corazón
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>
Hace un alambre rectangular cerrado centrado en center.

En el plano del suelo width va a lo largo de X y length a lo largo de Z; direction es la normal del plano, y el valor predeterminado [0, 1, 0] mantiene el alambre tumbado en el suelo.
Parameters
- inputs: Bit.Inputs.OCCT.RectangleDto
  La anchura, la longitud, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre rectangular
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>
Hace un alambre cerrado en forma de L: dos patas rectangulares unidas en una esquina.

La primera pata tiene widthFirst y lengthFirst, la segunda widthSecond y lengthSecond; align pone la esquina en el exterior, el interior o el medio de las patas, y rotation gira la forma en su plano, en grados. Está tumbado en el suelo salvo que direction diga lo contrario.
Parameters
- inputs: LPolygonDto
  Los dos tamaños de las patas, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSWirePointer>
El alambre en 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>
Hace una elipse completa como un alambre cerrado de una sola arista, situado en el plano cuya normal es direction.

radiusMajor no debe ser menor que radiusMinor, o el núcleo rechaza la elipse; la dirección predeterminada [0, 1, 0] lo tumba en el suelo.
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  El centro, la normal del plano y los dos radios
Returns Promise<TopoDSWirePointer>
El alambre 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>
Hace un alambre helicoidal, una espiral de radius constante que sube pitch unidades del modelo por vuelta hasta alcanzar height.

Empieza junto a center y sube a lo largo de direction; clockwise invierte el sentido de enrollado. La hélice se aproxima mediante una curva suave dentro de tolerance. Un radio, paso o altura de 0 o menos da un alambre null.
Parameters
- inputs: HelixWireDto
  El radio, el paso, la altura, el centro de la base, la dirección del eje, el sentido de giro y la tolerancia
Returns Promise<TopoDSWirePointer>
El alambre helicoidal
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>
Hace un alambre helicoidal como createHelixWire, pero dimensionado por numTurns en lugar de por una altura: la espiral sube pitch unidades del modelo por vuelta, numTurns veces.
Parameters
- inputs: HelixWireByTurnsDto
  El radio, el paso, el número de vueltas, el centro de la base, la dirección del eje, el sentido de giro y la tolerancia
Returns Promise<TopoDSWirePointer>
El alambre helicoidal
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>
Hace un alambre helicoidal cónico cuyo radio cambia uniformemente de startRadius en la base a endRadius en la cima, subiendo pitch unidades del modelo por vuelta hasta alcanzar height.

Empieza junto a center y sube a lo largo de direction; clockwise invierte el sentido de enrollado. La curva se aproxima dentro de tolerance.
Parameters
- inputs: TaperedHelixWireDto
  Los radios inicial y final, el paso, la altura, el centro de la base, la dirección del eje, el sentido de giro y la tolerancia
Returns Promise<TopoDSWirePointer>
El alambre helicoidal cónico
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>
Hace un alambre de espiral plana en el plano cuya normal es direction: numTurns vueltas cuyo radio crece uniformemente de startRadius a endRadius.

La dirección predeterminada [0, 1, 0] lo tumba en el suelo; clockwise invierte el sentido de enrollado, y la curva se aproxima dentro de tolerance.
Parameters
- inputs: FlatSpiralWireDto
  Los radios inicial y final, el número de vueltas, el centro, la normal del plano, el sentido de giro y la tolerancia
Returns Promise<TopoDSWirePointer>
El alambre en 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[]>
Escribe texto como alambres de trazo en el plano del suelo con la fuente de una sola línea Hershey simplex, un alambre de polilínea abierto por cada trazo de pluma.

height es la altura de una letra mayúscula en unidades del modelo, lineSpacing y letterSpacing son múltiplos de ella, align alinea líneas de distinta longitud, y centerOnOrigin mueve el bloque al origen.
Parameters
- inputs: TextWiresDto
  El texto, su tamaño y espaciado, la alineación y las opciones de colocación
Returns Promise<TopoDSWirePointer[]>
Un alambre por trazo, en orden de escritura
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>>
Escribe texto como alambres de trazo igual que textWires y los empaqueta en compuestos, junto con el tamaño del bloque.

El resultado lleva compound con todo el texto, characters con un compuesto por carácter en orden de escritura, width y height como la extensión del bloque a lo largo de X y a lo largo de Z, y center como el centro del bloque.
Parameters
- inputs: TextWiresDto
  El texto, su tamaño y espaciado, la alineación y las opciones de colocación
Returns Promise<TextWiresDataDto<TopoDSCompoundPointer>>
El compuesto del texto, los compuestos de los caracteres y el tamaño 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>
Reconstruye cada arista de un alambre como una B-spline de un grado dado, dentro de una tolerancia, y vuelve a unir los resultados en un alambre.

Bajar el grado simplifica las curvas, subirlo da más libertad a las operaciones posteriores; en cualquier caso cada curva nueva se queda dentro de tolerance respecto a la antigua.
Parameters
- inputs: RebuildCurveDegreeDto<TopoDSWirePointer>
  El alambre, el grado al que reconstruirlo y la tolerancia
Returns Promise<TopoDSWirePointer>
Un nuevo alambre con las aristas reconstruidas
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>
Mueve la costura de un alambre periódico cerrado, el punto donde empieza y termina, a un parámetro dado a lo largo de su curva.

La geometría no cambia; solo dónde se considera que empieza el alambre. Pensado para alambres de una sola arista como los círculos: cada arista periódica se mueve, las aristas que no son periódicas se quedan como están.
Parameters
- inputs: CurveSeamByParameterDto<TopoDSWirePointer>
  El alambre periódico y el parámetro de la nueva costura
Returns Promise<TopoDSWirePointer>
Un nuevo alambre que empieza en la 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>
Mueve la costura de un alambre periódico cerrado, el punto donde empieza y termina, una distancia a lo largo de la curva desde su inicio actual.

La geometría no cambia; solo dónde se considera que empieza el alambre. Pensado para alambres de una sola arista como los círculos: cada arista periódica se mueve, las aristas que no son periódicas se quedan como están.
Parameters
- inputs: CurveSeamByLengthDto<TopoDSWirePointer>
  El alambre periódico y la distancia que desplazar la costura
Returns Promise<TopoDSWirePointer>
Un nuevo alambre que empieza en la 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>
Hace un alambre cerrado de aristas rectas a través de una lista de puntos de esquina, añadiendo la arista del último punto de vuelta al primero.

Los puntos no tienen por qué estar en un mismo plano; una cara plana sí necesita un contorno plano.
Parameters
- inputs: PolygonDto
  Los puntos de las esquinas, en orden
Returns Promise<TopoDSWirePointer>
El alambre cerrado
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>
Hace un alambre recto de una sola arista entre dos puntos.
Parameters
- inputs: Bit.Inputs.OCCT.LineDto
  Los puntos inicial y final
Returns Promise<TopoDSWirePointer>
El alambre recto
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>
Hace un alambre recto de una sola arista entre dos puntos y lo alarga más allá de cada uno de ellos.

extensionStart y extensionEnd son distancias en unidades del modelo añadidas más allá del inicio y del final a lo largo de la línea; los dos puntos deben ser distintos o se lanza un error.
Parameters
- inputs: LineWithExtensionsDto
  Los puntos inicial y final y las dos longitudes de extensión
Returns Promise<TopoDSWirePointer>
El alambre recto extendido
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>
Hace un alambre abierto de aristas rectas a través de una lista de puntos, en orden.

El alambre no está cerrado; createPolygonWire añade la arista de vuelta al primer punto.
Parameters
- inputs: Bit.Inputs.OCCT.PolylineDto
  Los puntos, en orden
Returns Promise<TopoDSWirePointer>
El alambre abierto
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>
Hace un alambre Bezier suave dirigido por puntos de control: empieza en el primer punto, termina en el último y es atraído hacia los intermedios sin pasar por ellos.

closed añade de nuevo el primer punto para que los extremos se encuentren; periodic construye en su lugar una curva cerrada que es suave a través de la costura. degree limita cuántos vecinos dan forma a cada parte.
Parameters
- inputs: BezierDto
  Los puntos de control y las opciones de cierre y grado
Returns Promise<TopoDSWirePointer>
El alambre 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>
Hace un alambre Bezier como createBezier, con un peso por punto de control que dice con qué fuerza atrae la curva.

Un peso mayor que 1 acerca la curva a su punto, menor que 1 la suelta. Los pesos deben corresponderse con los puntos: el mismo número, o uno más cuando closed es true y periodic false, ya que el primer punto se repite.
Parameters
- inputs: BezierWeightsDto
  Los puntos de control, sus pesos y las opciones de cierre y grado
Returns Promise<TopoDSWirePointer>
El alambre 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>
Hace un alambre B-spline suave que pasa por cada punto en orden.

periodic cierra la curva para que sea suave a través de la costura, lo que da bucles bien formados. parametrization controla el espaciado entre puntos: centripetal resiste las cúspides y el sobrepaso cuando los puntos son desiguales. startTangent y endTangent, o una entrada de tangents por punto, fuerzan la dirección de la curva ahí.
Parameters
- inputs: InterpolationDto
  Los puntos, si cerrar la curva, la tolerancia, la parametrización y las tangentes opcionales
Returns Promise<TopoDSWirePointer>
El alambre B-spline que pasa por los puntos
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>
Hace un alambre B-spline suave y cerrado a través de los puntos cuya forma es simétrica respecto a un espejo siempre que los puntos lo son, sin un punto inicial o final de aspecto extraño.

Un interpolatePoints periódico simple puede parecer sesgado en su costura para entradas simétricas como un cuadrado o un triángulo; esta variante no. Falla con un error si los puntos no pueden interpolarse.
Parameters
- inputs: InterpolateSymmetricDto
  Los puntos y la tolerancia
Returns Promise<TopoDSWirePointer>
El alambre B-spline simétrico cerrado
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>
Hace un alambre B-spline suave que aproxima una lista de puntos: los sigue de cerca pero no tiene por qué pasar exactamente por cada uno.

closed añade de nuevo el primer punto para que los extremos se encuentren. El ajuste usa un grado entre 3 y 8 y una tolerancia de 0.001 unidades del modelo; usa interpolatePoints cuando la curva deba pasar por los puntos.
Parameters
- inputs: BSplineDto
  Los puntos y si cerrar la curva
Returns Promise<TopoDSWirePointer>
El alambre 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>
Dibuja una línea en zigzag que rebota entre dos alambres: ambos se dividen en el mismo número de puntos y una polilínea los visita alternativamente.

nrZigZags establece el número de rebotes; inverse empieza en el segundo alambre; divideByEqualDistance espacia los puntos por longitud en lugar de por parámetro; con zigZagsPerEdge en true cada arista recibe su propio zigzag, así que los recuentos de aristas deben coincidir.
Parameters
- inputs: ZigZagBetweenTwoWiresDto<TopoDSWirePointer>
  Los dos alambres, el número de zigzags y las opciones de espaciado
Returns Promise<TopoDSWirePointer>
El alambre en zigzag
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[]>
Conecta los puntos iniciales de varios alambres o aristas en un alambre nuevo y sus puntos finales en otro.

wireType los hace polilíneas o curvas interpoladas suaves, closed une el último punto de vuelta al primero, y tolerance se usa para la interpolación. Menos de dos formas lanzan un error.
Parameters
- inputs: WiresBetweenStartEndPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  Los alambres o aristas, el tipo de alambre que construir, si cerrarlo y la tolerancia
Returns Promise<TopoDSWirePointer[]>
Dos alambres: uno por los puntos iniciales, otro por los puntos finales
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 varios alambres o aristas en el mismo número de puntos y conecta los puntos de cada posición en un alambre nuevo, como los peldaños de una escalera.

nrOfDivisions pasos dan un peldaño más que eso; divideByEqualDistance espacia los puntos por longitud en lugar de por parámetro; wireType hace los peldaños polilíneas o curvas suaves, closed une cada uno en un bucle.
Parameters
- inputs: WiresBetweenSubdividedPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  Los alambres o aristas, el número de divisiones, el espaciado, el tipo de alambre que construir, si cerrarlo y la tolerancia
Returns Promise<TopoDSWirePointer[]>
Un alambre por punto de división, en orden a lo largo de las 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>
Dibuja un contorno cerrado alrededor de dos círculos que están en un mismo plano, uniéndolos con líneas tangentes: una forma de correa o de cápsula.

keepLines elige las líneas tangentes exteriores (la correa) o las interiores que se cruzan; circleRemainders elige qué arco de cada círculo se queda en el contorno. Cada alambre de círculo debe constar de una sola arista.
Parameters
- inputs: WireFromTwoCirclesTanDto<TopoDSWirePointer>
  Los dos alambres circulares, qué líneas tangentes y arcos conservar, y la tolerancia
Returns Promise<TopoDSWirePointer>
El alambre de contorno cerrado
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