Klasse OCCTWire

Drähte in OpenCascade: Ketten von Kanten, Ende an Ende verbunden, offen wie ein Pfad oder geschlossen wie ein Umriss. Bauen Sie sie aus Punkten und Kurven (Polylinien, B-splines, Beziers, Interpolationen, Helices, Spiralen), als fertige ebene Umrisse (Kreise, Rechtecke, Sterne, Trägerprofile, Text), die auf der Grundebene liegen, sofern direction nichts anderes sagt, oder durch Verbinden und Teilen vorhandener Kanten und Drähte; lesen Sie sie als Punkte, Tangenten, Längen und Mittelpunkte zurück; legen Sie sie auf Flächen oder projizieren Sie sie auf Formen. Parameter entlang eines Drahts laufen von 0 an seinem Anfang bis 1 an seinem Ende und folgen dem eigenen Parameter jeder Kante, nicht dem Abstand. Ein geschlossener Draht ist das, was shapes.face füllt, um eine Fläche zu erzeugen.

Index

Konstruktoren

constructor

new OCCTWire(): OCCTWire
Rückgabewert OCCTWire

beam profiles

createIBeamProfileWire

createIBeamProfileWire(inputs: IBeamProfileDto): Promise<TopoDSWirePointer>
Erstellt den geschlossenen Umriss eines I-Träger-Querschnitts: zwei horizontale Flansche, verbunden durch einen vertikalen Steg.

width ist die Flanschbreite, height die Gesamthöhe, webThickness und flangeThickness die Wanddicken; alignment sagt, welcher Punkt des Profilrahmens auf center sitzt, rotation dreht ihn in seiner Ebene, in Grad. Er liegt auf dem Boden, bereit zum Extrudieren.
Parameter
- inputs: IBeamProfileDto
  Die Profilgröße, die beiden Dicken, die Ausrichtung, die Drehung, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Umrissdraht des I-Trägers
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],
});
```
- Definiert in bitbybit-docs.d.ts:46323

createHBeamProfileWire

createHBeamProfileWire(inputs: HBeamProfileDto): Promise<TopoDSWirePointer>
Erstellt den geschlossenen Umriss eines H-Träger-Querschnitts: zwei vertikale Flansche, verbunden durch einen horizontalen Steg, ein I-Träger auf der Seite.

width ist die Gesamtbreite, height die Flanschhöhe, webThickness und flangeThickness die Wanddicken; alignment sagt, welcher Punkt des Profilrahmens auf center sitzt, rotation dreht ihn in seiner Ebene, in Grad.
Parameter
- inputs: HBeamProfileDto
  Die Profilgröße, die beiden Dicken, die Ausrichtung, die Drehung, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Umrissdraht des H-Trägers
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],
});
```
- Definiert in bitbybit-docs.d.ts:46350

createTBeamProfileWire

createTBeamProfileWire(inputs: TBeamProfileDto): Promise<TopoDSWirePointer>
Erstellt den geschlossenen Umriss eines T-Träger-Querschnitts: ein horizontaler Flansch mit einem vertikalen Steg, der von seiner Mitte herabhängt.

width ist die Flanschbreite, height die Gesamthöhe, webThickness und flangeThickness die Wanddicken; alignment sagt, welcher Punkt des Profilrahmens auf center sitzt, rotation dreht ihn in seiner Ebene, in Grad. Er liegt auf dem Boden.
Parameter
- inputs: TBeamProfileDto
  Die Profilgröße, die beiden Dicken, die Ausrichtung, die Drehung, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Umrissdraht des T-Trägers
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],
});
```
- Definiert in bitbybit-docs.d.ts:46377

createUBeamProfileWire

createUBeamProfileWire(inputs: UBeamProfileDto): Promise<TopoDSWirePointer>
Erstellt den geschlossenen Umriss eines U-Träger-Querschnitts, einer Rinne: ein Steg mit zwei Flanschen mit flangeWidth, die von seinen Enden aufragen.

width und height sind die Gesamtgröße, webThickness und flangeThickness die Wand- dicken; alignment sagt, welcher Punkt des Profilrahmens auf center sitzt, rotation dreht ihn in seiner Ebene, in Grad. Er liegt auf dem Boden.
Parameter
- inputs: UBeamProfileDto
  Die Profilgröße, die Dicken, die Flanschbreite, die Ausrichtung, die Drehung, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Umrissdraht des U-Trägers
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],
});
```
- Definiert in bitbybit-docs.d.ts:46405

build

combineEdgesAndWiresIntoAWire

combineEdgesAndWiresIntoAWire(
inputs: ShapesDto<TopoDSEdgePointer | TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Verbindet Kanten und Drähte, die sich Ende an Ende berühren, zu einem Draht.

Die Stücke müssen anschließen; eine Menge mit einer Lücke oder einem losen Stück löst einen Fehler aus. Formen anderer Arten in der Liste werden ignoriert.
Parameter
- inputs: ShapesDto<TopoDSEdgePointer | TopoDSWirePointer>
  Die zu verbindenden Kanten und Drähte
Rückgabewert Promise<TopoDSWirePointer>
Der verbundene Draht
Example
```
const outline = await bitbybit.occt.shapes.wire.combineEdgesAndWiresIntoAWire({ shapes: [arc, line1, line2] });
```
- Definiert in bitbybit-docs.d.ts:45827

createWireFromEdge

createWireFromEdge(
inputs: ShapeDto<TopoDSEdgePointer>,
): Promise<TopoDSWirePointer>
Packt eine einzelne Kante in einen Draht, damit sie dorthin gehen kann, wo ein Draht erwartet wird.
Parameter
- inputs: ShapeDto<TopoDSEdgePointer>
  Die Kante
Rückgabewert Promise<TopoDSWirePointer>
Der Draht, der diese Kante enthält
Example
```
const wire = await bitbybit.occt.shapes.wire.createWireFromEdge({ shape: edge });
```
- Definiert in bitbybit-docs.d.ts:45840

addEdgesAndWiresToWire

addEdgesAndWiresToWire(
    inputs: ShapeShapesDto<
        TopoDSWirePointer,
        TopoDSEdgePointer
        | TopoDSWirePointer,
    >,
): Promise<TopoDSWirePointer>
Erweitert einen Draht um weitere Kanten und Drähte, die ihn Ende an Ende berühren.

Die Stücke müssen an den Draht oder aneinander anschließen; eine Lücke löst einen Fehler aus. Formen anderer Arten in der Liste werden ignoriert.
Parameter
- inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSEdgePointer | TopoDSWirePointer>
  Der zu erweiternde Draht und die hinzuzufügenden Kanten und Drähte
Rückgabewert Promise<TopoDSWirePointer>
Der erweiterte Draht
Example
```
const longer = await bitbybit.occt.shapes.wire.addEdgesAndWiresToWire({ shape: wire, shapes: [nextEdge, nextWire] });
```
- Definiert in bitbybit-docs.d.ts:45856

debug

debugInfo

debugInfo(inputs: ShapeDto<TopoDSWirePointer>): Promise<WireDebugInfo>
Sammelt diagnostische Fakten über einen Draht: wie viele Kanten er hat, ob er geschlossen ist, seine Gesamtlänge und, für jede Kante, den Kurvenbericht, den shapes.edge.debugInfo liefert.

Ein leerer oder null-Draht ergibt einen als ungültig markierten Bericht mit Nullzählungen.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der zu untersuchende Draht
Rückgabewert Promise<WireDebugInfo>
Der Bericht mit der Kantenanzahl, dem Geschlossen-Flag, der Länge und einem Eintrag pro Kante
Example
```
const info = await bitbybit.occt.shapes.wire.debugInfo({ shape: wire });
console.log(info.nbEdges, info.closed, info.totalLength);
```
- Definiert in bitbybit-docs.d.ts:45300

edit

closeOpenWire

closeOpenWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<TopoDSWirePointer>
Schließt einen offenen Draht mit einer geraden Kante von seinem Endpunkt zurück zu seinem Startpunkt.

Ein Draht, dessen Enden sich bereits treffen, wird zurückgegeben, wie er ist.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der zu schließende Draht
Rückgabewert Promise<TopoDSWirePointer>
Der geschlossene Draht
Example
```
const closedWire = await bitbybit.occt.shapes.wire.closeOpenWire({ shape: openWire });
```
- Definiert in bitbybit-docs.d.ts:46717

extract

splitOnPoints

splitOnPoints(
inputs: SplitWireOnPointsDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer[]>
Schneidet einen Draht an den gegebenen Punkten in Stücke.

Jeder Punkt wird vor dem Schneiden zur nächsten Stelle auf dem Draht verschoben, daher muss er nicht genau darauf liegen; wiederholte Punkte werden ignoriert. Die Stücke kommen in Reihenfolge entlang des Drahts zurück, von seinem Anfang bis zu seinem Ende.
Parameter
- inputs: SplitWireOnPointsDto<TopoDSWirePointer>
  Der Draht und die Punkte, an denen geschnitten wird
Rückgabewert Promise<TopoDSWirePointer[]>
Die Stücke des Drahts, in Reihenfolge
Example
```
const pieces = await bitbybit.occt.shapes.wire.splitOnPoints({ shape: wire, points: [[3, 0, 0], [7, 0, 0]] });
```
- Definiert in bitbybit-docs.d.ts:45511

wiresToPoints

wiresToPoints(inputs: WiresToPointsDto<TopoDSShapePointer>): Promise<Point3[][]>
Verwandelt jeden Draht einer Form in eine Punktfolge, die seinen Kurven eng genug folgt, um ihn zu zeichnen, eine Liste pro Draht.

Die Abweichungseinstellungen sagen, wie eng sich die Punkte an gekrümmte Kanten schmiegen; wo eine Kante endet und die nächste beginnt, erscheint der gemeinsame Punkt einmal.
Parameter
- inputs: WiresToPointsDto<TopoDSShapePointer>
  Die Form und die Abweichungseinstellungen
Rückgabewert Promise<Point3[][]>
Eine Punktliste pro Draht
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,
});
```
- Definiert in bitbybit-docs.d.ts:45535

divideWireByParamsToPoints

divideWireByParamsToPoints(
inputs: DivideDto<TopoDSWirePointer>,
): Promise<Point3[]>
Platziert Punkte entlang eines Drahts in gleichen Schritten seines Parameters, von Anfang bis Ende.

nrOfDivisions Schritte ergeben einen Punkt mehr als das; removeStartPoint und removeEndPoint lassen die Enden weg. Der Parameter folgt dem eigenen Kurvenparameter jeder Kante, daher sind gleiche Schritte keine gleichen Abstände; verwenden Sie divideWireByEqualDistanceToPoints für diese.
Parameter
- inputs: DivideDto<TopoDSWirePointer>
  Der Draht, die Anzahl der Unterteilungen und ob die Endpunkte weggelassen werden
Rückgabewert Promise<Point3[]>
Die Punkte entlang des Drahts, in Reihenfolge
Example
```
const points = await bitbybit.occt.shapes.wire.divideWireByParamsToPoints({ shape: wire, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Definiert in bitbybit-docs.d.ts:45873

divideWireByEqualDistanceToPoints

divideWireByEqualDistanceToPoints(
inputs: DivideDto<TopoDSWirePointer>,
): Promise<Point3[]>
Platziert Punkte entlang eines Drahts in gleichen Abständen, gemessen entlang seiner Kurven, von Anfang bis Ende.

nrOfDivisions Schritte ergeben einen Punkt mehr als das; removeStartPoint und removeEndPoint lassen die Enden weg.
Parameter
- inputs: DivideDto<TopoDSWirePointer>
  Der Draht, die Anzahl der Unterteilungen und ob die Endpunkte weggelassen werden
Rückgabewert Promise<Point3[]>
Die Punkte entlang des Drahts, in Reihenfolge
Example
```
const points = await bitbybit.occt.shapes.wire.divideWireByEqualDistanceToPoints({ shape: wire, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Definiert in bitbybit-docs.d.ts:45902

pointOnWireAtParam

pointOnWireAtParam(
inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>,
): Promise<Point3>
Ermittelt den Punkt bei einem Anteil des Wegs entlang eines Drahts: 0 ist der Anfang, 1 das Ende.

Der Anteil folgt den Parametern der Kanten, nicht dem Abstand, daher ist 0.5 nicht immer die Mitte nach Länge; verwenden Sie pointOnWireAtLength für einen Abstand.
Parameter
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  Der Draht und der Anteil von 0 bis 1
Rückgabewert Promise<Point3>
Der Punkt auf dem Draht
Example
```
const point = await bitbybit.occt.shapes.wire.pointOnWireAtParam({ shape: wire, param: 0.25 });
```
- Definiert in bitbybit-docs.d.ts:45931

pointOnWireAtLength

pointOnWireAtLength(
inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>,
): Promise<Point3>
Ermittelt den Punkt in einem gegebenen Abstand entlang eines Drahts von seinem Anfang, gemessen entlang seiner Kurven in Modelleinheiten.
Parameter
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  Der Draht und der Abstand von seinem Anfang
Rückgabewert Promise<Point3>
Der Punkt auf dem Draht
Example
```
const point = await bitbybit.occt.shapes.wire.pointOnWireAtLength({ shape: wire, length: 2.5 });
```
- Definiert in bitbybit-docs.d.ts:45945

pointsOnWireAtLengths

pointsOnWireAtLengths(
inputs: DataOnGeometryAtLengthsDto<TopoDSWirePointer>,
): Promise<Point3[]>
Ermittelt die Punkte in mehreren Abständen entlang eines Drahts von seinem Anfang, gemessen entlang seiner Kurven in Modelleinheiten.
Parameter
- inputs: DataOnGeometryAtLengthsDto<TopoDSWirePointer>
  Der Draht und die Abstände von seinem Anfang
Rückgabewert Promise<Point3[]>
Ein Punkt pro Abstand, in derselben Reihenfolge
Example
```
const points = await bitbybit.occt.shapes.wire.pointsOnWireAtLengths({ shape: wire, lengths: [1, 2.5, 4] });
```
- Definiert in bitbybit-docs.d.ts:45959

pointsOnWireAtEqualLength

pointsOnWireAtEqualLength(
inputs: PointsOnWireAtEqualLengthDto<TopoDSWirePointer>,
): Promise<Point3[]>
Platziert Punkte entlang eines Drahts alle length Modelleinheiten von seinem Anfang, so viele wie passen.

includeFirst behält den Punkt am Anfang, includeLast hängt den Endpunkt unabhängig vom Abstand an, und tryNext fordert einen weiteren Punkt einen Schritt hinter dem letzten an, der gepasst hat.
Parameter
- inputs: PointsOnWireAtEqualLengthDto<TopoDSWirePointer>
  Der Draht, der Abstand und welche Endpunkte einbezogen werden
Rückgabewert Promise<Point3[]>
Die Punkte entlang des Drahts, in Reihenfolge
Example
```
const points = await bitbybit.occt.shapes.wire.pointsOnWireAtEqualLength({ shape: wire, length: 2, tryNext: false, includeFirst: true, includeLast: false });
```
- Definiert in bitbybit-docs.d.ts:45975

pointsOnWireAtPatternOfLengths

pointsOnWireAtPatternOfLengths(
inputs: PointsOnWireAtPatternOfLengthsDto<TopoDSWirePointer>,
): Promise<Point3[]>
Platziert Punkte entlang eines Drahts in einem sich wiederholenden Muster von Lücken, etwa 1, 3, 1, 3, bis der Draht zu Ende ist.

lengths ist das Muster der Lücken in Modelleinheiten, vom Anfang an wiederholt; includeFirst behält den Startpunkt, includeLast hängt den Endpunkt an, und tryNext fordert einen weiteren Punkt bei der nächsten Lücke hinter dem letzten an.
Parameter
- inputs: PointsOnWireAtPatternOfLengthsDto<TopoDSWirePointer>
  Der Draht, das Muster der Lücken und welche Endpunkte einbezogen werden
Rückgabewert Promise<Point3[]>
Die Punkte entlang des Drahts, in Reihenfolge
Example
```
const points = await bitbybit.occt.shapes.wire.pointsOnWireAtPatternOfLengths({ shape: wire, lengths: [1, 3], tryNext: false, includeFirst: true, includeLast: false });
```
- Definiert in bitbybit-docs.d.ts:45993

tangentOnWireAtParam

tangentOnWireAtParam(
inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>,
): Promise<Vector3>
Ermittelt die Richtung, in die der Draht bei einem Anteil des Wegs entlang ihm verläuft, von 0 am Anfang bis 1 am Ende.

Der Anteil folgt den Parametern der Kanten, nicht dem Abstand.
Parameter
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  Der Draht und der Anteil von 0 bis 1
Rückgabewert Promise<Vector3>
Die Tangentenrichtung
Example
```
const tangent = await bitbybit.occt.shapes.wire.tangentOnWireAtParam({ shape: wire, param: 0.5 });
```
- Definiert in bitbybit-docs.d.ts:46009

tangentOnWireAtLength

tangentOnWireAtLength(
inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>,
): Promise<Vector3>
Ermittelt die Richtung, in die der Draht in einem gegebenen Abstand von seinem Anfang verläuft, gemessen entlang seiner Kurven in Modelleinheiten.
Parameter
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  Der Draht und der Abstand von seinem Anfang
Rückgabewert Promise<Vector3>
Die Tangentenrichtung
Example
```
const tangent = await bitbybit.occt.shapes.wire.tangentOnWireAtLength({ shape: wire, length: 2.5 });
```
- Definiert in bitbybit-docs.d.ts:46023

derivativesOnWireAtLength

derivativesOnWireAtLength(
inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>,
): Promise<[Vector3, Vector3, Vector3]>
Berechnet die erste, zweite und dritte Ableitung der Kurve eines Drahts in einem gegebenen Abstand von seinem Anfang.

Die erste Ableitung ist die Tangente mit ihrer Geschwindigkeit, die zweite sagt, wie sich die Kurve biegt, die dritte, wie sich diese Biegung ändert; alle bezogen auf den Parameter der Kurve. Der Abstand wird entlang der Kurven in Modelleinheiten gemessen.
Parameter
- inputs: DataOnGeometryAtLengthDto<TopoDSWirePointer>
  Der Draht und der Abstand von seinem Anfang
Rückgabewert Promise<[Vector3, Vector3, Vector3]>
Die drei Ableitungsvektoren, erste bis dritte
Example
```
const [first, second, third] = await bitbybit.occt.shapes.wire.derivativesOnWireAtLength({ shape: wire, length: 2.5 });
```
- Definiert in bitbybit-docs.d.ts:46041

derivativesOnWireAtParam

derivativesOnWireAtParam(
inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>,
): Promise<[Vector3, Vector3, Vector3]>
Berechnet die erste, zweite und dritte Ableitung der Kurve eines Drahts bei einem Anteil des Wegs entlang ihm, von 0 am Anfang bis 1 am Ende.

Die erste Ableitung ist die Tangente mit ihrer Geschwindigkeit, die zweite sagt, wie sich die Kurve biegt, die dritte, wie sich diese Biegung ändert; alle bezogen auf den Parameter der Kurve.
Parameter
- inputs: DataOnGeometryAtParamDto<TopoDSWirePointer>
  Der Draht und der Anteil von 0 bis 1
Rückgabewert Promise<[Vector3, Vector3, Vector3]>
Die drei Ableitungsvektoren, erste bis dritte
Example
```
const [first, second, third] = await bitbybit.occt.shapes.wire.derivativesOnWireAtParam({ shape: wire, param: 0.5 });
```
- Definiert in bitbybit-docs.d.ts:46058

startPointOnWire

startPointOnWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<Point3>
Liest den Punkt, an dem ein Draht beginnt, in der eigenen Richtung des Drahts.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der Draht
Rückgabewert Promise<Point3>
Der Startpunkt
Example
```
const start = await bitbybit.occt.shapes.wire.startPointOnWire({ shape: wire });
```
- Definiert in bitbybit-docs.d.ts:46071

midPointOnWire

midPointOnWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<Point3>
Ermittelt den Punkt auf halbem Weg des Parameterbereichs eines Drahts.

Der Parameter folgt den eigenen Kurven der Kanten, nicht dem Abstand, daher ist dies bei einem Draht aus ungleichen Kanten nicht immer die Mitte nach Länge; pointOnWireAtLength mit der Hälfte von getWireLength liefert diese.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der Draht
Rückgabewert Promise<Point3>
Der Punkt beim Parameter 0.5
Example
```
const middle = await bitbybit.occt.shapes.wire.midPointOnWire({ shape: wire });
```
- Definiert in bitbybit-docs.d.ts:46088

endPointOnWire

endPointOnWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<Point3>
Liest den Punkt, an dem ein Draht endet, in der eigenen Richtung des Drahts.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der Draht
Rückgabewert Promise<Point3>
Der Endpunkt
Example
```
const end = await bitbybit.occt.shapes.wire.endPointOnWire({ shape: wire });
```
- Definiert in bitbybit-docs.d.ts:46101

extract from wires

divideWiresByParamsToPoints

divideWiresByParamsToPoints(
inputs: DivideShapesDto<TopoDSWirePointer>,
): Promise<Point3[][]>
Führt divideWireByParamsToPoints mit denselben Einstellungen auf mehreren Drähten aus.
Parameter
- inputs: DivideShapesDto<TopoDSWirePointer>
  Die Drähte, die Anzahl der Unterteilungen und ob die Endpunkte weggelassen werden
Rückgabewert Promise<Point3[][]>
Eine Punktliste pro Draht, in derselben Reihenfolge
Example
```
const lists = await bitbybit.occt.shapes.wire.divideWiresByParamsToPoints({ shapes: wires, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Definiert in bitbybit-docs.d.ts:45886

divideWiresByEqualDistanceToPoints

divideWiresByEqualDistanceToPoints(
inputs: DivideShapesDto<TopoDSWirePointer>,
): Promise<Point3[][]>
Führt divideWireByEqualDistanceToPoints mit denselben Einstellungen auf mehreren Drähten aus.
Parameter
- inputs: DivideShapesDto<TopoDSWirePointer>
  Die Drähte, die Anzahl der Unterteilungen und ob die Endpunkte weggelassen werden
Rückgabewert Promise<Point3[][]>
Eine Punktliste pro Draht, in derselben Reihenfolge
Example
```
const lists = await bitbybit.occt.shapes.wire.divideWiresByEqualDistanceToPoints({ shapes: wires, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });
```
- Definiert in bitbybit-docs.d.ts:45915

from base

fromBaseLine

fromBaseLine(inputs: LineBaseDto): Promise<TopoDSWirePointer>
Erstellt einen geraden Einzelkanten-Draht aus einem Linienobjekt der Form { start, end }.
Parameter
- inputs: LineBaseDto
  Die Linie
Rückgabewert Promise<TopoDSWirePointer>
Der gerade Draht
Example
```
const wire = await bitbybit.occt.shapes.wire.fromBaseLine({ line: { start: [0, 0, 0], end: [10, 0, 0] } });
```
- Definiert in bitbybit-docs.d.ts:45313

fromBaseLines

fromBaseLines(inputs: LinesBaseDto): Promise<TopoDSWirePointer[]>
Erstellt einen geraden Einzelkanten-Draht pro Linienobjekt der Form { start, end }.
Parameter
- inputs: LinesBaseDto
  Die Linien
Rückgabewert Promise<TopoDSWirePointer[]>
Ein Draht pro Linie, in derselben Reihenfolge
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] }] });
```
- Definiert in bitbybit-docs.d.ts:45326

fromBaseSegment

fromBaseSegment(inputs: SegmentBaseDto): Promise<TopoDSWirePointer>
Erstellt einen geraden Einzelkanten-Draht aus einem Segment, einem Punktepaar [start, end].
Parameter
- inputs: SegmentBaseDto
  Das Segment
Rückgabewert Promise<TopoDSWirePointer>
Der gerade Draht
Example
```
const wire = await bitbybit.occt.shapes.wire.fromBaseSegment({ segment: [[0, 0, 0], [10, 0, 0]] });
```
- Definiert in bitbybit-docs.d.ts:45339

fromBaseSegments

fromBaseSegments(inputs: SegmentsBaseDto): Promise<TopoDSWirePointer[]>
Erstellt einen geraden Einzelkanten-Draht pro Segment, jedes ein Punktepaar [start, end].
Parameter
- inputs: SegmentsBaseDto
  Die Segmente
Rückgabewert Promise<TopoDSWirePointer[]>
Ein Draht pro Segment, in derselben Reihenfolge
Example
```
const wires = await bitbybit.occt.shapes.wire.fromBaseSegments({ segments: [[[0, 0, 0], [10, 0, 0]], [[10, 0, 0], [10, 10, 0]]] });
```
- Definiert in bitbybit-docs.d.ts:45352

fromPoints

fromPoints(inputs: Bit.Inputs.OCCT.PointsDto): Promise<TopoDSWirePointer>
Verbindet eine Liste von Punkten in Reihenfolge mit geraden Kanten zu einem Draht.

Weniger als zwei Punkte werfen einen Fehler. Wenn der letzte Punkt den ersten wiederholt, wird die Wiederholung verworfen und der Draht zurück zum ersten Punkt geschlossen; andernfalls bleibt der Draht offen. Für einen geschlossenen Umriss ohne Wiederholung eines Punkts verwenden Sie createPolygonWire.
Parameter
- inputs: Bit.Inputs.OCCT.PointsDto
  Die Punkte, in Reihenfolge
Rückgabewert Promise<TopoDSWirePointer>
Der Draht durch die Punkte
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]] });
```
- Definiert in bitbybit-docs.d.ts:45370

fromBasePolyline

fromBasePolyline(inputs: PolylineBaseDto): Promise<TopoDSWirePointer>
Erstellt einen Draht aus einem Polylinienobjekt, eine gerade Kante pro Segment; eine als geschlossen markierte Polylinie erhält auch die Kante von ihrem letzten Punkt zurück zu ihrem ersten.
Parameter
- inputs: PolylineBaseDto
  Die Polylinie
Rückgabewert Promise<TopoDSWirePointer>
Der Draht
Example
```
const outline = await bitbybit.occt.shapes.wire.fromBasePolyline({ polyline: { points: [[0, 0, 0], [10, 0, 0], [10, 0, 10]], isClosed: true } });
```
- Definiert in bitbybit-docs.d.ts:45384

fromBaseTriangle

fromBaseTriangle(inputs: TriangleBaseDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen Dreikanten-Draht aus einem als drei Punkte gegebenen Dreieck.
Parameter
- inputs: TriangleBaseDto
  Das Dreieck
Rückgabewert Promise<TopoDSWirePointer>
Der geschlossene Draht
Example
```
const outline = await bitbybit.occt.shapes.wire.fromBaseTriangle({ triangle: [[0, 0, 0], [10, 0, 0], [0, 0, 10]] });
```
- Definiert in bitbybit-docs.d.ts:45397

fromBaseMesh

fromBaseMesh(inputs: MeshBaseDto): Promise<TopoDSWirePointer[]>
Erstellt einen geschlossenen Dreikanten-Draht pro Dreieck eines Meshes.

Ein Dreieck, dessen Draht nicht gebaut werden kann, wird mit einer Warnung übersprungen, statt den Rest anzuhalten.
Parameter
- inputs: MeshBaseDto
  Das Mesh als Liste von Dreiecken
Rückgabewert Promise<TopoDSWirePointer[]>
Ein Draht pro Dreieck, das gebaut werden konnte
Example
```
const outlines = await bitbybit.occt.shapes.wire.fromBaseMesh({ mesh: triangles });
```
- Definiert in bitbybit-docs.d.ts:45413

get

getWire

getWire(inputs: ShapeIndexDto<TopoDSShapePointer>): Promise<TopoDSWirePointer>
Wählt einen Draht aus einer Form anhand seiner Position, gezählt ab 0, in der Reihenfolge, in der der Kernel die Form durchläuft.

Die Form muss ein Draht oder etwas aus Drähten Gebautes sein; ein Index jenseits des letzten Drahts löst einen Fehler aus.
Parameter
- inputs: ShapeIndexDto<TopoDSShapePointer>
  Die Form und der 0-basierte Index
Rückgabewert Promise<TopoDSWirePointer>
Der Draht an diesem Index
Example
```
const outer = await bitbybit.occt.shapes.wire.getWire({ shape: face, index: 0 });
```
- Definiert in bitbybit-docs.d.ts:46556

getWires

getWires(inputs: ShapeDto<TopoDSShapePointer>): Promise<TopoDSWirePointer[]>
Listet jeden Draht einer Form in der Reihenfolge auf, in der der Kernel sie durchläuft.
Parameter
- inputs: ShapeDto<TopoDSShapePointer>
  Die Form
Rückgabewert Promise<TopoDSWirePointer[]>
Die in der Form gefundenen Drähte
Example
```
const wires = await bitbybit.occt.shapes.wire.getWires({ shape: face });
```
- Definiert in bitbybit-docs.d.ts:46569

getWireCenterOfMass

getWireCenterOfMass(inputs: ShapeDto<TopoDSWirePointer>): Promise<Point3>
Ermittelt den Schwerpunkt eines Drahts, den Gleichgewichtspunkt seiner Kurven; bei einem Kreis ist das sein Mittelpunkt, abseits des Drahts selbst.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der Draht
Rückgabewert Promise<Point3>
Der Schwerpunkt
Example
```
const center = await bitbybit.occt.shapes.wire.getWireCenterOfMass({ shape: wire });
```
- Definiert in bitbybit-docs.d.ts:46583

getWiresCentersOfMass

getWiresCentersOfMass(inputs: ShapesDto<TopoDSWirePointer>): Promise<Point3[]>
Ermittelt den Schwerpunkt jedes Drahts in einer Liste.
Parameter
- inputs: ShapesDto<TopoDSWirePointer>
  Die Drähte
Rückgabewert Promise<Point3[]>
Ein Punkt pro Draht, in derselben Reihenfolge
Example
```
const centers = await bitbybit.occt.shapes.wire.getWiresCentersOfMass({ shapes: wires });
```
- Definiert in bitbybit-docs.d.ts:46596

reversedWire

reversedWire(inputs: ShapeDto<TopoDSWirePointer>): Promise<TopoDSWirePointer>
Kehrt die Richtung eines Drahts um, sodass sein Anfang zu seinem Ende wird.

Die Kanten behalten ihre eigene Reihenfolge und ihre Richtungs-Flags; der Draht als Ganzes wird als umgekehrt markiert, was die meisten Operationen lesen. reversedWireFromReversedEdges baut den Draht stattdessen Kante für Kante neu auf.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der Draht
Rückgabewert Promise<TopoDSWirePointer>
Ein neuer Draht, der in die andere Richtung verläuft
Example
```
const back = await bitbybit.occt.shapes.wire.reversedWire({ shape: wire });
```
- Definiert in bitbybit-docs.d.ts:46613

reversedWireFromReversedEdges

reversedWireFromReversedEdges(
inputs: ShapeDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Kehrt die Richtung eines Drahts um, indem jede Kante umgekehrt und sie in umgekehrter Reihenfolge wieder verbunden werden.

Das Ergebnis ist ein Draht, der durch und durch in die andere Richtung verläuft, was manche Operationen brauchen, wo das bloße reversedWire-Flag nicht genügt.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der Draht
Rückgabewert Promise<TopoDSWirePointer>
Ein neuer Draht, der in die andere Richtung verläuft
Example
```
const back = await bitbybit.occt.shapes.wire.reversedWireFromReversedEdges({ shape: wire });
```
- Definiert in bitbybit-docs.d.ts:46630

isWireClosed

isWireClosed(inputs: ShapeDto<TopoDSWirePointer>): Promise<boolean>
Sagt, ob ein Draht geschlossen ist, was der Fall ist, wenn sein Start- und Endpunkt innerhalb einer kleinen Toleranz zusammenfallen.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der Draht
Rückgabewert Promise<boolean>
True, wenn sich die Enden treffen
Example
```
const wireIsClosed = await bitbybit.occt.shapes.wire.isWireClosed({ shape: wire });
```
- Definiert in bitbybit-docs.d.ts:46644

getWireLength

getWireLength(inputs: ShapeDto<TopoDSWirePointer>): Promise<number>
Misst die Länge eines Drahts entlang seiner Kurven, in Modelleinheiten.
Parameter
- inputs: ShapeDto<TopoDSWirePointer>
  Der Draht
Rückgabewert Promise<number>
Die Länge
Example
```
const len = await bitbybit.occt.shapes.wire.getWireLength({ shape: wire });
```
- Definiert in bitbybit-docs.d.ts:46657

getWiresLengths

getWiresLengths(inputs: ShapesDto<TopoDSWirePointer>): Promise<number[]>
Misst die Länge jedes Drahts in einer Liste entlang seiner Kurven, in Modelleinheiten.
Parameter
- inputs: ShapesDto<TopoDSWirePointer>
  Die Drähte
Rückgabewert Promise<number[]>
Eine Länge pro Draht, in derselben Reihenfolge
Example
```
const lengths = await bitbybit.occt.shapes.wire.getWiresLengths({ shapes: wires });
```
- Definiert in bitbybit-docs.d.ts:46670

multiple

createPolygons

createPolygons(
inputs: PolygonsDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Erstellt einen geschlossenen Polygondraht pro Punktliste, wie createPolygonWire es tut.

Mit returnCompound true werden die Drähte in eine Verbundform gepackt statt in eine Liste.
Parameter
- inputs: PolygonsDto
  Die Polygone und ob sie in einen Verbund gepackt werden
Rückgabewert Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Die Drähte in Reihenfolge oder ein Verbund, der sie enthält
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,
});
```
- Definiert in bitbybit-docs.d.ts:45447

createLines

createLines(
inputs: Bit.Inputs.OCCT.LinesDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Erstellt einen geraden Einzelkanten-Draht pro Liniendefinition.

Mit returnCompound true werden die Drähte in eine Verbundform gepackt statt in eine Liste.
Parameter
- inputs: Bit.Inputs.OCCT.LinesDto
  Die Linien und ob sie in einen Verbund gepackt werden
Rückgabewert Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Die Drähte in Reihenfolge oder ein Verbund, der sie enthält
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,
});
```
- Definiert in bitbybit-docs.d.ts:45494

createPolylines

createPolylines(
inputs: Bit.Inputs.OCCT.PolylinesDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Erstellt einen offenen Polyliniendraht pro Punktliste, wie createPolylineWire es tut.

Mit returnCompound true werden die Drähte in eine Verbundform gepackt statt in eine Liste.
Parameter
- inputs: Bit.Inputs.OCCT.PolylinesDto
  Die Polylinien und ob sie in einen Verbund gepackt werden
Rückgabewert Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Die Drähte in Reihenfolge oder ein Verbund, der sie enthält
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,
});
```
- Definiert in bitbybit-docs.d.ts:45658

createBezierWires

createBezierWires(
inputs: BezierWiresDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Erstellt einen Bezier-Draht pro Definition, wie createBezier es tut.

Mit returnCompound true werden die Drähte in eine Verbundform gepackt statt in eine Liste.
Parameter
- inputs: BezierWiresDto
  Die Bezier-Definitionen und ob sie in einen Verbund gepackt werden
Rückgabewert Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Die Drähte in Reihenfolge oder ein Verbund, der sie enthält
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,
});
```
- Definiert in bitbybit-docs.d.ts:45716

interpolateWires

interpolateWires(
inputs: InterpolateWiresDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Erstellt einen interpolierten B-spline-Draht pro Definition, wie interpolatePoints es tut.

Mit returnCompound true werden die Drähte in eine Verbundform gepackt statt in eine Liste.
Parameter
- inputs: InterpolateWiresDto
  Die Interpolationsdefinitionen und ob sie in einen Verbund gepackt werden
Rückgabewert Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Die Drähte in Reihenfolge oder ein Verbund, der sie enthält
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,
});
```
- Definiert in bitbybit-docs.d.ts:45775

createBSplines

createBSplines(
inputs: BSplinesDto,
): Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Erstellt einen annähernden B-spline-Draht pro Definition, wie createBSpline es tut.

Mit returnCompound true werden die Drähte in eine Verbundform gepackt statt in eine Liste.
Parameter
- inputs: BSplinesDto
  Die B-spline-Definitionen und ob sie in einen Verbund gepackt werden
Rückgabewert Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>
Die Drähte in Reihenfolge oder ein Verbund, der sie enthält
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,
});
```
- Definiert in bitbybit-docs.d.ts:45811

place

placeWireOnFace

placeWireOnFace(
inputs: WireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>,
): Promise<TopoDSWirePointer>
Bildet einen flachen, auf der Bodenebene gezeichneten Draht auf die Oberfläche einer Fläche ab, als wäre die Zeichnung um sie gewickelt.

Die Z-Koordinate des Drahts wird als U und seine X-Koordinate als V gelesen, in den echten UV-Werten der Fläche, die shapes.face.getUMinBound und seine Geschwister melden; eine Zeichnung, die in diese Grenzen passt, landet auf der Fläche.
Parameter
- inputs: WireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Der Draht auf der Grundebene und die Fläche
Rückgabewert Promise<TopoDSWirePointer>
Der auf der Oberfläche der Fläche liegende Draht
Example
```
const onSurface = await bitbybit.occt.shapes.wire.placeWireOnFace({ wire: flatWire, face: cylinderFace });
```
- Definiert in bitbybit-docs.d.ts:46688

placeWiresOnFace

placeWiresOnFace(
inputs: WiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>,
): Promise<TopoDSWirePointer[]>
Bildet mehrere flache, auf der Bodenebene gezeichnete Drähte auf die Oberfläche einer Fläche ab, wie placeWireOnFace es für einen tut.
Parameter
- inputs: WiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Die Drähte auf der Grundebene und die Fläche
Rückgabewert Promise<TopoDSWirePointer[]>
Die auf der Oberfläche der Fläche liegenden Drähte, in derselben Reihenfolge
Example
```
const onSurface = await bitbybit.occt.shapes.wire.placeWiresOnFace({ wires: flatWires, face: cylinderFace });
```
- Definiert in bitbybit-docs.d.ts:46702

project

project(
inputs: ProjectWireDto<TopoDSWirePointer, TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer>
Projiziert einen Draht entlang einer Richtung auf eine Form, wie das Werfen seines Schattens auf die Oberfläche.

Das Ergebnis ist ein Verbund der Kurven, an denen die Projektion auf die Flächen der Form trifft, was sowohl auf ihrer nahen als auch auf ihrer fernen Seite sein kann. Schneiden Sie damit eine Fläche über shapes.face.createFaceFromWireOnFace oder verwenden Sie es als Pfad.
Parameter
- inputs: ProjectWireDto<TopoDSWirePointer, TopoDSShapePointer>
  Der Draht, die Form, auf die projiziert wird, und die Richtung
Rückgabewert Promise<TopoDSCompoundPointer>
Ein Verbund der projizierten Kurven
Example
```
const shadow = await bitbybit.occt.shapes.wire.project({ wire: circle, shape: sphere, direction: [0, -1, 0] });
```
- Definiert in bitbybit-docs.d.ts:46734

projectWires

projectWires(
inputs: ProjectWiresDto<TopoDSWirePointer, TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer[]>
Projiziert mehrere Drähte entlang einer Richtung auf eine Form, wie project es für einen tut.
Parameter
- inputs: ProjectWiresDto<TopoDSWirePointer, TopoDSShapePointer>
  Die Drähte, die Form, auf die projiziert wird, und die Richtung
Rückgabewert Promise<TopoDSCompoundPointer[]>
Ein Verbund projizierter Kurven pro Draht, in derselben Reihenfolge
Example
```
const shadows = await bitbybit.occt.shapes.wire.projectWires({ wires: [circle, square], shape: sphere, direction: [0, -1, 0] });
```
- Definiert in bitbybit-docs.d.ts:46747

primitives

createCircleWire

createCircleWire(inputs: Bit.Inputs.OCCT.CircleDto): Promise<TopoDSWirePointer>
Erstellt einen vollen Kreis als geschlossenen Einzelkanten-Draht, in der Ebene liegend, deren Normale direction ist; der Standard [0, 1, 0] legt ihn flach auf den Boden.
Parameter
- inputs: Bit.Inputs.OCCT.CircleDto
  Der Radius, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Kreisdraht
Example
```
const circle = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:46115

hexagonsInGrid

hexagonsInGrid(inputs: HexagonsInGridDto): Promise<TopoDSWirePointer[]>
Füllt ein Rechteck auf der Bodenebene mit einem Gitter aus geschlossenen Sechseckdrähten, zentriert auf dem Ursprung.

Die Sechsecke werden so skaliert, dass nrHexagonsInWidth über width und nrHexagonsInHeight über height passen. Die Skalierungs-, Verrundungs- und Einschlussmuster werden Sechseck für Sechseck gelesen und wiederholen sich; die Extend-Flags strecken die äußeren Reihen über die Ränder hinaus, um das Rechteck abzudecken.
Parameter
- inputs: HexagonsInGridDto
  Die Rechteckgröße, die Sechseckanzahlen, die Erweiterungs-Flags und die optionalen Muster
Rückgabewert Promise<TopoDSWirePointer[]>
Ein Draht pro Sechseck, Reihe für Reihe
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],
});
```
- Definiert in bitbybit-docs.d.ts:46141

createSquareWire

createSquareWire(inputs: Bit.Inputs.OCCT.SquareDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen Quadratdraht, zentriert auf center.

direction ist die Normale seiner Ebene: der Standard [0, 1, 0] legt ihn flach auf den Boden.
Parameter
- inputs: Bit.Inputs.OCCT.SquareDto
  Die Seitenlänge, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Quadratdraht
Example
```
const square = await bitbybit.occt.shapes.wire.createSquareWire({ size: 10, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:46156

createStarWire

createStarWire(inputs: Bit.Inputs.OCCT.StarDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen sternförmigen Draht mit numRays Zacken.

Die Zacken reichen bis outerRadius und die Kerben dazwischen bis innerRadius; offsetOuterEdges hebt die Strahlspitzen um diesen Abstand aus der Ebene und macht so einen 3D-Stern, und half behält die erste Hälfte der Strahlen als offenen Draht. Er liegt flach auf dem Boden, sofern direction nichts anderes sagt.
Parameter
- inputs: Bit.Inputs.OCCT.StarDto
  Die beiden Radien, die Anzahl der Strahlen, der Mittelpunkt, die Ebenennormale und die Optionen
Rückgabewert Promise<TopoDSWirePointer>
Der Sterndraht
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 });
```
- Definiert in bitbybit-docs.d.ts:46174

createChristmasTreeWire

createChristmasTreeWire(inputs: ChristmasTreeDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen Draht in Form eines stilisierten Weihnachtsbaums: nrSkirts Astschichten, die sich von outerDist auf innerDist von der Stammlinie verjüngen, auf einem Stamm mit trunkHeight und trunkWidth.

Anders als die anderen flachen Formen hier steht er aufrecht in der XY-Ebene, Spitze entlang Y; direction ist die Richtung vom Stamm zur Spitze, rotation dreht ihn um diese Achse, in Grad.
Parameter
- inputs: ChristmasTreeDto
  Die Baumproportionen, die Stammgröße, die Optionen, der Ursprung und die Richtung vom Stamm zur Spitze
Rückgabewert Promise<TopoDSWirePointer>
Der Baumdraht
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],
});
```
- Definiert in bitbybit-docs.d.ts:46203

createNGonWire

createNGonWire(inputs: NGonWireDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen regelmäßigen Polygondraht mit nrCorners Ecken, alle auf einem Kreis mit radius.

direction ist die Normale der Ebene; der Standard [0, 1, 0] legt ihn flach auf den Boden.
Parameter
- inputs: NGonWireDto
  Die Anzahl der Ecken, der Radius, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Polygondraht
Example
```
const hexagon = await bitbybit.occt.shapes.wire.createNGonWire({ nrCorners: 6, radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:46218

createParallelogramWire

createParallelogramWire(inputs: ParallelogramDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen Parallelogrammdraht: ein Rechteck mit width und height, dessen Seiten um angle Grad geneigt sind.

Mit aroundCenter true ist die Form auf center zentriert; andernfalls beginnt sie dort und erstreckt sich in die positiven Richtungen. direction ist die Ebenennormale; der Standard [0, 1, 0] legt ihn flach auf den Boden.
Parameter
- inputs: ParallelogramDto
  Die Breite, die Höhe, der Neigungswinkel, ob es zentriert wird, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Parallelogrammdraht
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] });
```
- Definiert in bitbybit-docs.d.ts:46236

createHeartWire

createHeartWire(inputs: Heart2DDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen herzförmigen Draht aus zwei glatten Hälften, der ungefähr in ein Quadrat mit sizeApprox passt.

rotation dreht ihn in seiner Ebene, in Grad. direction ist die Ebenennormale; der Standard [0, 1, 0] legt ihn flach auf den Boden.
Parameter
- inputs: Heart2DDto
  Die ungefähre Größe, die Drehung, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Herzdraht
Example
```
const heart = await bitbybit.occt.shapes.wire.createHeartWire({ sizeApprox: 10, rotation: 0, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:46253

createRectangleWire

createRectangleWire(
inputs: Bit.Inputs.OCCT.RectangleDto,
): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen Rechteckdraht, zentriert auf center.

Auf der Bodenebene verläuft width entlang X und length entlang Z; direction ist die Normale der Ebene, und der Standard [0, 1, 0] hält den Draht flach auf dem Boden.
Parameter
- inputs: Bit.Inputs.OCCT.RectangleDto
  Die Breite, die Länge, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der Rechteckdraht
Example
```
const rectangle = await bitbybit.occt.shapes.wire.createRectangleWire({ width: 20, length: 10, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:46269

createLPolygonWire

createLPolygonWire(inputs: LPolygonDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen L-förmigen Draht: zwei rechteckige Schenkel, an einer Ecke verbunden.

Der erste Schenkel hat widthFirst und lengthFirst, der zweite widthSecond und lengthSecond; align setzt die Ecke an die Außenseite, Innenseite oder Mitte der Schenkel, und rotation dreht die Form in ihrer Ebene, in Grad. Er liegt flach auf dem Boden, sofern direction nichts anderes sagt.
Parameter
- inputs: LPolygonDto
  Die beiden Schenkelgrößen, die Ausrichtung, die Drehung, der Mittelpunkt und die Ebenennormale
Rückgabewert Promise<TopoDSWirePointer>
Der L-förmige Draht
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],
});
```
- Definiert in bitbybit-docs.d.ts:46296

createEllipseWire

createEllipseWire(
inputs: Bit.Inputs.OCCT.EllipseDto,
): Promise<TopoDSWirePointer>
Erstellt eine volle Ellipse als geschlossenen Einzelkanten-Draht, in der Ebene liegend, deren Normale direction ist.

radiusMajor darf nicht kleiner sein als radiusMinor, sonst verweigert der Kernel die Ellipse; die Standardrichtung [0, 1, 0] legt sie flach auf den Boden.
Parameter
- inputs: Bit.Inputs.OCCT.EllipseDto
  Der Mittelpunkt, die Ebenennormale und die beiden Radien
Rückgabewert Promise<TopoDSWirePointer>
Der Ellipsendraht
Example
```
const ellipse = await bitbybit.occt.shapes.wire.createEllipseWire({ center: [0, 0, 0], direction: [0, 1, 0], radiusMinor: 3, radiusMajor: 6 });
```
- Definiert in bitbybit-docs.d.ts:46422

createHelixWire

createHelixWire(inputs: HelixWireDto): Promise<TopoDSWirePointer>
Erstellt einen Wendeldraht, eine Spule mit konstantem radius, die pitch Modelleinheiten pro Windung steigt, bis sie height erreicht.

Sie beginnt neben center und steigt entlang direction; clockwise kehrt die Wicklung um. Die Wendel wird durch eine glatte Kurve innerhalb von tolerance angenähert. Ein Radius, eine Steigung oder eine Höhe von 0 oder weniger ergibt einen null-Draht.
Parameter
- inputs: HelixWireDto
  Der Radius, die Steigung, die Höhe, der Basismittelpunkt, die Achsenrichtung, der Windungssinn und die Toleranz
Rückgabewert Promise<TopoDSWirePointer>
Der Helixdraht
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 });
```
- Definiert in bitbybit-docs.d.ts:46440

createHelixWireByTurns

createHelixWireByTurns(inputs: HelixWireByTurnsDto): Promise<TopoDSWirePointer>
Erstellt einen Wendeldraht wie createHelixWire, aber bemessen nach numTurns statt nach einer Höhe: die Spule steigt pitch Modelleinheiten pro Windung, numTurns Mal.
Parameter
- inputs: HelixWireByTurnsDto
  Der Radius, die Steigung, die Anzahl der Windungen, der Basismittelpunkt, die Achsenrichtung, der Windungssinn und die Toleranz
Rückgabewert Promise<TopoDSWirePointer>
Der Helixdraht
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 });
```
- Definiert in bitbybit-docs.d.ts:46454

createTaperedHelixWire

createTaperedHelixWire(inputs: TaperedHelixWireDto): Promise<TopoDSWirePointer>
Erstellt einen konischen Wendeldraht, dessen Radius sich gleichmäßig von startRadius am Fuß zu endRadius an der Spitze ändert und der pitch Modelleinheiten pro Windung steigt, bis er height erreicht.

Er beginnt neben center und steigt entlang direction; clockwise kehrt die Wicklung um. Die Kurve wird innerhalb von tolerance angenähert.
Parameter
- inputs: TaperedHelixWireDto
  Der Start- und der Endradius, die Steigung, die Höhe, der Basismittelpunkt, die Achsenrichtung, der Windungssinn und die Toleranz
Rückgabewert Promise<TopoDSWirePointer>
Der konische Helixdraht
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 });
```
- Definiert in bitbybit-docs.d.ts:46471

createFlatSpiralWire

createFlatSpiralWire(inputs: FlatSpiralWireDto): Promise<TopoDSWirePointer>
Erstellt einen flachen Spiraldraht in der Ebene, deren Normale direction ist: numTurns Windungen, deren Radius gleichmäßig von startRadius auf endRadius wächst.

Die Standardrichtung [0, 1, 0] legt ihn flach auf den Boden; clockwise kehrt die Wicklung um, und die Kurve wird innerhalb von tolerance angenähert.
Parameter
- inputs: FlatSpiralWireDto
  Der Start- und der Endradius, die Anzahl der Windungen, der Mittelpunkt, die Ebenennormale, der Windungssinn und die Toleranz
Rückgabewert Promise<TopoDSWirePointer>
Der Spiraldraht
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 });
```
- Definiert in bitbybit-docs.d.ts:46488

textWires

textWires(inputs: TextWiresDto): Promise<TopoDSWirePointer[]>
Schreibt Text als Strichdrähte auf die Bodenebene in der einlinigen Hershey-Simplex-Schrift, ein offener Polyliniendraht pro Stiftstrich.

height ist die Höhe eines Großbuchstabens in Modelleinheiten, lineSpacing und letterSpacing sind Vielfache davon, align richtet Zeilen unterschiedlicher Länge aus, und centerOnOrigin verschiebt den Block zum Ursprung.
Parameter
- inputs: TextWiresDto
  Der Text, seine Größe und sein Abstand, die Ausrichtung und die Platzierungsoptionen
Rückgabewert Promise<TopoDSWirePointer[]>
Ein Draht pro Strich, in Schreibreihenfolge
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,
});
```
- Definiert in bitbybit-docs.d.ts:46513

textWiresWithData

textWiresWithData(
inputs: TextWiresDto,
): Promise<TextWiresDataDto<TopoDSCompoundPointer>>
Schreibt Text als Strichdrähte wie textWires und packt sie in Verbünde, zusammen mit der Größe des Blocks.

Das Ergebnis enthält compound mit dem gesamten Text, characters mit einem Verbund pro Zeichen in Schreibreihenfolge, width und height als Ausdehnung des Blocks entlang X und entlang Z, und center als Mitte des Blocks.
Parameter
- inputs: TextWiresDto
  Der Text, seine Größe und sein Abstand, die Ausrichtung und die Platzierungsoptionen
Rückgabewert Promise<TextWiresDataDto<TopoDSCompoundPointer>>
Der Textverbund, die Zeichenverbünde und die gemessene Größ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);
```
- Definiert in bitbybit-docs.d.ts:46539

rebuild

rebuildWireDegree

rebuildWireDegree(
inputs: RebuildCurveDegreeDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Baut jede Kante eines Drahts als B-spline eines gegebenen Grads neu auf, innerhalb einer Toleranz, und verbindet die Ergebnisse wieder zu einem Draht.

Ein niedrigerer Grad vereinfacht die Kurven, ein höherer gibt späteren Operationen mehr Freiheit; so oder so bleibt jede neue Kurve innerhalb von tolerance zur alten.
Parameter
- inputs: RebuildCurveDegreeDto<TopoDSWirePointer>
  Der Draht, der Grad, auf den neu aufgebaut wird, und die Toleranz
Rückgabewert Promise<TopoDSWirePointer>
Ein neuer Draht mit den neu aufgebauten Kanten
Example
```
const simpler = await bitbybit.occt.shapes.wire.rebuildWireDegree({ shape: wire, degree: 3, tolerance: 1e-3 });
```
- Definiert in bitbybit-docs.d.ts:45247

seam

moveWireSeamByParameter

moveWireSeamByParameter(
inputs: CurveSeamByParameterDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Verschiebt die Naht eines geschlossenen periodischen Drahts, den Punkt, an dem er beginnt und endet, zu einem gegebenen Parameter entlang seiner Kurve.

Die Geometrie ändert sich nicht; nur wo der Draht als beginnend gilt. Gedacht für Einzelkanten-Drähte wie Kreise: jede periodische Kante wird verschoben, Kanten, die nicht periodisch sind, bleiben, wie sie sind.
Parameter
- inputs: CurveSeamByParameterDto<TopoDSWirePointer>
  Der periodische Draht und der Parameter der neuen Naht
Rückgabewert Promise<TopoDSWirePointer>
Ein neuer Draht, der an der Naht beginnt
Example
```
const rotated = await bitbybit.occt.shapes.wire.moveWireSeamByParameter({ shape: circle, parameter: 1.57 });
```
- Definiert in bitbybit-docs.d.ts:45265

moveWireSeamByLength

moveWireSeamByLength(
inputs: CurveSeamByLengthDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Verschiebt die Naht eines geschlossenen periodischen Drahts, den Punkt, an dem er beginnt und endet, um einen Abstand entlang der Kurve von seinem aktuellen Anfang.

Die Geometrie ändert sich nicht; nur wo der Draht als beginnend gilt. Gedacht für Einzelkanten-Drähte wie Kreise: jede periodische Kante wird verschoben, Kanten, die nicht periodisch sind, bleiben, wie sie sind.
Parameter
- inputs: CurveSeamByLengthDto<TopoDSWirePointer>
  Der periodische Draht und der Abstand, um den die Naht verschoben wird
Rückgabewert Promise<TopoDSWirePointer>
Ein neuer Draht, der an der Naht beginnt
Example
```
const rotated = await bitbybit.occt.shapes.wire.moveWireSeamByLength({ shape: circle, length: 2.5 });
```
- Definiert in bitbybit-docs.d.ts:45283

via points

createPolygonWire

createPolygonWire(inputs: PolygonDto): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen Draht aus geraden Kanten durch eine Liste von Eckpunkten und fügt die Kante vom letzten Punkt zurück zum ersten hinzu.

Die Punkte müssen nicht in einer Ebene liegen; eine ebene Fläche braucht allerdings einen ebenen Umriss.
Parameter
- inputs: PolygonDto
  Die Eckpunkte, in Reihenfolge
Rückgabewert Promise<TopoDSWirePointer>
Der geschlossene Draht
Example
```
const square = await bitbybit.occt.shapes.wire.createPolygonWire({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10], [0, 0, 10]] });
```
- Definiert in bitbybit-docs.d.ts:45429

createLineWire

createLineWire(inputs: Bit.Inputs.OCCT.LineDto): Promise<TopoDSWirePointer>
Erstellt einen geraden Einzelkanten-Draht zwischen zwei Punkten.
Parameter
- inputs: Bit.Inputs.OCCT.LineDto
  Der Start- und der Endpunkt
Rückgabewert Promise<TopoDSWirePointer>
Der gerade Draht
Example
```
const line = await bitbybit.occt.shapes.wire.createLineWire({ start: [0, 0, 0], end: [10, 0, 0] });
```
- Definiert in bitbybit-docs.d.ts:45460

createLineWireWithExtensions

createLineWireWithExtensions(
inputs: LineWithExtensionsDto,
): Promise<TopoDSWirePointer>
Erstellt einen geraden Einzelkanten-Draht zwischen zwei Punkten und verlängert ihn über jeden von ihnen hinaus.

extensionStart und extensionEnd sind Abstände in Modelleinheiten, die über den Anfang und das Ende hinaus entlang der Linie hinzugefügt werden; die beiden Punkte müssen sich unterscheiden, sonst wird ein Fehler ausgelöst.
Parameter
- inputs: LineWithExtensionsDto
  Der Start- und der Endpunkt und die beiden Verlängerungslängen
Rückgabewert Promise<TopoDSWirePointer>
Der verlängerte gerade Draht
Example
```
const longer = await bitbybit.occt.shapes.wire.createLineWireWithExtensions({ start: [0, 0, 0], end: [10, 0, 0], extensionStart: 2, extensionEnd: 5 });
```
- Definiert in bitbybit-docs.d.ts:45476

createPolylineWire

createPolylineWire(
inputs: Bit.Inputs.OCCT.PolylineDto,
): Promise<TopoDSWirePointer>
Erstellt einen offenen Draht aus geraden Kanten durch eine Liste von Punkten, der Reihe nach.

Der Draht ist nicht geschlossen; createPolygonWire fügt die Kante zurück zum ersten Punkt hinzu.
Parameter
- inputs: Bit.Inputs.OCCT.PolylineDto
  Die Punkte, in Reihenfolge
Rückgabewert Promise<TopoDSWirePointer>
Der offene Draht
Example
```
const path = await bitbybit.occt.shapes.wire.createPolylineWire({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10]] });
```
- Definiert in bitbybit-docs.d.ts:45550

createBezier

createBezier(inputs: BezierDto): Promise<TopoDSWirePointer>
Erstellt einen glatten Bezier-Draht, der von Kontrollpunkten gelenkt wird: er beginnt am ersten Punkt, endet am letzten und wird zu den dazwischen gezogen, ohne durch sie zu verlaufen.

closed hängt den ersten Punkt erneut an, sodass sich die Enden treffen; periodic baut stattdessen eine geschlossene Kurve, die über die Naht hinweg glatt ist. degree begrenzt, wie viele Nachbarn jeden Teil formen.
Parameter
- inputs: BezierDto
  Die Kontrollpunkte und die Optionen für Schließen und Grad
Rückgabewert Promise<TopoDSWirePointer>
Der Bezier-Draht
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 });
```
- Definiert in bitbybit-docs.d.ts:45675

createBezierWeights

createBezierWeights(inputs: BezierWeightsDto): Promise<TopoDSWirePointer>
Erstellt einen Bezier-Draht wie createBezier, mit einem Gewicht pro Kontrollpunkt, das sagt, wie stark er die Kurve zieht.

Ein Gewicht über 1 zieht die Kurve zu seinem Punkt, unter 1 lässt sie los. Die Gewichte müssen zu den Punkten passen: dieselbe Anzahl, oder eine mehr, wenn closed true und periodic false ist, da sich der erste Punkt wiederholt.
Parameter
- inputs: BezierWeightsDto
  Die Kontrollpunkte, ihre Gewichte und die Optionen für Schließen und Grad
Rückgabewert Promise<TopoDSWirePointer>
Der gewichtete Bezier-Draht
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,
});
```
- Definiert in bitbybit-docs.d.ts:45698

interpolatePoints

interpolatePoints(inputs: InterpolationDto): Promise<TopoDSWirePointer>
Erstellt einen glatten B-spline-Draht, der der Reihe nach durch jeden Punkt verläuft.

periodic schließt die Kurve, sodass sie über die Naht hinweg glatt ist, was schön geformte Schleifen ergibt. parametrization steuert den Abstand zwischen Punkten: centripetal widersteht Spitzen und Überschwingen, wenn die Punkte ungleichmäßig sind. startTangent und endTangent, oder ein tangents- Eintrag pro Punkt, erzwingen dort die Richtung der Kurve.
Parameter
- inputs: InterpolationDto
  Die Punkte, ob die Kurve geschlossen wird, die Toleranz, die Parametrisierung und optionale Tangenten
Rückgabewert Promise<TopoDSWirePointer>
Der B-spline-Draht durch die Punkte
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,
});
```
- Definiert in bitbybit-docs.d.ts:45739

interpolatePointsSymmetric

interpolatePointsSymmetric(
inputs: InterpolateSymmetricDto,
): Promise<TopoDSWirePointer>
Erstellt einen geschlossenen, glatten B-spline-Draht durch die Punkte, dessen Form spiegelsymmetrisch ist, wann immer die Punkte es sind, ohne seltsam aussehenden Start- oder Endpunkt.

Ein einfaches periodisches interpolatePoints kann bei symmetrischen Eingaben wie einem Quadrat oder einem Dreieck an seiner Naht schief aussehen; diese Variante nicht. Sie scheitert mit einem Fehler, wenn die Punkte nicht interpoliert werden können.
Parameter
- inputs: InterpolateSymmetricDto
  Die Punkte und die Toleranz
Rückgabewert Promise<TopoDSWirePointer>
Der geschlossene symmetrische B-spline-Draht
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 });
```
- Definiert in bitbybit-docs.d.ts:45757

createBSpline

createBSpline(inputs: BSplineDto): Promise<TopoDSWirePointer>
Erstellt einen glatten B-spline-Draht, der eine Liste von Punkten annähert: er folgt ihnen eng, muss aber nicht genau durch jeden verlaufen.

closed hängt den ersten Punkt erneut an, sodass sich die Enden treffen. Die Anpassung verwendet einen Grad zwischen 3 und 8 und eine Toleranz von 0.001 Modelleinheiten; verwenden Sie interpolatePoints, wenn die Kurve durch die Punkte verlaufen muss.
Parameter
- inputs: BSplineDto
  Die Punkte und ob die Kurve geschlossen wird
Rückgabewert Promise<TopoDSWirePointer>
Der B-spline-Draht
Example
```
const curve = await bitbybit.occt.shapes.wire.createBSpline({ points: [[0, 0, 0], [5, 0, 5], [10, 0, 0], [15, 0, 5]], closed: false });
```
- Definiert in bitbybit-docs.d.ts:45793

via wires

createZigZagBetweenTwoWires

createZigZagBetweenTwoWires(
inputs: ZigZagBetweenTwoWiresDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Zeichnet eine Zickzacklinie, die zwischen zwei Drähten hin und her springt: beide werden in dieselbe Anzahl von Punkten geteilt und eine Polylinie besucht sie abwechselnd.

nrZigZags legt die Anzahl der Sprünge fest; inverse beginnt auf dem zweiten Draht; divideByEqualDistance verteilt die Punkte nach Länge statt nach Parameter; mit zigZagsPerEdge true erhält jede Kante ihren eigenen Zickzack, daher müssen die Kantenanzahlen übereinstimmen.
Parameter
- inputs: ZigZagBetweenTwoWiresDto<TopoDSWirePointer>
  Die beiden Drähte, die Anzahl der Zickzacks und die Abstandsoptionen
Rückgabewert Promise<TopoDSWirePointer>
Der Zickzack-Draht
Example
```
const zigzag = await bitbybit.occt.shapes.wire.createZigZagBetweenTwoWires({ wire1: lower, wire2: upper, nrZigZags: 20, inverse: false, divideByEqualDistance: true, zigZagsPerEdge: false });
```
- Definiert in bitbybit-docs.d.ts:45568

createWiresBetweenStartEndPointsOfWiresAndEdges

createWiresBetweenStartEndPointsOfWiresAndEdges(
    inputs: WiresBetweenStartEndPointsOfWiresAndEdgesDto<
        TopoDSEdgePointer
        | TopoDSWirePointer,
    >,
): Promise<TopoDSWirePointer[]>
Verbindet die Startpunkte mehrerer Drähte oder Kanten zu einem neuen Draht und ihre Endpunkte zu einem anderen.

wireType macht sie zu Polylinien oder glatten interpolierten Kurven, closed verbindet den letzten Punkt zurück mit dem ersten, und tolerance wird für die Interpolation verwendet. Weniger als zwei Formen lösen einen Fehler aus.
Parameter
- inputs: WiresBetweenStartEndPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  Die Drähte oder Kanten, die Art des zu bauenden Drahts, ob er geschlossen wird, und die Toleranz
Rückgabewert Promise<TopoDSWirePointer[]>
Zwei Drähte: einer durch die Startpunkte, einer durch die Endpunkte
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,
});
```
- Definiert in bitbybit-docs.d.ts:45591

createWiresBetweenSubdividedPointsOfWiresAndEdges

createWiresBetweenSubdividedPointsOfWiresAndEdges(
    inputs: WiresBetweenSubdividedPointsOfWiresAndEdgesDto<
        TopoDSEdgePointer
        | TopoDSWirePointer,
    >,
): Promise<TopoDSWirePointer[]>
Teilt mehrere Drähte oder Kanten in dieselbe Anzahl von Punkten und verbindet die Punkte an jeder Position zu einem neuen Draht, wie die Sprossen einer Leiter.

nrOfDivisions Schritte ergeben eine Sprosse mehr als das; divideByEqualDistance verteilt die Punkte nach Länge statt nach Parameter; wireType macht die Sprossen zu Polylinien oder glatten Kurven, closed verbindet jede zu einer Schleife.
Parameter
- inputs: WiresBetweenSubdividedPointsOfWiresAndEdgesDto<
  TopoDSEdgePointer
  | TopoDSWirePointer,
  >
  Die Drähte oder Kanten, die Anzahl der Unterteilungen, der Abstand, die Art des zu bauenden Drahts, ob er geschlossen wird, und die Toleranz
Rückgabewert Promise<TopoDSWirePointer[]>
Ein Draht pro Teilungspunkt, in Reihenfolge entlang der Formen
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,
});
```
- Definiert in bitbybit-docs.d.ts:45616

createWireFromTwoCirclesTan

createWireFromTwoCirclesTan(
inputs: WireFromTwoCirclesTanDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Zeichnet einen geschlossenen Umriss um zwei Kreise, die in einer Ebene liegen, und verbindet sie mit Tangenten- linien: eine Riemen- oder Kapselform.

keepLines wählt die äußeren Tangentenlinien (den Riemen) oder die sich kreuzenden inneren; circleRemainders wählt, welcher Bogen jedes Kreises im Umriss bleibt. Jeder Kreisdraht muss aus einer einzigen Kante bestehen.
Parameter
- inputs: WireFromTwoCirclesTanDto<TopoDSWirePointer>
  Die beiden Kreisdrähte, welche Tangentenlinien und Bögen behalten werden, und die Toleranz
Rückgabewert Promise<TopoDSWirePointer>
Der geschlossene Umrissdraht
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,
});
```
- Definiert in bitbybit-docs.d.ts:45640

Klasse OCCTWire

Index

Konstruktoren

beam profiles

build

debug

edit

extract

extract from wires

from base

get

multiple

place

primitives

rebuild

seam

via points

via wires

Konstruktoren

constructor

Rückgabewert OCCTWire

beam profiles

createIBeamProfileWire

Parameter

Rückgabewert Promise<TopoDSWirePointer>

Example

createHBeamProfileWire

Parameter

Rückgabewert Promise<TopoDSWirePointer>

Example

createTBeamProfileWire

Parameter

Rückgabewert Promise<TopoDSWirePointer>

Example

createUBeamProfileWire

Parameter

Rückgabewert Promise<TopoDSWirePointer>

Example

build

combineEdgesAndWiresIntoAWire

Parameter

Rückgabewert Promise<TopoDSWirePointer>

Example

createWireFromEdge

Parameter

Rückgabewert Promise<TopoDSWirePointer>

Example

addEdgesAndWiresToWire

Parameter

Rückgabewert Promise<TopoDSWirePointer>

Example

debug

debugInfo

Parameter

Rückgabewert Promise<WireDebugInfo>

Example

edit

closeOpenWire

Parameter

Rückgabewert Promise<TopoDSWirePointer>

Example

extract

splitOnPoints

Parameter

Rückgabewert Promise<TopoDSWirePointer[]>

Example

wiresToPoints

Parameter

Rückgabewert Promise<Point3[][]>

Example

divideWireByParamsToPoints

Parameter

Rückgabewert Promise<Point3[]>

Example

divideWireByEqualDistanceToPoints

Parameter

Rückgabewert Promise<Point3[]>

Example

pointOnWireAtParam

Parameter