Bitbybit Docs
    Bereite Suchindex vor...

    Klasse OCCTFace

    Flächen in OpenCascade: begrenzte Stücke einer Oberfläche, eben oder gekrümmt, mit einem äußeren Randdraht und optionalen inneren Drähten, die Löcher bilden. Bauen Sie sie aus Drähten oder Oberflächen oder als fertige ebene Formen (Kreise, Rechtecke, Sterne, Trägerprofile), die auf der Grundebene liegen, sofern direction nichts anderes sagt; durchlaufen Sie ihre Oberfläche über UV-Parameter, um Punkte, Normalen und Gitter von Drähten zu erhalten; schneiden Sie Lochmuster in sie; und messen Sie Flächeninhalt und Schwerpunkt. U und V sind die beiden Richtungen einer Oberfläche, hier als Anteile von 0 bis 1 des eigenen Bereichs der Fläche angegeben. Flächen fügen sich Kante an Kante zu Schalen, die shapes.shell behandelt.

    Index

    Konstruktoren

    beam profiles

    • Erstellt den ebenen Querschnitt eines I-Trägers: 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 entlang Y.

      Parameter

      • inputs: IBeamProfileDto

        Die Profilgröße, die beiden Dicken, die Ausrichtung, die Drehung, der Mittelpunkt und die Ebenennormale

      Rückgabewert Promise<TopoDSFacePointer>

      Die Profilfläche des I-Trägers

      const profile = await bitbybit.occt.shapes.face.createIBeamProfileFace({
      width: 10,
      height: 20,
      webThickness: 2,
      flangeThickness: 3,
      alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
      rotation: 0,
      center: [0, 0, 0],
      direction: [0, 1, 0],
      });
      const beam = await bitbybit.occt.operations.extrude({ shape: profile, direction: [0, 100, 0] });
    • Erstellt den ebenen Querschnitt eines H-Trägers: 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. Er liegt auf dem Boden.

      Parameter

      • inputs: HBeamProfileDto

        Die Profilgröße, die beiden Dicken, die Ausrichtung, die Drehung, der Mittelpunkt und die Ebenennormale

      Rückgabewert Promise<TopoDSFacePointer>

      Die Profilfläche des H-Trägers

      const profile = await bitbybit.occt.shapes.face.createHBeamProfileFace({
      width: 20,
      height: 10,
      webThickness: 2,
      flangeThickness: 3,
      alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
      rotation: 0,
      center: [0, 0, 0],
      direction: [0, 1, 0],
      });
    • Erstellt den ebenen Querschnitt eines T-Trägers: 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, und rotation dreht ihn in seiner Ebene, in Grad. Er liegt flach auf dem Boden.

      Parameter

      • inputs: TBeamProfileDto

        Die Profilgröße, die beiden Dicken, die Ausrichtung, die Drehung, der Mittelpunkt und die Ebenennormale

      Rückgabewert Promise<TopoDSFacePointer>

      Die Profilfläche des T-Trägers

      const profile = await bitbybit.occt.shapes.face.createTBeamProfileFace({
      width: 10,
      height: 12,
      webThickness: 2,
      flangeThickness: 2,
      alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
      rotation: 0,
      center: [0, 0, 0],
      direction: [0, 1, 0],
      });
    • Erstellt den ebenen Querschnitt eines U-Trägers, 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 flach 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<TopoDSFacePointer>

      Die Profilfläche des U-Trägers

      const profile = await bitbybit.occt.shapes.face.createUBeamProfileFace({
      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],
      });

    debug

    • Sammelt diagnostische Fakten über eine Fläche: ihren Oberflächentyp, U- und V-Grade, die Anzahl der Kontrollpunkte und Knoten, ob U oder V geschlossen, periodisch oder rational sind, die UV-Grenzen, den Flächeninhalt, die Ebenheit, die Orientierung und die Anzahl der Drähte und Kanten.

      Eine leere oder null-Fläche ergibt einen als ungültig markierten Bericht.

      Parameter

      Rückgabewert Promise<FaceDebugInfo>

      Der Bericht

      const info = await bitbybit.occt.shapes.face.debugInfo({ shape: face });
      console.log(info.type, info.isPlanar, info.area);

    extract

    • Legt ein Gitter aus Punkten über eine Fläche, indem gleichmäßig durch ihre U- und V-Bereiche geschritten wird.

      nrDivisionsU mal nrDivisionsV Punkte decken die Fläche von Rand zu Rand ab, Reihe für Reihe aufgelistet: alle V- Werte für das erste U, dann das nächste U. Die Entfernungs-Flags lassen die erste oder letzte Reihe weg; die Verschiebungs-Flags rücken jeden Punkt um einen halben Schritt.

      Parameter

      Rückgabewert Promise<Point3[]>

      Die Punkte, Reihe für Reihe

      const points = await bitbybit.occt.shapes.face.subdivideToPoints({
      shape: face,
      nrDivisionsU: 10,
      nrDivisionsV: 5,
      shiftHalfStepU: false,
      removeStartEdgeU: false,
      removeEndEdgeU: false,
      shiftHalfStepV: false,
      removeStartEdgeV: false,
      removeEndEdgeV: false,
      });
    • Zeichnet gleichmäßig verteilte Drähte über eine Fläche entlang einer Parameterrichtung, wie die Linien eines linierten Blatts.

      nrDivisions Schritte ergeben einen Draht mehr als das, die Begrenzungslinien eingeschlossen; removeStart und removeEnd lassen diese weg, shiftHalfStep rückt jeden Draht um einen halben Schritt. Mit isU true sitzt jeder Draht bei einem festen U und läuft über V; false tauscht die Rollen.

      Parameter

      Rückgabewert Promise<TopoDSWirePointer[]>

      Die Drähte, in Reihenfolge entlang der gewählten Richtung

      const lines = await bitbybit.occt.shapes.face.subdivideToWires({ shape: face, nrDivisions: 10, isU: true, shiftHalfStep: false, removeStart: false, removeEnd: false });
      
    • Legt ein Gitter aus Punkten über eine Fläche wie subdivideToPoints, verschiebt und entfernt aber Punkte in jeder n-ten Reihe oder Spalte, für ziegelartige und versetzte Muster.

      Jede Regel ist ein Paar: shiftHalfStepNthU sagt, jede wievielte V-Reihe um einen halben Schritt in U rückt, shiftHalfStepUOffsetN, wo die Zählung beginnt; die Entfernungsregeln lassen jeden n-ten Punkt einer Randreihe weg.

      Parameter

      Rückgabewert Promise<Point3[]>

      Die Punkte, Reihe für Reihe

      const staggered = await bitbybit.occt.shapes.face.subdivideToPointsControlled({
      shape: face,
      nrDivisionsU: 10,
      nrDivisionsV: 10,
      shiftHalfStepNthU: 2,
      shiftHalfStepUOffsetN: 0,
      removeStartEdgeNthU: 0,
      removeStartEdgeUOffsetN: 0,
      removeEndEdgeNthU: 0,
      removeEndEdgeUOffsetN: 0,
      shiftHalfStepNthV: 0,
      shiftHalfStepVOffsetN: 0,
      removeStartEdgeNthV: 0,
      removeStartEdgeVOffsetN: 0,
      removeEndEdgeNthV: 0,
      removeEndEdgeVOffsetN: 0,
      });
    • Berechnet die Oberflächennormale an jedem Punkt des Gitters, das subdivideToPoints über eine Fläche legen würde, mit denselben Optionen und derselben Reihenfolge.

      Die Normalen sind Einheitsvektoren und folgen der Orientierung der Fläche, daher ergibt eine umgekehrte Fläche sie umgekehrt. Kombinieren Sie die Liste mit subdivideToPoints, um Dinge auf der Oberfläche stehend zu platzieren.

      Parameter

      Rückgabewert Promise<Vector3[]>

      Die Einheitsnormalen, Reihe für Reihe

      const normals = await bitbybit.occt.shapes.face.subdivideToNormals({
      shape: face,
      nrDivisionsU: 10,
      nrDivisionsV: 5,
      shiftHalfStepU: false,
      removeStartEdgeU: false,
      removeEndEdgeU: false,
      shiftHalfStepV: false,
      removeStartEdgeV: false,
      removeEndEdgeV: false,
      });
    • Listet die UV-Parameterpaare des Gitters auf, das subdivideToPoints über eine Fläche legen würde, mit denselben Optionen und derselben Reihenfolge.

      Die Paare sind in den echten UV-Werten der Fläche, nicht in Anteilen.

      Parameter

      Rückgabewert Promise<Point2[]>

      Die UV-Paare, Reihe für Reihe

      const uvs = await bitbybit.occt.shapes.face.subdivideToUV({
      shape: face,
      nrDivisionsU: 10,
      nrDivisionsV: 5,
      shiftHalfStepU: false,
      removeStartEdgeU: false,
      removeEndEdgeU: false,
      shiftHalfStepV: false,
      removeStartEdgeV: false,
      removeEndEdgeV: false,
      });
    • Ermittelt den Punkt auf einer Fläche bei den gegebenen UV-Anteilen.

      paramU und paramV laufen von 0 bis 1 über den U- und V-Bereich der Fläche, sodass 0.5, 0.5 die Mitte des Bereichs ist, die auf einer getrimmten Fläche nicht immer innerhalb der Fläche liegt.

      Parameter

      Rückgabewert Promise<Point3>

      Der Punkt auf der Oberfläche

      const middle = await bitbybit.occt.shapes.face.pointOnUV({ shape: face, paramU: 0.5, paramV: 0.5 });
      
    • Ermittelt die Oberflächennormale einer Fläche bei den gegebenen UV-Anteilen.

      paramU und paramV laufen von 0 bis 1 über den U- und V-Bereich der Fläche. Die Normale ist ein Einheits- vektor und folgt der Orientierung der Fläche, daher ergibt eine umgekehrte Fläche sie umgekehrt.

      Parameter

      Rückgabewert Promise<Vector3>

      Die Einheitsnormale

      const normal = await bitbybit.occt.shapes.face.normalOnUV({ shape: face, paramU: 0.5, paramV: 0.5 });
      
    • Ermittelt die Punkte auf einer Fläche bei mehreren UV-Anteilspaaren auf einmal.

      Jedes Paar enthält U, dann V, beide von 0 bis 1 über den Bereich der Fläche.

      Parameter

      Rückgabewert Promise<Point3[]>

      Ein Punkt pro Paar, in derselben Reihenfolge

      const points = await bitbybit.occt.shapes.face.pointsOnUVs({ shape: face, paramsUV: [[0, 0], [0.5, 0.5], [1, 1]] });
      
    • Ermittelt die Oberflächennormalen einer Fläche bei mehreren UV-Anteilspaaren auf einmal.

      Jedes Paar enthält U, dann V, beide von 0 bis 1 über den Bereich der Fläche. Die Normalen sind Einheits- vektoren der zugrunde liegenden Oberfläche; anders als bei normalOnUV werden sie für eine umgekehrte Fläche nicht umgekehrt.

      Parameter

      Rückgabewert Promise<Vector3[]>

      Eine Einheitsnormale pro Paar, in derselben Reihenfolge

      const normals = await bitbybit.occt.shapes.face.normalsOnUVs({ shape: face, paramsUV: [[0, 0], [0.5, 0.5], [1, 1]] });
      
    • Platziert gleichmäßig verteilte Punkte entlang einer geraden Linie über den UV-Bereich einer Fläche.

      Mit isU true sitzt die Linie bei param (ein Anteil von 0 bis 1 des U-Bereichs) und nrPoints Punkte verteilen sich über den ganzen V-Bereich; mit false tauschen die Rollen. removeStartPoint und removeEndPoint lassen die Enden weg, und shiftHalfStep rückt jeden Punkt um einen halben Schritt.

      Parameter

      Rückgabewert Promise<Point3[]>

      Die Punkte entlang der Linie, in Reihenfolge

      const midline = await bitbybit.occt.shapes.face.subdivideToPointsOnParam({ shape: face, isU: true, param: 0.5, nrPoints: 10, shiftHalfStep: false, removeStartPoint: false, removeEndPoint: false });
      
    • Zeichnet einen Draht über eine Fläche entlang einer Parameterlinie, der Oberfläche folgend.

      Mit isU true sitzt der Draht bei param (ein Anteil von 0 bis 1 des U-Bereichs) und läuft über den ganzen V-Bereich; mit false tauschen die Rollen.

      Parameter

      Rückgabewert Promise<TopoDSWirePointer>

      Der Draht auf der Oberfläche

      const middle = await bitbybit.occt.shapes.face.wireAlongParam({ shape: face, isU: true, param: 0.5 });
      
    • Zeichnet mehrere Drähte über eine Fläche, einen pro Parameterwert, der Oberfläche folgend.

      Mit isU true sitzt jeder Draht bei seinem Anteil des U-Bereichs und läuft über den ganzen V- Bereich; mit false tauschen die Rollen.

      Parameter

      Rückgabewert Promise<TopoDSWirePointer[]>

      Ein Draht pro Anteil, in derselben Reihenfolge

      const wires = await bitbybit.occt.shapes.face.wiresAlongParams({ shape: face, isU: false, params: [0.25, 0.5, 0.75] });
      

    filter

    • Ordnet Punkte als innerhalb einer Fläche, auf ihrem Rand oder außerhalb ein und behält die gewählten Gruppen.

      keepIn, keepOn, keepOut und keepUnknown wählen die Gruppen; tolerance entscheidet, wie nah am Rand als darauf liegend gilt. Mit useBndBox liegt ein Punkt außerhalb des um gapTolerance vergrößerten Begrenzungsrahmens außerhalb.

      Parameter

      Rückgabewert Promise<Point3[]>

      Die Punkte, die den Filter passiert haben, in ihrer ursprünglichen Reihenfolge

      const onFace = await bitbybit.occt.shapes.face.filterFacePoints({
      shape: face,
      points: grid,
      tolerance: 1e-4,
      useBndBox: false,
      gapTolerance: 0.1,
      keepIn: true,
      keepOn: true,
      keepOut: false,
      keepUnknown: false,
      });
    • Führt filterFacePoints mit denselben Punkten und Optionen gegen mehrere Flächen aus.

      Standardmäßig enthält das Ergebnis eine Liste pro Fläche; mit flatPointsArray true werden die Listen zu einer verbunden, sodass ein Punkt auf zwei Flächen zweimal erscheint.

      Parameter

      Rückgabewert Promise<Point3[] | Point3[][]>

      Eine Punktliste pro Fläche oder eine einzige zusammengefügte Liste

      const perFace = await bitbybit.occt.shapes.face.filterFacesPoints({
      shapes: faces,
      points: grid,
      tolerance: 1e-4,
      useBndBox: false,
      gapTolerance: 0.1,
      keepIn: true,
      keepOn: true,
      keepOut: false,
      keepUnknown: false,
      flatPointsArray: false,
      });

    from

    • Erstellt eine Fläche pro Draht, jede aus der Oberfläche einer führenden Fläche geschnitten, sodass sie die Krümmung dieser Oberfläche annimmt.

      Die Drähte müssen auf der Oberfläche liegen. Mit inside true wird jeder Draht so gedreht, dass seine Fläche der von ihm eingeschlossene Bereich ist; mit false entscheidet die eigene Richtung des Drahts, und ein Draht, der in die andere Richtung verläuft, ergibt den äußeren Bereich.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer[]>

      Eine Fläche pro Draht, in derselben Reihenfolge

      const patches = await bitbybit.occt.shapes.face.createFacesFromWiresOnFace({ wires: circlesOnSphere, face: sphereFace, inside: true });
      
    • Erstellt eine Fläche aus einem Draht, der auf der Oberfläche einer führenden Fläche liegt, sodass die neue Fläche die Krümmung dieser Oberfläche annimmt.

      Mit inside true wird der Draht so gedreht, dass die Fläche der von ihm eingeschlossene Bereich ist; mit false entscheidet die eigene Richtung des Drahts, und ein Draht, der in die andere Richtung verläuft, ergibt den Bereich außerhalb.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die neue Fläche

      const patch = await bitbybit.occt.shapes.face.createFaceFromWireOnFace({ wire: circleOnCylinder, face: cylinderFace, inside: true });
      
    • Erstellt eine Fläche, die von einem geschlossenen Draht begrenzt wird.

      Mit planar true muss der Draht in einer Ebene liegen und die Fläche ist eben; mit false wird eine glatte Oberfläche durch die Kanten des Drahts angepasst, was einen Draht füllt, der nicht eben ist. Eine Form, die kein Draht ist, löst einen Fehler aus.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die neue Fläche

      const wire = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
      const disc = await bitbybit.occt.shapes.face.createFaceFromWire({ shape: wire, planar: true });
    • Erstellt eine Fläche aus mehreren Drähten: der erste Draht ist die äußere Begrenzung und jeder weitere Draht schneidet ein Loch hinein.

      Mit planar true müssen die Drähte in einer Ebene liegen. Die Lochdrähte müssen innerhalb des äußeren liegen, ohne ihn oder einander zu kreuzen.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Fläche mit Löchern

      const outer = await bitbybit.occt.shapes.wire.createRectangleWire({ width: 20, length: 10, center: [0, 0, 0], direction: [0, 1, 0] });
      const hole = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 2, center: [0, 0, 0], direction: [0, 1, 0] });
      const plate = await bitbybit.occt.shapes.face.createFaceFromWires({ shapes: [outer, hole], planar: true });
    • Erstellt eine Fläche aus mehreren Drähten auf der Oberfläche einer führenden Fläche: der erste Draht ist die äußere Begrenzung und jeder weitere Draht schneidet ein Loch.

      Die Fläche nimmt die Krümmung der führenden Oberfläche an. inside gilt für den ersten Draht: true dreht ihn so, dass die Fläche der von ihm eingeschlossene Bereich ist; false lässt seine eigene Richtung entscheiden.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Fläche mit Löchern

      const perforated = await bitbybit.occt.shapes.face.createFaceFromWiresOnFace({ wires: [outerOnCylinder, holeOnCylinder], face: cylinderFace, inside: true });
      
    • Erstellt eine Fläche pro geschlossenem Draht, jede wie createFaceFromWire es täte.

      Mit planar true muss jeder Draht in einer Ebene liegen; mit false wird durch jeden eine glatte Oberfläche angepasst.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer[]>

      Eine Fläche pro Draht, in derselben Reihenfolge

      const faces = await bitbybit.occt.shapes.face.createFacesFromWires({ shapes: wires, planar: true });
      
    • Verbindet Kreise mit Tangentenriemen: für jedes Paar zeichnet es die zwei äußeren Tangentenlinien und die äußeren Bögen dazwischen und füllt diesen Umriss mit einer ebenen Fläche.

      combination wählt die Paare: allWithAll jeden Kreis mit jedem anderen, inOrder Nachbarn in der Liste, inOrderClosed auch den letzten mit dem ersten. unify verschmilzt die Flächen; andernfalls bilden sie einen Verbund.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Die verschmolzene Form oder der Verbund der Riemenflächen

      const a = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 3, center: [0, 0, 0], direction: [0, 1, 0] });
      const b = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 1, center: [10, 0, 0], direction: [0, 1, 0] });
      const c = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 2, center: [5, 0, 8], direction: [0, 1, 0] });
      const belt = await bitbybit.occt.shapes.face.createFaceFromMultipleCircleTanWires({
      circles: [a, b, c],
      combination: Bit.Inputs.OCCT.combinationCirclesForFaceEnum.inOrderClosed,
      unify: true,
      tolerance: 1e-7,
      });
    • Verbindet Kreise aus aufeinanderfolgenden Listen mit Tangentenriemen, so wie createFaceFromMultipleCircleTanWires einzelne Kreise verbindet.

      allWithAll verbindet jeden Kreis einer Liste mit jedem Kreis der nächsten; inOrder verbindet Kreise an derselben Position in benachbarten Listen, die gleich lang sein müssen; inOrderClosed schließt auch jede Liste zu einem Ring. unify verschmilzt die Flächen; andernfalls bilden sie einen Verbund.

      Parameter

      Rückgabewert Promise<TopoDSShapePointer>

      Die verschmolzene Form oder der Verbund der Riemenflächen

      const mesh = await bitbybit.occt.shapes.face.createFaceFromMultipleCircleTanWireCollections({
      listsOfCircles: [bottomRow, middleRow, topRow],
      combination: Bit.Inputs.OCCT.combinationCirclesForFaceEnum.inOrderClosed,
      unify: true,
      tolerance: 1e-7,
      });
    • Erstellt eine Fläche, die eine ganze Oberfläche abdeckt, bis zu den natürlichen Grenzen der Oberfläche.

      tolerance wird verwendet, um entartete Kanten zu erkennen, etwa den Pol einer Kugel. Oberflächen kommen aus geom.surfaces.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Fläche

      const face = await bitbybit.occt.shapes.face.faceFromSurface({ shape: surface, tolerance: 1e-7 });
      
    • Erstellt eine Fläche, indem eine Oberfläche mit einem darauf liegenden Draht geschnitten wird.

      Mit inside true wird der Draht so gedreht, dass die Fläche der von ihm eingeschlossene Bereich ist; mit false entscheidet die eigene Richtung des Drahts, und ein Draht, der in die andere Richtung verläuft, ergibt den Bereich außerhalb. Oberflächen kommen aus geom.surfaces.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Fläche

      const patch = await bitbybit.occt.shapes.face.faceFromSurfaceAndWire({ surface, wire: wireOnSurface, inside: true });
      

    from base

    • Erstellt eine ebene Dreiecksfläche aus drei Punkten.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Fläche

      const face = await bitbybit.occt.shapes.face.fromBaseTriangle({ triangle: [[0, 0, 0], [10, 0, 0], [0, 0, 10]] });
      
    • Erstellt eine ebene Dreiecksfläche pro Dreieck eines Meshes.

      Ein Dreieck, das keine Fläche bilden kann, etwa eines mit wiederholten Punkten, wird mit einer Warnung in der Konsole übersprungen.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer[]>

      Eine Fläche pro Dreieck, das gebaut werden konnte

      const faces = await bitbybit.occt.shapes.face.fromBaseMesh({
      mesh: [[[0, 0, 0], [10, 0, 0], [0, 0, 10]], [[10, 0, 0], [10, 0, 10], [0, 0, 10]]],
      });

    get

    • Wählt eine Fläche aus einer Form anhand ihrer Position, gezählt ab 0, in der Reihenfolge, in der der Kernel die Form durchläuft.

      Die Form muss eine Fläche oder etwas aus Flächen Gebautes sein; ein Index jenseits der letzten Fläche löst einen Fehler aus.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Fläche an diesem Index

      const first = await bitbybit.occt.shapes.face.getFace({ shape: box, index: 0 });
      
    • Kehrt eine Fläche um, sodass ihre Normale in die andere Richtung zeigt.

      Die Geometrie bleibt gleich; nur die Orientierung ändert sich, die die Außenseite einer Schale und die Richtung bestimmt, die normalOnUV meldet.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die umgedrehte Fläche

      const flipped = await bitbybit.occt.shapes.face.reversedFace({ shape: face });
      
    • Liest den kleinsten U-Parameterwert einer Fläche, in den eigenen Einheiten der Oberfläche.

      Zusammen mit getUMaxBound, getVMinBound und getVMaxBound ergibt es den Bereich, auf den die anderswo in dieser Klasse verwendeten UV-Anteile abgebildet werden.

      Parameter

      Rückgabewert Promise<number>

      Die untere U-Grenze

      const uMin = await bitbybit.occt.shapes.face.getUMinBound({ shape: face });
      
    • Liest den größten U-Parameterwert einer Fläche, in den eigenen Einheiten der Oberfläche.

      Parameter

      Rückgabewert Promise<number>

      Die obere U-Grenze

      const uMax = await bitbybit.occt.shapes.face.getUMaxBound({ shape: face });
      
    • Liest den kleinsten V-Parameterwert einer Fläche, in den eigenen Einheiten der Oberfläche.

      Parameter

      Rückgabewert Promise<number>

      Die untere V-Grenze

      const vMin = await bitbybit.occt.shapes.face.getVMinBound({ shape: face });
      
    • Liest den größten V-Parameterwert einer Fläche, in den eigenen Einheiten der Oberfläche.

      Parameter

      Rückgabewert Promise<number>

      Die obere V-Grenze

      const vMax = await bitbybit.occt.shapes.face.getVMaxBound({ shape: face });
      
    • Misst den Flächeninhalt einer Fläche, in quadratischen Modelleinheiten.

      Parameter

      Rückgabewert Promise<number>

      Der Flächeninhalt

      const area = await bitbybit.occt.shapes.face.getFaceArea({ shape: face });
      
    • Misst den Flächeninhalt jeder Fläche in einer Liste, in quadratischen Modelleinheiten.

      Parameter

      Rückgabewert Promise<number[]>

      Ein Flächeninhalt pro Fläche, in derselben Reihenfolge

      const areas = await bitbybit.occt.shapes.face.getFacesAreas({ shapes: faces });
      
    • Ermittelt den Schwerpunkt einer Fläche, den Punkt, auf dem ihr Flächeninhalt im Gleichgewicht ist.

      Auf einer gekrümmten oder ringförmigen Fläche kann dieser Punkt abseits der Oberfläche liegen.

      Parameter

      Rückgabewert Promise<Point3>

      Der Schwerpunkt

      const center = await bitbybit.occt.shapes.face.getFaceCenterOfMass({ shape: face });
      
    • Ermittelt den Schwerpunkt jeder Fläche in einer Liste.

      Parameter

      Rückgabewert Promise<Point3[]>

      Ein Punkt pro Fläche, in derselben Reihenfolge

      const centers = await bitbybit.occt.shapes.face.getFacesCentersOfMass({ shapes: faces });
      

    patterns

    • Legt Rechteckdrähte über eine Fläche, einen pro Zelle einer Unterteilung ihres UV-Bereichs in nrRectanglesU mal nrRectanglesV, der Oberfläche folgend.

      Die Randversätze beschneiden den Bereich an jedem Ende. Jedes Rechteck sitzt zentriert in seiner Zelle, bemessen durch die Skalierungsmuster als Anteil davon; das Verrundungsmuster rundet Ecken, das Einschlussmuster überspringt Zellen.

      Parameter

      Rückgabewert Promise<TopoDSWirePointer[]>

      Die Rechteckdrähte, Zelle für Zelle

      const cells = await bitbybit.occt.shapes.face.subdivideToRectangleWires({
      shape: face,
      nrRectanglesU: 6,
      nrRectanglesV: 4,
      scalePatternU: [0.8, 0.5],
      scalePatternV: [0.8],
      filletPattern: [0.3],
      inclusionPattern: [true, true, false],
      offsetFromBorderU: 0.05,
      offsetFromBorderV: 0.05,
      });
    • Schneidet ein Gitter aus rechteckigen Löchern in eine Fläche und gibt die durchlöcherte Fläche zurück.

      Die Löcher folgen denselben Zellen und Mustern wie subdivideToRectangleWires; wenn kein Skalierungs- muster angegeben ist, deckt jedes Loch die Hälfte seiner Zelle ab. Mit holesToFaces true trägt das Ergebnis auch eine Fläche pro Loch, nach der durchlöcherten Fläche, was für Deckel oder Füllstücke praktisch ist.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer[]>

      Die perforierte Fläche, gefolgt von den Lochflächen, falls angefordert

      const [perforated] = await bitbybit.occt.shapes.face.subdivideToRectangleHoles({
      shape: face,
      nrRectanglesU: 6,
      nrRectanglesV: 4,
      scalePatternU: [0.6],
      scalePatternV: [0.6],
      filletPattern: [0.5],
      inclusionPattern: [true],
      holesToFaces: false,
      offsetFromBorderU: 0.05,
      offsetFromBorderV: 0.05,
      });
    • Legt eine Wabe aus Sechseckdrähten über eine Fläche, nrHexagonsU mal nrHexagonsV davon, in ihren UV-Bereich eingepasst, jeder der Oberfläche folgend.

      Die Randversätze beschneiden einen Anteil des Bereichs an jedem Ende; flatU dreht eine flache Seite zu U, die Extend-Flags strecken die äußeren Reihen über die Ränder hinaus. Skalierungs-, Verrundungs- und Einschluss- muster wiederholen sich pro Sechseck.

      Parameter

      Rückgabewert Promise<TopoDSWirePointer[]>

      Die Sechseckdrähte, Reihe für Reihe

      const cells = await bitbybit.occt.shapes.face.subdivideToHexagonWires({
      shape: face,
      nrHexagonsU: 8,
      nrHexagonsV: 6,
      flatU: false,
      scalePatternU: [0.9],
      scalePatternV: [0.9],
      filletPattern: [0.2],
      inclusionPattern: [true],
      offsetFromBorderU: 0,
      offsetFromBorderV: 0,
      });
    • Schneidet eine Wabe aus sechseckigen Löchern in eine Fläche und gibt die durchlöcherte Fläche zurück.

      Die Löcher folgen demselben Layout und denselben Mustern wie subdivideToHexagonWires; wenn kein Skalierungs- muster angegeben ist, ist jedes Loch halb so groß wie sein Sechseck. Mit holesToFaces true trägt das Ergebnis auch eine Fläche pro Loch, nach der durchlöcherten Fläche.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer[]>

      Die perforierte Fläche, gefolgt von den Lochflächen, falls angefordert

      const [perforated] = await bitbybit.occt.shapes.face.subdivideToHexagonHoles({
      shape: face,
      nrHexagonsU: 8,
      nrHexagonsV: 6,
      flatU: false,
      holesToFaces: false,
      scalePatternU: [0.7],
      scalePatternV: [0.7],
      filletPattern: [0],
      inclusionPattern: [true],
      offsetFromBorderU: 0.05,
      offsetFromBorderV: 0.05,
      });

    primitives

    • Erstellt eine ebene Fläche aus einer Liste von Eckpunkten und schließt den Umriss vom letzten Punkt zurück zum ersten.

      Die Punkte müssen in einer Ebene liegen.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Fläche

      const face = await bitbybit.occt.shapes.face.createPolygonFace({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10], [0, 0, 10]] });
      
    • Erstellt eine ebene Kreisfläche, eine Scheibe.

      direction ist die Normale ihrer Ebene: der Standard [0, 1, 0] legt sie flach auf den Boden.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Scheibenfläche

      const disc = await bitbybit.occt.shapes.face.createCircleFace({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
      
    • Füllt ein Rechteck auf der Bodenebene mit einem Gitter aus ebenen Sechseckflächen, 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<TopoDSFacePointer[]>

      Eine Fläche pro Sechseck, Reihe für Reihe

      const cells = await bitbybit.occt.shapes.face.hexagonsInGrid({
      width: 20,
      height: 10,
      nrHexagonsInWidth: 8,
      nrHexagonsInHeight: 4,
      flatTop: false,
      scalePatternWidth: [0.9],
      scalePatternHeight: [0.9],
      });
    • Erstellt eine ebene elliptische Fläche.

      direction ist die Normale ihrer Ebene: der Standard [0, 1, 0] legt sie flach auf den Boden. radiusMajor muss mindestens radiusMinor sein.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Ellipsenfläche

      const face = await bitbybit.occt.shapes.face.createEllipseFace({ radiusMinor: 3, radiusMajor: 6, center: [0, 0, 0], direction: [0, 1, 0] });
      
    • Erstellt eine ebene Quadratfläche, zentriert auf center.

      direction ist die Normale ihrer Ebene: der Standard [0, 1, 0] legt sie flach auf den Boden.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Quadratfläche

      const face = await bitbybit.occt.shapes.face.createSquareFace({ size: 10, center: [0, 0, 0], direction: [0, 1, 0] });
      
    • Erstellt eine ebene Rechteckfläche, 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 die Fläche flach auf dem Boden.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Rechteckfläche

      const face = await bitbybit.occt.shapes.face.createRectangleFace({ width: 20, length: 10, center: [0, 0, 0], direction: [0, 1, 0] });
      
    • Erstellt eine ebene L-förmige Fläche: 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. Sie 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<TopoDSFacePointer>

      Die L-förmige Fläche

      const face = await bitbybit.occt.shapes.face.createLPolygonFace({
      widthFirst: 2,
      lengthFirst: 10,
      widthSecond: 2,
      lengthSecond: 6,
      align: Bit.Inputs.OCCT.directionEnum.outside,
      rotation: 0,
      center: [0, 0, 0],
      direction: [0, 1, 0],
      });
    • Erstellt eine ebene sternförmige Fläche mit numRays Zacken.

      Die Zacken reichen bis outerRadius und die Kerben dazwischen bis innerRadius; half behält nur die erste Hälfte der Strahlen. offsetOuterEdges hebt die Strahlspitzen aus der Ebene und ist für den Draht gedacht; eine ebene Fläche braucht es bei 0. Sie 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<TopoDSFacePointer>

      Die Sternfläche

      const star = await bitbybit.occt.shapes.face.createStarFace({ outerRadius: 5, innerRadius: 2, numRays: 5, center: [0, 0, 0], direction: [0, 1, 0], offsetOuterEdges: 0, half: false });
      
    • Erstellt eine ebene Fläche 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 sie aufrecht in der XY-Ebene, Spitze entlang Y; direction ist die Richtung vom Stamm zur Spitze, rotation dreht sie 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<TopoDSFacePointer>

      Die Baumfläche

      const tree = await bitbybit.occt.shapes.face.createChristmasTreeFace({
      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],
      });
    • Erstellt eine ebene Parallelogrammfläche: 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 Normale der Ebene; der Standard [0, 1, 0] legt sie 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<TopoDSFacePointer>

      Die Parallelogrammfläche

      const face = await bitbybit.occt.shapes.face.createParallelogramFace({ width: 10, height: 5, angle: 30, aroundCenter: true, center: [0, 0, 0], direction: [0, 1, 0] });
      
    • Erstellt eine ebene herzförmige Fläche, die ungefähr in ein Quadrat mit sizeApprox passt.

      rotation dreht sie in ihrer Ebene, in Grad. direction ist die Normale der Ebene; der Standard [0, 1, 0] legt sie flach auf den Boden.

      Parameter

      • inputs: Heart2DDto

        Die ungefähre Größe, die Drehung, der Mittelpunkt und die Ebenennormale

      Rückgabewert Promise<TopoDSFacePointer>

      Die Herzfläche

      const heart = await bitbybit.occt.shapes.face.createHeartFace({ sizeApprox: 10, rotation: 0, center: [0, 0, 0], direction: [0, 1, 0] });
      
    • Erstellt eine ebene regelmäßige Polygonfläche mit nrCorners Ecken, alle auf einem Kreis mit radius.

      direction ist die Normale der Ebene; der Standard [0, 1, 0] legt sie flach auf den Boden.

      Parameter

      • inputs: NGonWireDto

        Die Anzahl der Ecken, der Radius, der Mittelpunkt und die Ebenennormale

      Rückgabewert Promise<TopoDSFacePointer>

      Die Polygonfläche

      const hexagon = await bitbybit.occt.shapes.face.createNGonFace({ nrCorners: 6, radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
      

    rebuild

    • Baut die Oberfläche einer Fläche als B-spline der gegebenen U- und V-Grade neu auf.

      Ein niedrigerer Grad glättet die Oberfläche zu einer einfacheren Näherung innerhalb von tolerance; ein höherer ist exakt. keepTrim behält die ursprünglichen Begrenzungsdrähte, was beim Erhöhen zuverlässig ist; andernfalls deckt die Fläche die ganze neue Oberfläche ab. Ein Neuaufbau, der scheitert, ergibt eine null- Fläche.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die neu aufgebaute Fläche

      const smoother = await bitbybit.occt.shapes.face.rebuildFaceDegree({ shape: face, uDegree: 2, vDegree: 2, tolerance: 0.01, keepTrim: true });
      
    • Ändert, wie die UV-Parameter über eine Fläche verlaufen: U und V vertauschen, U umkehren, V umkehren oder eine beliebige Kombination.

      Die Geometrie bleibt gleich; nur die Parameterrichtungen ändern sich, was für jede Methode hier zählt, die in UV arbeitet, etwa subdivideToPoints oder wireAlongParam. Die Fläche wird über die natürlichen Grenzen der Oberfläche neu aufgebaut.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die Fläche mit der geänderten Parametrisierung

      const flipped = await bitbybit.occt.shapes.face.flipFaceUV({ shape: face, swapUV: true, reverseU: false, reverseV: false });
      
    • Parametrisiert eine Fläche neu, sodass gleiche Schritte in U oder V ungefähr gleiche Abstände auf der Oberfläche ergeben.

      Viele Oberflächen drängen ihre Parameter stellenweise zusammen, sodass ein UV-Gitter darüber ungleichmäßig aussieht; dies tastet die Oberfläche an samples Punkten pro Richtung neu ab und passt sie neu an, was subdivideToPoints und seine Geschwister ausgleicht. Die Fläche wird über die neuen Grenzen neu aufgebaut.

      Parameter

      Rückgabewert Promise<TopoDSFacePointer>

      Die neu parametrisierte Fläche

      const even = await bitbybit.occt.shapes.face.normalizeFaceParametrization({ shape: face, normalizeU: true, normalizeV: true, samples: 50, tolerance: 0.001 });