Bitbybit Docs
    Bereite Suchindex vor...

    Klasse OCCTOperations

    Die Modellierungsoperationen, die OpenCascade-Drähte und -Flächen in Oberflächen und Volumenkörper verwandeln und Formen messen: Loften durch Schnitte, Extrudieren und Rotieren, Führen von Profilen entlang von Pfaden (Sweep), Versetzen, Verdicken von Schalen zu Volumenkörpern, Schneiden und Teilen, plus Begrenzungsrahmen, Begrenzungskugeln und Abfragen des nächsten Punkts. Abstände sind in Modelleinheiten und Winkel in Grad; jede Operation gibt eine neue Form zurück. Boolesche Operationen leben in booleans, Verrundungen in fillets.

    Index

    Konstruktoren

    closest pts

    • Ermittelt das Punktepaar, eines auf jeder Form, das einander am nächsten liegt.

      Der Abstand zwischen ihnen ist die Lücke zwischen den Formen; er ist 0, wenn sie sich berühren oder überlappen. Löst einen Fehler aus, wenn kein Paar gefunden werden kann.

      Parameter

      Rückgabewert Promise<Point3[]>

      Der Punkt auf der ersten Form und der Punkt auf der zweiten

      const [onBox, onSphere] = await bitbybit.occt.operations.closestPointsBetweenTwoShapes({ shape1: box, shape2: sphere });
      
    • Ermittelt für jeden Punkt in einer Liste den nächsten Punkt auf einer Form.

      Ein Punkt, der bereits auf der Form liegt, wird auf sich selbst abgebildet. Nützlich, um Punkte auf eine Oberfläche einzurasten.

      Parameter

      Rückgabewert Promise<Point3[]>

      Ein Punkt auf der Form pro Eingabepunkt, in derselben Reihenfolge

      const snapped = await bitbybit.occt.operations.closestPointsOnShapeFromPoints({ shape: sphere, points: [[0, 20, 0], [20, 0, 0]] });
      
    • Ermittelt den nächsten Punkt auf jeder von mehreren Formen für jeden Punkt in einer Liste.

      Das Ergebnis ist eine flache Liste: alle Punkte für die erste Form, in Punktreihenfolge, dann alle Punkte für die zweite Form, und so weiter.

      Parameter

      Rückgabewert Promise<Point3[]>

      Die nächsten Punkte, Form für Form gruppiert

      const snapped = await bitbybit.occt.operations.closestPointsOnShapesFromPoints({ shapes: [box, sphere], points: [[0, 20, 0], [20, 0, 0]] });
      

    divisions

    • Schneidet eine Form mit anderen Formen in Stücke, so wie ein Messer einen Laib teilt, ohne Material zu entfernen.

      Mit nonDestructive true, dem Standard, bleiben die Eingaben unberührt und das Ergebnis enthält die Stücke jeder beteiligten Form, die Schneider eingeschlossen; mit false kommen nur die Stücke von shape zurück. localFuzzyTolerance lässt Geometrie, die sich beinahe berührt, als berührend gelten.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer[]>

      Die Stücke

      const pieces = await bitbybit.occt.operations.splitShapeWithShapes({ shape: box, shapes: [cuttingPlane], localFuzzyTolerance: 1e-4, nonDestructive: false });
      
    • Schneidet einen Volumenkörper in parallele Scheiben entlang einer Richtung, wie einen Laib Brot, alle step Modell- einheiten von der Unterseite der Form nach oben.

      Jede Scheibe ist der ebene Schnitt, an dem eine Schnittebene auf den Volumenkörper trifft; sie kommen zusammen in einem Verbund zurück. Die Form muss Volumenkörper sein oder enthalten, sonst wird ein Fehler ausgelöst.

      Parameter

      Rückgabewert Promise<TopoDSCompoundPointer>

      Ein Verbund der Schnittflächen

      const layers = await bitbybit.occt.operations.slice({ shape: sphere, step: 0.5, direction: [0, 1, 0] });
      
    • Schneidet einen Volumenkörper in parallele Scheiben wie slice, aber mit einem sich wiederholenden Muster von Lücken zwischen ihnen, etwa 0.1, 0.5, 0.1, 0.5.

      Das Muster wird von der Unterseite der Form nach oben angewendet und wiederholt sich, bis das obere Ende erreicht ist.

      Parameter

      Rückgabewert Promise<TopoDSCompoundPointer>

      Ein Verbund der Schnittflächen

      const layers = await bitbybit.occt.operations.sliceInStepPattern({ shape: sphere, steps: [0.1, 0.5], direction: [0, 1, 0] });
      

    extrusions

    • Führt eine Form in gerader Linie entlang eines Vektors, dessen Länge die Strecke ist: eine Fläche wird zu einem Volumenkörper, ein Draht zu einer Schale, eine Kante zu einer Fläche.

      Die Form selbst bleibt am Anfang der Extrusion; der Vektor ist in Modelleinheiten, sodass [0, 10, 0] 10 Einheiten nach oben extrudiert.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Die extrudierte Form

      const disc = await bitbybit.occt.shapes.face.createCircleFace({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
      const cylinder = await bitbybit.occt.operations.extrude({ shape: disc, direction: [0, 10, 0] });
    • Führt mehrere Formen entlang desselben Vektors, wie extrude es für eine tut.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer[]>

      Die extrudierten Formen, in derselben Reihenfolge

      const walls = await bitbybit.occt.operations.extrudeShapes({ shapes: [faceA, faceB], direction: [0, 10, 0] });
      
    • Extrudiert eine flache Form entlang Y um height nach oben und verdreht sie dabei um angle Grad um die Y- Achse, wie eine gedrehte Säule.

      Die Form sollte flach liegen, wie die Profile, die dieses Paket erzeugt. Mit makeSolid true, dem Standard, ergibt ein Flächenprofil einen geschlossenen Volumenkörper; ein Draht ergibt eine verdrehte Schale.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Die verdrehte Extrusion

      const square = await bitbybit.occt.shapes.face.createSquareFace({ size: 5, center: [0, 0, 0], direction: [0, 1, 0] });
      const twisted = await bitbybit.occt.operations.rotatedExtrude({ shape: square, height: 20, angle: 90, makeSolid: true });

    lofts

    • Baut eine Oberfläche durch eine Reihe von Drähten, wie Haut, die über Rippen gespannt ist: jeder Draht ist ein Schnitt und die Oberfläche verläuft durch sie in Listenreihenfolge.

      Kanten werden als Einzelkanten-Drähte akzeptiert. Mit makeSolid true und geschlossenen Schnitten wird das Ergebnis zu einem Volumenkörper verschlossen; andernfalls ist es eine Schale. Schnitte passen am besten zusammen, wenn sie gleich viele Kanten haben.

      Parameter

      • inputs: LoftDto<TopoDSWirePointer>

        Die Schnittdrähte oder -kanten, in Reihenfolge, und ob ein Volumenkörper erstellt wird

      Rückgabewert Promise<TopoDSShapePointer>

      Die geloftete Schale oder der geloftete Volumenkörper

      const bottom = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
      const upper = await bitbybit.occt.shapes.wire.createSquareWire({ size: 6, center: [0, 10, 0], direction: [0, 1, 0] });
      const vase = await bitbybit.occt.operations.loft({ shapes: [bottom, upper], makeSolid: true });
    • Baut eine Oberfläche durch eine Reihe von Drähten wie loft, mit Kontrolle darüber, wie die Haut angepasst wird.

      straight macht Regelflächenstücke zwischen den Schnitten statt eines glatten Übergangs; closed lässt die Oberfläche vom letzten Schnitt zurück zum ersten laufen, und periodic macht diese Schleife glatt, indem die Schnitte neu abgetastet werden. startVertex und endVertex schließen die Enden zu Punkten.

      Parameter

      • inputs: LoftAdvancedDto<TopoDSWirePointer>

        Die Schnittdrähte oder -kanten, ob ein Volumenkörper erstellt wird, die Schließ- und Glättungsoptionen und optionale Endpunkte

      Rückgabewert Promise<TopoDSShapePointer>

      Die geloftete Schale oder der geloftete Volumenkörper

      const cone = await bitbybit.occt.operations.loftAdvanced({
      shapes: [circleBottom, circleMiddle],
      makeSolid: true,
      closed: false,
      periodic: false,
      straight: false,
      nrPeriodicSections: 10,
      useSmoothing: false,
      maxUDegree: 3,
      tolerance: 1e-7,
      parType: Bit.Inputs.OCCT.approxParametrizationTypeEnum.approxCentripetal,
      endVertex: [0, 20, 0],
      });

    measure

    • Misst, wie weit jeder Punkt in einer Liste von einer Form entfernt ist, als gerader Abstand zum nächsten Punkt auf ihr, in Modelleinheiten.

      Der Abstand gilt zur Oberfläche der Form, daher meldet ein Punkt innerhalb eines Volumenkörpers trotzdem seinen Abstand zur Hülle.

      Parameter

      Rückgabewert Promise<number[]>

      Ein Abstand pro Punkt, in derselben Reihenfolge

      const distances = await bitbybit.occt.operations.distancesToShapeFromPoints({ shape: sphere, points: [[0, 20, 0], [20, 0, 0]] });
      
    • Berechnet den achsenparallelen Quader, der eine Form umschließt: seine minimale und maximale Ecke, seinen Mittelpunkt und seine Größe entlang X, Y und Z.

      Bei gekrümmten Formen kann der Quader etwas größer sein als die Form selbst, weil der Kernel die Kontrollgeometrie und nicht die exakte Oberfläche eingrenzt.

      Parameter

      Rückgabewert Promise<BoundingBoxPropsDto>

      Der Rahmen als min, max, center und size

      const box = await bitbybit.occt.operations.boundingBoxOfShape({ shape });
      console.log(box.size, box.center);
    • Liest die minimale Ecke des achsenparallelen Begrenzungsrahmens einer Form, den Punkt mit dem kleinsten X, Y und Z.

      Parameter

      Rückgabewert Promise<Point3>

      Die minimale Ecke

      const min = await bitbybit.occt.operations.boundingBoxMinOfShape({ shape });
      
    • Liest die maximale Ecke des achsenparallelen Begrenzungsrahmens einer Form, den Punkt mit dem größten X, Y und Z.

      Parameter

      Rückgabewert Promise<Point3>

      Die maximale Ecke

      const max = await bitbybit.occt.operations.boundingBoxMaxOfShape({ shape });
      
    • Liest den Mittelpunkt des achsenparallelen Begrenzungsrahmens einer Form, auf halbem Weg zwischen seinen beiden Ecken.

      Dies ist nicht der Schwerpunkt; shapes.solid.getSolidCenterOfMass und seine Geschwister liefern diesen.

      Parameter

      Rückgabewert Promise<Point3>

      Der Mittelpunkt des Rahmens

      const center = await bitbybit.occt.operations.boundingBoxCenterOfShape({ shape });
      
    • Liest die Größe des achsenparallelen Begrenzungsrahmens einer Form entlang X, Y und Z, in Modelleinheiten.

      Parameter

      Rückgabewert Promise<Vector3>

      Die Breite, Höhe und Länge des Rahmens

      const size = await bitbybit.occt.operations.boundingBoxSizeOfShape({ shape });
      
    • Erzeugt den achsenparallelen Begrenzungsrahmen einer Form als Quader-Volumenkörper, praktisch zum Zeichnen oder zur Verwendung in einer booleschen Operation.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Der Quader-Volumenkörper

      const boxSolid = await bitbybit.occt.operations.boundingBoxShapeOfShape({ shape });
      
    • Berechnet eine Kugel, die eine Form umschließt: sie ist auf dem Begrenzungsrahmen zentriert und reicht bis zu seinen Ecken, sodass sie die Form immer enthält, aber nicht die kleinstmögliche Kugel ist.

      Parameter

      Rückgabewert Promise<BoundingSpherePropsDto>

      Die Kugel als center und radius

      const sphere = await bitbybit.occt.operations.boundingSphereOfShape({ shape });
      console.log(sphere.radius);
    • Liest den Mittelpunkt der Begrenzungskugel einer Form, der der Mittelpunkt ihres Begrenzungsrahmens ist.

      Parameter

      Rückgabewert Promise<Point3>

      Der Mittelpunkt der Kugel

      const center = await bitbybit.occt.operations.boundingSphereCenterOfShape({ shape });
      
    • Liest den Radius der Begrenzungskugel einer Form, den Abstand vom Mittelpunkt des Begrenzungsrahmens zu seiner Ecke, in Modelleinheiten.

      Parameter

      Rückgabewert Promise<number>

      Der Radius

      const radius = await bitbybit.occt.operations.boundingSphereRadiusOfShape({ shape });
      

    offsets

    • Versetzt den Rand einer Form um einen festen Abstand nach außen, oder bei einem negativen Abstand nach innen: ein Draht wächst zu einem parallelen Umriss, eine Fläche oder ein Volumenkörper zu einem größeren.

      Ein Draht oder eine Kante wird in der eigenen Ebene versetzt, oder auf face, wenn angegeben; Ecken werden gerundet. Ein Abstand von 0 gibt die Form zurück, wie sie ist.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Die versetzte Form

      const bigger = await bitbybit.occt.operations.offset({ shape: box, distance: 1, tolerance: 0.1 });
      
    • Versetzt eine Form wie offset, mit einer Wahl, wie Ecken verbunden werden: arc rundet sie, intersection verlängert die Seiten zu einer scharfen Ecke, tangent hält sie tangential.

      removeIntEdges verwirft die inneren Kanten, die der Versatz auf einem Volumenkörper hinterlassen kann.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Die versetzte Form

      const sharper = await bitbybit.occt.operations.offsetAdv({
      shape: rectangleWire,
      distance: 1,
      tolerance: 0.1,
      joinType: Bit.Inputs.OCCT.joinTypeEnum.intersection,
      removeIntEdges: false,
      });
    • Gibt einer Fläche oder Schale eine Dicke und verwandelt sie in eine massive Platte oder Wand mit dem gegebenen offset.

      Ein positiver Versatz verdickt in Richtung der Oberflächennormalen, ein negativer in die andere Richtung. Verwenden Sie es, um eine geloftete oder per Sweep erzeugte Haut in etwas Druckbares zu verwandeln.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Der dicke Volumenkörper

      const wall = await bitbybit.occt.operations.makeThickSolidSimple({ shape: loftedShell, offset: 0.5 });
      
    • Höhlt einen Volumenkörper zu einer Schale mit der gegebenen Wanddicke aus, indem die aufgeführten Flächen entfernt und der Rest versetzt wird.

      Das Entfernen der oberen Fläche eines Quaders ergibt zum Beispiel einen offenen Becher. offset ist die Wand- dicke, negativ, um nach innen zu wachsen; joinType sagt, wie die versetzten Wände an Ecken zusammentreffen, die anderen Flags gehen an den Dickkörper-Builder des Kernels.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Der ausgehöhlte Volumenkörper

      const box = await bitbybit.occt.shapes.solid.createBox({ width: 10, length: 10, height: 10, center: [0, 0, 0] });
      const faces = await bitbybit.occt.shapes.face.getFaces({ shape: box });
      const cup = await bitbybit.occt.operations.makeThickSolidByJoin({
      shape: box,
      shapes: [faces[0]],
      offset: -1,
      tolerance: 1e-3,
      intersection: false,
      selfIntersection: false,
      joinType: Bit.Inputs.OCCT.joinTypeEnum.arc,
      removeIntEdges: false,
      });
    • Versetzt einen Draht, der nicht in einer Ebene liegt, indem er entlang direction extrudiert, das Ergebnis verdickt und die versetzte Kante davon zurückgelesen wird.

      Es funktioniert am besten bei glatten Drähten; verrunden Sie scharfe Ecken zuerst mit fillets.fillet3DWire. Wenn die versetzten Kanten nicht zu einem Draht verbunden werden können, kommen sie als Liste von Kanten zurück.

      Parameter

      Rückgabewert Promise<TopoDSWirePointer>

      Der versetzte Draht oder die losen Kanten, wenn sie nicht verbunden werden konnten

      const outer = await bitbybit.occt.operations.offset3DWire({ shape: smoothWire, offset: 1, direction: [0, 1, 0] });
      

    pipeing

    • Führt eine oder mehrere Profilformen entlang eines Pfaddrahts und schließt das Ergebnis zu einem Volumenkörper.

      Die Profile sollten auf dem Pfad platziert sein; bei mehreren Profilen blendet der Sweep unterwegs von einem zum nächsten über.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Der per Sweep erzeugte Volumenkörper

      const tube = await bitbybit.occt.operations.pipe({ shape: pathWire, shapes: [profileAtStart] });
      
    • Führt ein regelmäßiges Polygon entlang eines Drahts und ergibt ein Rohr mit nrCorners flachen Seiten, zum Beispiel eine Sechskantstange entlang eines Pfads.

      Das Polygon mit radius wird am Anfang des Drahts platziert, senkrecht zu ihm. makeSolid ergibt einen Volumenkörper statt einer Schale, trihedronEnum wählt, wie sich das Profil entlang des Pfads dreht, und forceApproxC1 glättet das Ergebnis.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Der per Sweep erzeugte Volumenkörper oder die Schale

      const bar = await bitbybit.occt.operations.pipePolylineWireNGon({
      shape: pathWire,
      radius: 0.5,
      nrCorners: 6,
      makeSolid: true,
      trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
      forceApproxC1: false,
      });
    • Führt einen Kreis entlang jedes von mehreren Drähten, wie pipeWireCylindrical es für einen tut, alle mit demselben Radius und denselben Optionen.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer[]>

      Ein Rohr pro Draht, in derselben Reihenfolge

      const tubes = await bitbybit.occt.operations.pipeWiresCylindrical({
      shapes: [pathA, pathB],
      radius: 0.5,
      makeSolid: true,
      trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
      forceApproxC1: false,
      });
    • Führt einen Kreis entlang eines Drahts und ergibt ein rundes Rohr mit dem gegebenen Radius, das dem Pfad folgt.

      Der Kreis wird am Anfang des Drahts platziert, senkrecht zu ihm. makeSolid ergibt einen Volumenkörper statt einer Schale, trihedronEnum wählt, wie sich das Profil dreht, während es dem Pfad folgt, und forceApproxC1 glättet das Ergebnis.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Das Rohr als Volumenkörper oder Schale

      const tube = await bitbybit.occt.operations.pipeWireCylindrical({
      shape: pathWire,
      radius: 0.5,
      makeSolid: true,
      trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
      forceApproxC1: false,
      });

    revolutions

    • Rotiert eine Form um eine Achse durch den Ursprung, um eine Oberfläche oder einen Volumenkörper zu überstreichen: eine Fläche ergibt einen Volumenkörper, ein Draht eine Schale.

      angle ist in Grad; 360 oder mehr ergibt eine volle Umdrehung. Die Achse verläuft entlang direction: ein Profil neben der Y-Achse, um diese rotiert, ergibt eine Vase. Das Profil darf sie nicht kreuzen.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Die rotierte Form

      const profile = await bitbybit.occt.shapes.wire.createPolylineWire({ points: [[2, 0, 0], [4, 0, 0], [3, 10, 0], [2, 12, 0]] });
      const vase = await bitbybit.occt.operations.revolve({ shape: profile, angle: 360, direction: [0, 1, 0], copy: false });