Class OCCTWire

Fils dans OpenCascade : des chaînes d'arêtes jointes bout à bout, ouvertes comme un chemin ou fermées comme un contour. Construisez-les à partir de points et de courbes (polylignes, B-splines, Béziers, interpolations, hélices, spirales), comme contours plans prêts à l'emploi (cercles, rectangles, étoiles, profils de poutres, texte) qui reposent sur le plan du sol sauf si direction dit autrement, ou en joignant et divisant des arêtes et fils existants ; relisez-les comme points, tangentes, longueurs et centres ; appliquez-les sur des faces ou projetez-les sur des formes. Les paramètres le long d'un fil vont de 0 à son début à 1 à sa fin et suivent le paramètre propre à chaque arête, pas la distance. Un fil fermé est ce que shapes.face remplit pour faire une face.

Index

Constructors

constructor

new OCCTWire(): OCCTWire
Returns OCCTWire

beam profiles

createIBeamProfileWire

createIBeamProfileWire(inputs: IBeamProfileDto): Promise<TopoDSWirePointer>
Crée le contour fermé d'une section de poutre en I : deux ailes horizontales jointes par une âme verticale.

width est la largeur des ailes, height la hauteur totale, webThickness et flangeThickness les épaisseurs de paroi ; alignment dit quel point de la boîte du profil se place sur center, rotation le tourne dans son plan, en degrés. Il est posé sur le sol, prêt à extruder.
Parameters
- inputs: IBeamProfileDto
  La taille du profil, les deux épaisseurs, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil de contour de poutre 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>
Crée le contour fermé d'une section de poutre en H : deux ailes verticales jointes par une âme horizontale, une poutre en I sur le côté.

width est la largeur totale, height la hauteur des ailes, webThickness et flangeThickness les épaisseurs de paroi ; alignment dit quel point de la boîte du profil se place sur center, rotation le tourne dans son plan, en degrés.
Parameters
- inputs: HBeamProfileDto
  La taille du profil, les deux épaisseurs, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil de contour de poutre 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>
Crée le contour fermé d'une section de poutre en T : une aile horizontale avec une âme verticale suspendue à son milieu.

width est la largeur de l'aile, height la hauteur totale, webThickness et flangeThickness les épaisseurs de paroi ; alignment dit quel point de la boîte du profil se place sur center, rotation le tourne dans son plan, en degrés. Il est posé sur le sol.
Parameters
- inputs: TBeamProfileDto
  La taille du profil, les deux épaisseurs, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil de contour de poutre 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>
Crée le contour fermé d'une section de poutre en U, un profilé en C : une âme avec deux ailes de flangeWidth dressées à ses extrémités.

width et height sont la taille totale, webThickness et flangeThickness les épaisseurs de paroi ; alignment dit quel point de la boîte du profil se place sur center, rotation le tourne dans son plan, en degrés. Il est posé sur le sol.
Parameters
- inputs: UBeamProfileDto
  La taille du profil, les épaisseurs, la largeur des ailes, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil de contour de poutre 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>
Réunit des arêtes et des fils qui se touchent bout à bout en un seul fil.

Les morceaux doivent se connecter ; un ensemble avec un trou ou un morceau isolé lève une erreur. Les formes d'autres types dans la liste sont ignorées.
Parameters
- inputs: ShapesDto<TopoDSEdgePointer | TopoDSWirePointer>
  Les arêtes et fils à assembler
Returns Promise<TopoDSWirePointer>
Le fil assemblé
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>
Enveloppe une seule arête dans un fil, pour qu'elle puisse aller là où un fil est attendu.
Parameters
- inputs: ShapeDto<TopoDSEdgePointer>
  L'arête
Returns Promise<TopoDSWirePointer>
Le fil contenant cette arête
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>
Prolonge un fil avec d'autres arêtes et fils qui le touchent bout à bout.

Les morceaux doivent se connecter au fil ou entre eux ; un trou lève une erreur. Les formes d'autres types dans la liste sont ignorées.
Parameters
- inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSEdgePointer | TopoDSWirePointer>
  Le fil à prolonger et les arêtes et fils à ajouter
Returns Promise<TopoDSWirePointer>
Le fil prolongé
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>
Rassemble des informations de diagnostic sur un fil : combien d'arêtes il a, s'il est fermé, sa longueur totale et, pour chaque arête, le rapport de courbe que shapes.edge.debugInfo donne.

Un fil vide ou null donne un rapport marqué invalide avec des comptes à zéro.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil à inspecter
Returns Promise<WireDebugInfo>
Le rapport avec le nombre d'arêtes, l'indicateur de fermeture, la longueur et une entrée par arête
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>
Ferme un fil ouvert par une arête droite de son point d'arrivée à son point de départ.

Un fil dont les extrémités se rejoignent déjà est renvoyé tel quel.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil à fermer
Returns Promise<TopoDSWirePointer>
Le fil fermé
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[]>
Coupe un fil en morceaux aux points donnés.

Chaque point est déplacé à l'endroit le plus proche sur le fil avant la coupe, il n'a donc pas besoin d'être exactement dessus ; les points répétés sont ignorés. Les morceaux reviennent dans l'ordre le long du fil, de son début à sa fin.
Parameters
- inputs: SplitWireOnPointsDto<TopoDSWirePointer>
  Le fil et les points où couper
Returns Promise<TopoDSWirePointer[]>
Les morceaux du fil, dans l'ordre
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[][]>
Transforme chaque fil d'une forme en une suite de points qui suit ses courbes d'assez près pour le dessiner, une liste par fil.

Les réglages de déflexion disent à quel point les points épousent les arêtes courbes ; là où une arête finit et la suivante commence, le point partagé apparaît une fois.
Parameters
- inputs: WiresToPointsDto<TopoDSShapePointer>
  La forme et les réglages de déflexion
Returns Promise<Point3[][]>
Une liste de points par fil
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[]>
Place des points le long d'un fil à pas égaux de son paramètre, du début à la fin.

nrOfDivisions pas donnent un point de plus que cela ; removeStartPoint et removeEndPoint retirent les extrémités. Le paramètre suit le paramètre de courbe propre de chaque arête, des pas égaux ne sont donc pas des distances égales ; utilisez divideWireByEqualDistanceToPoints pour celles-ci.
Parameters
- inputs: DivideDto<TopoDSWirePointer>
  Le fil, le nombre de divisions et s'il faut omettre les points d'extrémité
Returns Promise<Point3[]>
Les points le long du fil, dans l'ordre
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[]>
Place des points le long d'un fil à distances égales mesurées le long de ses courbes, du début à la fin.

nrOfDivisions pas donnent un point de plus que cela ; removeStartPoint et removeEndPoint retirent les extrémités.
Parameters
- inputs: DivideDto<TopoDSWirePointer>
  Le fil, le nombre de divisions et s'il faut omettre les points d'extrémité
Returns Promise<Point3[]>
Les points le long du fil, dans l'ordre
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>
Trouve le point situé à une fraction du chemin le long d'un fil : 0 est le début, 1 la fin.

La fraction suit les paramètres des arêtes, pas la distance, 0.5 n'est donc pas toujours le milieu en longueur ; utilisez pointOnWireAtLength pour une distance.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  Le fil et la fraction de 0 à 1
Returns Promise<Point3>
Le point sur le fil
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>
Trouve le point à une distance donnée le long d'un fil depuis son début, mesurée le long de ses courbes en unités du modèle.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  Le fil et la distance depuis son début
Returns Promise<Point3>
Le point sur le fil
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[]>
Trouve les points à plusieurs distances le long d'un fil depuis son début, mesurées le long de ses courbes en unités du modèle.
Parameters
- inputs: DataOnGeometryAtLengthsDto<TopoDSWirePointer>
  Le fil et les distances depuis son début
Returns Promise<Point3[]>
Un point par distance, dans le même ordre
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[]>
Place des points le long d'un fil toutes les length unités du modèle depuis son début, autant qu'il en tient.

includeFirst garde le point au début, includeLast ajoute le point d'arrivée quel que soit l'espacement, et tryNext demande un point de plus un pas au-delà du dernier qui tenait.
Parameters
- inputs: PointsOnWireAtEqualLengthDto<TopoDSWirePointer>
  Le fil, l'espacement et les points d'extrémité à inclure
Returns Promise<Point3[]>
Les points le long du fil, dans l'ordre
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[]>
Place des points le long d'un fil selon un motif répété d'écarts, comme 1, 3, 1, 3, jusqu'à épuisement du fil.

lengths est le motif d'écarts en unités du modèle, répété depuis le début ; includeFirst garde le point de départ, includeLast ajoute le point d'arrivée, et tryNext demande un point de plus à l'écart suivant après le dernier.
Parameters
- inputs: PointsOnWireAtPatternOfLengthsDto<TopoDSWirePointer>
  Le fil, le motif d'écarts et les points d'extrémité à inclure
Returns Promise<Point3[]>
Les points le long du fil, dans l'ordre
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>
Trouve la direction dans laquelle le fil se dirige à une fraction du chemin le long de lui, de 0 au début à 1 à la fin.

La fraction suit les paramètres des arêtes, pas la distance.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  Le fil et la fraction de 0 à 1
Returns Promise<Vector3>
La direction de la 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>
Trouve la direction dans laquelle le fil se dirige à une distance donnée de son début, mesurée le long de ses courbes en unités du modèle.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  Le fil et la distance depuis son début
Returns Promise<Vector3>
La direction de la 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]>
Calcule les dérivées première, seconde et troisième de la courbe d'un fil à une distance donnée de son début.

La dérivée première est la tangente avec sa vitesse, la seconde dit comment la courbe se plie, la troisième comment cette courbure change ; toutes sont par rapport au paramètre de la courbe. La distance est mesurée le long des courbes en unités du modèle.
Parameters
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  Le fil et la distance depuis son début
Returns Promise<[Vector3, Vector3, Vector3]>
Les trois vecteurs dérivés, du premier au troisième
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]>
Calcule les dérivées première, seconde et troisième de la courbe d'un fil à une fraction du chemin le long de lui, de 0 au début à 1 à la fin.

La dérivée première est la tangente avec sa vitesse, la seconde dit comment la courbe se plie, la troisième comment cette courbure change ; toutes sont par rapport au paramètre de la courbe.
Parameters
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  Le fil et la fraction de 0 à 1
Returns Promise<[Vector3, Vector3, Vector3]>
Les trois vecteurs dérivés, du premier au troisième
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>
Lit le point où un fil commence, dans le sens propre du fil.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil
Returns Promise<Point3>
Le point de départ
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>
Trouve le point à mi-chemin de la plage de paramètres d'un fil.

Le paramètre suit les courbes propres des arêtes, pas la distance, sur un fil aux arêtes inégales ce n'est donc pas toujours le milieu en longueur ; pointOnWireAtLength avec la moitié de getWireLength donne celui-ci.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil
Returns Promise<Point3>
Le point au paramètre 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>
Lit le point où un fil finit, dans le sens propre du fil.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil
Returns Promise<Point3>
Le point d'arrivée
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[][]>
Exécute divideWireByParamsToPoints sur plusieurs fils avec les mêmes réglages.
Parameters
- inputs: DivideShapesDto<TopoDSWirePointer>
  Les fils, le nombre de divisions et s'il faut omettre les points d'extrémité
Returns Promise<Point3[][]>
Une liste de points par fil, dans le même ordre
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[][]>
Exécute divideWireByEqualDistanceToPoints sur plusieurs fils avec les mêmes réglages.
Parameters
- inputs: DivideShapesDto<TopoDSWirePointer>
  Les fils, le nombre de divisions et s'il faut omettre les points d'extrémité
Returns Promise<Point3[][]>
Une liste de points par fil, dans le même ordre
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>
Crée un fil droit à une seule arête à partir d'un objet ligne de la forme { start, end }.
Parameters
- inputs: LineBaseDto
  La ligne
Returns Promise<TopoDSWirePointer>
Le fil droit
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[]>
Crée un fil droit à une seule arête par objet ligne de la forme { start, end }.
Parameters
- inputs: LinesBaseDto
  Les lignes
Returns Promise<TopoDSWirePointer[]>
Un fil par ligne, dans le même ordre
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>
Crée un fil droit à une seule arête à partir d'un segment, une paire de points [start, end].
Parameters
- inputs: SegmentBaseDto
  Le segment
Returns Promise<TopoDSWirePointer>
Le fil droit
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[]>
Crée un fil droit à une seule arête par segment, chacun une paire de points [start, end].
Parameters
- inputs: SegmentsBaseDto
  Les segments
Returns Promise<TopoDSWirePointer[]>
Un fil par segment, dans le même ordre
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>
Joint une liste de points dans l'ordre par des arêtes droites en un seul fil.

Moins de deux points lèvent une erreur. Quand le dernier point répète le premier, la répétition est supprimée et le fil est refermé sur le premier point ; sinon le fil reste ouvert. Pour un contour fermé sans répéter un point, utilisez createPolygonWire.
Parameters
- inputs: Bit.Inputs.OCCT.PointsDto
  Les points, dans l'ordre
Returns Promise<TopoDSWirePointer>
Le fil passant par les points
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>
Crée un fil à partir d'un objet polyligne, une arête droite par segment ; une polyligne marquée fermée reçoit aussi l'arête de son dernier point à son premier.
Parameters
- inputs: PolylineBaseDto
  La polyligne
Returns Promise<TopoDSWirePointer>
Le fil
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>
Crée un fil fermé à trois arêtes à partir d'un triangle donné par trois points.
Parameters
- inputs: TriangleBaseDto
  Le triangle
Returns Promise<TopoDSWirePointer>
Le fil fermé
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[]>
Crée un fil fermé à trois arêtes par triangle d'un maillage.

Un triangle dont le fil ne peut pas être construit est sauté avec un avertissement plutôt que d'arrêter le reste.
Parameters
- inputs: MeshBaseDto
  Le maillage sous forme de liste de triangles
Returns Promise<TopoDSWirePointer[]>
Un fil par triangle qui a pu être construit
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>
Choisit un fil d'une forme par sa position, en comptant à partir de 0, dans l'ordre où le noyau parcourt la forme.

La forme doit être un fil ou quelque chose construit à partir de fils ; un index au-delà du dernier fil lève une erreur.
Parameters
- inputs: ShapeIndexDto<TopoDSShapePointer>
  La forme et l'index à partir de 0
Returns Promise<TopoDSWirePointer>
Le fil à cet index
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[]>
Liste chaque fil d'une forme dans l'ordre où le noyau la parcourt.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<TopoDSWirePointer[]>
Les fils trouvés dans la forme
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>
Trouve le centre de masse d'un fil, le point d'équilibre de ses courbes ; pour un cercle c'est son centre, hors du fil lui-même.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil
Returns Promise<Point3>
Le point du centre de masse
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[]>
Trouve le centre de masse de chaque fil d'une liste.
Parameters
- inputs: ShapesDto<TopoDSWirePointer>
  Les fils
Returns Promise<Point3[]>
Un point par fil, dans le même ordre
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>
Inverse le sens d'un fil, de sorte que son début devient sa fin.

Les arêtes gardent leur propre ordre et leurs indicateurs de sens ; le fil dans son ensemble est marqué inversé, ce qui est ce que la plupart des opérations lisent. reversedWireFromReversedEdges reconstruit plutôt le fil arête par arête.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil
Returns Promise<TopoDSWirePointer>
Un nouveau fil parcouru dans l'autre sens
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>
Inverse le sens d'un fil en inversant chaque arête et en les rejoignant dans l'ordre opposé.

Le résultat est un fil qui va dans l'autre sens de part en part, ce dont certaines opérations ont besoin là où le simple indicateur reversedWire ne suffit pas.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil
Returns Promise<TopoDSWirePointer>
Un nouveau fil parcouru dans l'autre sens
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>
Indique si un fil est fermé, c'est-à-dire quand ses points de départ et d'arrivée coïncident à une petite tolérance près.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil
Returns Promise<boolean>
Vrai quand les extrémités se rejoignent
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>
Mesure la longueur d'un fil le long de ses courbes, en unités du modèle.
Parameters
- inputs: ShapeDto<TopoDSWirePointer>
  Le fil
Returns Promise<number>
La longueur
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[]>
Mesure la longueur de chaque fil d'une liste le long de ses courbes, en unités du modèle.
Parameters
- inputs: ShapesDto<TopoDSWirePointer>
  Les fils
Returns Promise<number[]>
Une longueur par fil, dans le même ordre
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[]>
Crée un fil polygonal fermé par liste de points, comme le fait createPolygonWire.

Avec returnCompound vrai, les fils sont regroupés dans une seule forme composée au lieu d'une liste.
Parameters
- inputs: PolygonsDto
  Les polygones et s'il faut les regrouper dans un composé
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Les fils dans l'ordre, ou un composé qui les contient
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[]>
Crée un fil droit à une seule arête par définition de ligne.

Avec returnCompound vrai, les fils sont regroupés dans une seule forme composée au lieu d'une liste.
Parameters
- inputs: Bit.Inputs.OCCT.LinesDto
  Les lignes et s'il faut les regrouper dans un composé
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Les fils dans l'ordre, ou un composé qui les contient
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[]>
Crée un fil polyligne ouvert par liste de points, comme le fait createPolylineWire.

Avec returnCompound vrai, les fils sont regroupés dans une seule forme composée au lieu d'une liste.
Parameters
- inputs: Bit.Inputs.OCCT.PolylinesDto
  Les polylignes et s'il faut les regrouper dans un composé
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Les fils dans l'ordre, ou un composé qui les contient
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[]>
Crée un fil de Bézier par définition, comme le fait createBezier.

Avec returnCompound vrai, les fils sont regroupés dans une seule forme composée au lieu d'une liste.
Parameters
- inputs: BezierWiresDto
  Les définitions de Bézier et s'il faut les regrouper dans un composé
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Les fils dans l'ordre, ou un composé qui les contient
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[]>
Crée un fil B-spline interpolé par définition, comme le fait interpolatePoints.

Avec returnCompound vrai, les fils sont regroupés dans une seule forme composée au lieu d'une liste.
Parameters
- inputs: InterpolateWiresDto
  Les définitions d'interpolation et s'il faut les regrouper dans un composé
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Les fils dans l'ordre, ou un composé qui les contient
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[]>
Crée un fil B-spline d'approximation par définition, comme le fait createBSpline.

Avec returnCompound vrai, les fils sont regroupés dans une seule forme composée au lieu d'une liste.
Parameters
- inputs: BSplinesDto
  Les définitions de B-spline et s'il faut les regrouper dans un composé
Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Les fils dans l'ordre, ou un composé qui les contient
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>
Reporte un fil plat dessiné sur le plan du sol sur la surface d'une face, comme si le dessin était enroulé autour d'elle.

La coordonnée Z du fil est lue comme U et sa coordonnée X comme V, dans les vraies valeurs UV de la face, que shapes.face.getUMinBound et ses semblables rapportent ; un dessin qui tient dans ces limites atterrit sur la face.
Parameters
- inputs: WireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Le fil sur le plan du sol et la face
Returns Promise<TopoDSWirePointer>
Le fil posé sur la surface de la 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[]>
Reporte plusieurs fils plats dessinés sur le plan du sol sur la surface d'une face, comme placeWireOnFace le fait pour un seul.
Parameters
- inputs: WiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Les fils sur le plan du sol et la face
Returns Promise<TopoDSWirePointer[]>
Les fils posés sur la surface de la face, dans le même ordre
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>
Projette un fil sur une forme le long d'une direction, comme en projetant son ombre sur la surface.

Le résultat est un composé des courbes là où la projection rencontre les faces de la forme, qui peuvent être sur son côté proche comme sur son côté éloigné. Découpez une face avec lui via shapes.face.createFaceFromWireOnFace ou utilisez-le comme chemin.
Parameters
- inputs: ProjectWireDto<TopoDSWirePointer, TopoDSShapePointer>
  Le fil, la forme sur laquelle projeter et la direction
Returns Promise<TopoDSCompoundPointer>
Un composé des courbes projetées
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[]>
Projette plusieurs fils sur une forme le long d'une direction, comme project le fait pour un seul.
Parameters
- inputs: ProjectWiresDto<TopoDSWirePointer, TopoDSShapePointer>
  Les fils, la forme sur laquelle projeter et la direction
Returns Promise<TopoDSCompoundPointer[]>
Un composé de courbes projetées par fil, dans le même ordre
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>
Crée un cercle complet sous forme de fil fermé à une seule arête, posé dans le plan dont la normale est direction ; la valeur par défaut [0, 1, 0] le pose à plat sur le sol.
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  Le rayon, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil circulaire
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[]>
Remplit un rectangle sur le plan du sol avec une grille de fils hexagonaux fermés, centrée sur l'origine.

Les hexagones sont mis à l'échelle pour que nrHexagonsInWidth tiennent sur width et nrHexagonsInHeight sur height. Les motifs d'échelle, de congé et d'inclusion sont lus hexagone par hexagone et se répètent ; les indicateurs d'extension étirent les rangées extérieures au-delà des bords pour couvrir le rectangle.
Parameters
- inputs: HexagonsInGridDto
  La taille du rectangle, les nombres d'hexagones, les indicateurs d'extension et les motifs facultatifs
Returns Promise<TopoDSWirePointer[]>
Un fil par hexagone, rangée par rangée
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>
Crée un fil carré fermé centré sur center.

direction est la normale de son plan : la valeur par défaut [0, 1, 0] le pose à plat sur le sol.
Parameters
- inputs: Bit.Inputs.OCCT.SquareDto
  La longueur du côté, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil carré
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>
Crée un fil fermé en forme d'étoile à numRays pointes.

Les pointes atteignent outerRadius et les creux entre elles innerRadius ; offsetOuterEdges soulève les bouts des rayons hors du plan de cette distance, ce qui fait une étoile 3D, et half garde la première moitié des rayons sous forme de fil ouvert. Elle est posée à plat sur le sol sauf si direction dit autrement.
Parameters
- inputs: Bit.Inputs.OCCT.StarDto
  Les deux rayons, le nombre de branches, le centre, la normale du plan et les options
Returns Promise<TopoDSWirePointer>
Le fil en étoile
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>
Crée un fil fermé en forme de sapin de Noël stylisé : nrSkirts couches de branches, se rétrécissant de outerDist à innerDist par rapport à la ligne du tronc, sur un tronc de trunkHeight et trunkWidth.

Contrairement aux autres formes plates d'ici, il se dresse dans le plan XY, la pointe le long de Y ; direction est la direction du tronc vers la pointe, rotation le fait tourner autour de cet axe, en degrés.
Parameters
- inputs: ChristmasTreeDto
  Les proportions du sapin, la taille du tronc, les options, l'origine et la direction du tronc vers la cime
Returns Promise<TopoDSWirePointer>
Le fil en sapin
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>
Crée un fil polygonal régulier fermé à nrCorners coins, tous sur un cercle de radius.

direction est la normale du plan ; la valeur par défaut [0, 1, 0] le pose à plat sur le sol.
Parameters
- inputs: NGonWireDto
  Le nombre de coins, le rayon, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil polygonal
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>
Crée un fil de parallélogramme fermé : un rectangle de width et height dont les côtés penchent de angle degrés.

Avec aroundCenter vrai, la forme est centrée sur center ; sinon elle y commence et s'étend dans les directions positives. direction est la normale du plan ; la valeur par défaut [0, 1, 0] le pose à plat sur le sol.
Parameters
- inputs: ParallelogramDto
  La largeur, la hauteur, l'angle d'inclinaison, s'il faut le centrer, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil en parallélogramme
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>
Crée un fil fermé en forme de cœur à deux moitiés lisses qui tient à peu près dans un carré de sizeApprox.

rotation le fait tourner dans son plan, en degrés. direction est la normale du plan ; la valeur par défaut [0, 1, 0] le pose à plat sur le sol.
Parameters
- inputs: Heart2DDto
  La taille approximative, la rotation, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil en cœur
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>
Crée un fil rectangulaire fermé centré sur center.

Sur le plan du sol, width suit X et length suit Z ; direction est la normale du plan, et la valeur par défaut [0, 1, 0] garde le fil à plat sur le sol.
Parameters
- inputs: Bit.Inputs.OCCT.RectangleDto
  La largeur, la longueur, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil rectangulaire
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>
Crée un fil fermé en forme de L : deux branches rectangulaires jointes à un coin.

La première branche a widthFirst et lengthFirst, la seconde widthSecond et lengthSecond ; align place le coin à l'extérieur, à l'intérieur ou au milieu des branches, et rotation tourne la forme dans son plan, en degrés. Elle est posée à plat sur le sol sauf si direction dit autrement.
Parameters
- inputs: LPolygonDto
  Les tailles des deux branches, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSWirePointer>
Le fil en 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>
Crée une ellipse complète sous forme de fil fermé à une seule arête, posé dans le plan dont la normale est direction.

radiusMajor ne doit pas être plus petit que radiusMinor, sinon le noyau refuse l'ellipse ; la direction par défaut [0, 1, 0] la pose à plat sur le sol.
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  Le centre, la normale du plan et les deux rayons
Returns Promise<TopoDSWirePointer>
Le fil elliptique
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>
Crée un fil hélicoïdal, une spire de radius constant qui monte de pitch unités du modèle par tour jusqu'à atteindre height.

Elle commence à côté de center et monte le long de direction ; clockwise inverse l'enroulement. L'hélice est approchée par une courbe lisse à tolerance près. Un rayon, un pas ou une hauteur de 0 ou moins donne un fil null.
Parameters
- inputs: HelixWireDto
  Le rayon, le pas, la hauteur, le centre de la base, la direction de l'axe, le sens d'enroulement et la tolérance
Returns Promise<TopoDSWirePointer>
Le fil hélicoïdal
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>
Crée un fil hélicoïdal comme createHelixWire, mais dimensionné par numTurns au lieu d'une hauteur : la spire monte de pitch unités du modèle par tour, numTurns fois.
Parameters
- inputs: HelixWireByTurnsDto
  Le rayon, le pas, le nombre de tours, le centre de la base, la direction de l'axe, le sens d'enroulement et la tolérance
Returns Promise<TopoDSWirePointer>
Le fil hélicoïdal
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>
Crée un fil hélicoïdal conique dont le rayon change régulièrement de startRadius à la base à endRadius au sommet, montant de pitch unités du modèle par tour jusqu'à atteindre height.

Il commence à côté de center et monte le long de direction ; clockwise inverse l'enroulement. La courbe est approchée à tolerance près.
Parameters
- inputs: TaperedHelixWireDto
  Les rayons de départ et d'arrivée, le pas, la hauteur, le centre de la base, la direction de l'axe, le sens d'enroulement et la tolérance
Returns Promise<TopoDSWirePointer>
Le fil hélicoïdal conique
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>
Crée un fil en spirale plate dans le plan dont la normale est direction : numTurns tours dont le rayon croît régulièrement de startRadius à endRadius.

La direction par défaut [0, 1, 0] la pose à plat sur le sol ; clockwise inverse l'enroulement, et la courbe est approchée à tolerance près.
Parameters
- inputs: FlatSpiralWireDto
  Les rayons de départ et d'arrivée, le nombre de tours, le centre, la normale du plan, le sens d'enroulement et la tolérance
Returns Promise<TopoDSWirePointer>
Le fil en spirale
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[]>
Écrit du texte sous forme de fils de traits sur le plan du sol dans la police simplex Hershey à trait unique, un fil polyligne ouvert par trait de plume.

height est la hauteur d'une lettre majuscule en unités du modèle, lineSpacing et letterSpacing en sont des multiples, align aligne les lignes de longueurs différentes, et centerOnOrigin déplace le bloc à l'origine.
Parameters
- inputs: TextWiresDto
  Le texte, sa taille et son espacement, l'alignement et les options de placement
Returns Promise<TopoDSWirePointer[]>
Un fil par trait, dans l'ordre d'écriture
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>>
Écrit du texte sous forme de fils de traits comme textWires et les regroupe dans des composés, avec la taille du bloc à côté.

Le résultat porte compound avec tout le texte, characters avec un composé par caractère dans l'ordre d'écriture, width et height comme étendue du bloc le long de X et le long de Z, et center comme milieu du bloc.
Parameters
- inputs: TextWiresDto
  Le texte, sa taille et son espacement, l'alignement et les options de placement
Returns Promise<TextWiresDataDto<TopoDSCompoundPointer>>
Le composé du texte, les composés des caractères et la taille mesurée
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>
Reconstruit chaque arête d'un fil en B-spline d'un degré donné, à une tolérance près, et rejoint les résultats en un fil.

Baisser le degré simplifie les courbes, l'augmenter donne plus de liberté aux opérations ultérieures ; dans les deux cas chaque nouvelle courbe reste à moins de tolerance de l'ancienne.
Parameters
- inputs: RebuildCurveDegreeDto<TopoDSWirePointer>
  Le fil, le degré vers lequel reconstruire et la tolérance
Returns Promise<TopoDSWirePointer>
Un nouveau fil avec les arêtes reconstruites
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>
Déplace la couture d'un fil périodique fermé, le point où il commence et finit, vers un paramètre donné le long de sa courbe.

La géométrie ne change pas ; seulement l'endroit où le fil est considéré comme commençant. Destiné aux fils à une seule arête tels que les cercles : chaque arête périodique est déplacée, les arêtes non périodiques restent telles quelles.
Parameters
- inputs: CurveSeamByParameterDto<TopoDSWirePointer>
  Le fil périodique et le paramètre de la nouvelle couture
Returns Promise<TopoDSWirePointer>
Un nouveau fil commençant à la couture
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>
Déplace la couture d'un fil périodique fermé, le point où il commence et finit, d'une distance le long de la courbe depuis son début actuel.

La géométrie ne change pas ; seulement l'endroit où le fil est considéré comme commençant. Destiné aux fils à une seule arête tels que les cercles : chaque arête périodique est déplacée, les arêtes non périodiques restent telles quelles.
Parameters
- inputs: CurveSeamByLengthDto<TopoDSWirePointer>
  Le fil périodique et la distance de déplacement de la couture
Returns Promise<TopoDSWirePointer>
Un nouveau fil commençant à la couture
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>
Crée un fil fermé d'arêtes droites passant par une liste de points de coin, en ajoutant l'arête du dernier point au premier.

Les points n'ont pas besoin d'être dans un même plan ; une face plane a cependant besoin d'un contour plan.
Parameters
- inputs: PolygonDto
  Les points de coin, dans l'ordre
Returns Promise<TopoDSWirePointer>
Le fil fermé
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>
Crée un fil droit à une seule arête entre deux points.
Parameters
- inputs: Bit.Inputs.OCCT.LineDto
  Les points de départ et d'arrivée
Returns Promise<TopoDSWirePointer>
Le fil droit
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>
Crée un fil droit à une seule arête entre deux points et le prolonge au-delà de chacun d'eux.

extensionStart et extensionEnd sont des distances en unités du modèle ajoutées au-delà du début et de la fin le long de la ligne ; les deux points doivent différer, sinon une erreur est levée.
Parameters
- inputs: LineWithExtensionsDto
  Les points de départ et d'arrivée et les deux longueurs de prolongement
Returns Promise<TopoDSWirePointer>
Le fil droit prolongé
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>
Crée un fil ouvert d'arêtes droites passant par une liste de points, dans l'ordre.

Le fil n'est pas fermé ; createPolygonWire ajoute l'arête de retour au premier point.
Parameters
- inputs: Bit.Inputs.OCCT.PolylineDto
  Les points, dans l'ordre
Returns Promise<TopoDSWirePointer>
Le fil ouvert
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>
Crée un fil de Bézier lisse guidé par des points de contrôle : il commence au premier point, finit au dernier et est attiré vers ceux entre les deux sans passer par eux.

closed ajoute à nouveau le premier point pour que les extrémités se rejoignent ; periodic construit plutôt une courbe fermée lisse à travers la couture. degree limite le nombre de voisins qui façonnent chaque partie.
Parameters
- inputs: BezierDto
  Les points de contrôle et les options de fermeture et de degré
Returns Promise<TopoDSWirePointer>
Le fil de Bézier
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>
Crée un fil de Bézier comme createBezier, avec un poids par point de contrôle qui dit avec quelle force il attire la courbe.

Un poids supérieur à 1 attire la courbe vers son point, inférieur à 1 la laisse aller. Les poids doivent correspondre aux points : le même nombre, ou un de plus quand closed est vrai et periodic faux, puisque le premier point se répète.
Parameters
- inputs: BezierWeightsDto
  Les points de contrôle, leurs poids et les options de fermeture et de degré
Returns Promise<TopoDSWirePointer>
Le fil de Bézier pondéré
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>
Crée un fil B-spline lisse qui passe par chaque point dans l'ordre.

periodic ferme la courbe pour qu'elle soit lisse à travers la couture, ce qui donne des boucles bien formées. parametrization contrôle l'espacement entre les points : centripetal résiste aux pointes et aux dépassements quand les points sont irréguliers. startTangent et endTangent, ou une entrée tangents par point, imposent la direction de la courbe à cet endroit.
Parameters
- inputs: InterpolationDto
  Les points, s'il faut fermer la courbe, la tolérance, la paramétrisation et des tangentes facultatives
Returns Promise<TopoDSWirePointer>
Le fil B-spline passant par les points
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>
Crée un fil B-spline fermé et lisse passant par les points dont la forme est symétrique en miroir chaque fois que les points le sont, sans point de départ ou d'arrivée d'aspect étrange.

Un interpolatePoints périodique simple peut paraître déformé à sa couture pour des entrées symétriques telles qu'un carré ou un triangle ; cette variante non. Elle échoue avec une erreur si les points ne peuvent pas être interpolés.
Parameters
- inputs: InterpolateSymmetricDto
  Les points et la tolérance
Returns Promise<TopoDSWirePointer>
Le fil B-spline symétrique fermé
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>
Crée un fil B-spline lisse qui approche une liste de points : il les suit de près mais n'a pas besoin de passer exactement par chacun.

closed ajoute à nouveau le premier point pour que les extrémités se rejoignent. L'ajustement utilise un degré entre 3 et 8 et une tolérance de 0.001 unités du modèle ; utilisez interpolatePoints quand la courbe doit passer par les points.
Parameters
- inputs: BSplineDto
  Les points et s'il faut fermer la courbe
Returns Promise<TopoDSWirePointer>
Le fil 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>
Trace une ligne en zigzag qui rebondit entre deux fils : les deux sont divisés en un même nombre de points et une polyligne les visite alternativement.

nrZigZags règle le nombre de rebonds ; inverse commence sur le second fil ; divideByEqualDistance espace les points selon la longueur plutôt que le paramètre ; avec zigZagsPerEdge vrai chaque arête reçoit son propre zigzag, les nombres d'arêtes doivent donc correspondre.
Parameters
- inputs: ZigZagBetweenTwoWiresDto<TopoDSWirePointer>
  Les deux fils, le nombre de zigzags et les options d'espacement
Returns Promise<TopoDSWirePointer>
Le fil 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[]>
Relie les points de départ de plusieurs fils ou arêtes en un nouveau fil et leurs points d'arrivée en un autre.

wireType en fait des polylignes ou des courbes interpolées lisses, closed rejoint le dernier point au premier, et tolerance est utilisée pour l'interpolation. Moins de deux formes lèvent une erreur.
Parameters
- inputs: WiresBetweenStartEndPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  Les fils ou arêtes, le type de fil à construire, s'il faut le fermer et la tolérance
Returns Promise<TopoDSWirePointer[]>
Deux fils : un par les points de départ, un par les points d'arrivée
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[]>
Divise plusieurs fils ou arêtes en un même nombre de points et relie les points à chaque position en un nouveau fil, comme les barreaux d'une échelle.

nrOfDivisions pas donnent un barreau de plus que cela ; divideByEqualDistance espace les points selon la longueur plutôt que le paramètre ; wireType fait des barreaux des polylignes ou des courbes lisses, closed ferme chacun en boucle.
Parameters
- inputs: WiresBetweenSubdividedPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  Les fils ou arêtes, le nombre de divisions, l'espacement, le type de fil à construire, s'il faut le fermer et la tolérance
Returns Promise<TopoDSWirePointer[]>
Un fil par point de division, dans l'ordre le long des formes
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>
Trace un contour fermé autour de deux cercles situés dans un même plan, en les reliant par des lignes tangentes : une forme de courroie ou de capsule.

keepLines choisit les lignes tangentes extérieures (la courroie) ou les lignes intérieures croisées ; circleRemainders choisit quel arc de chaque cercle reste dans le contour. Chaque fil de cercle doit être constitué d'une seule arête.
Parameters
- inputs: WireFromTwoCirclesTanDto<TopoDSWirePointer>
  Les deux fils circulaires, les lignes tangentes et arcs à conserver, et la tolérance
Returns Promise<TopoDSWirePointer>
Le fil de contour fermé
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