Class OCCTOperations

Les opérations de modélisation qui transforment les fils et faces OpenCascade en surfaces et solides et mesurent les formes : lissage à travers des sections, extrusion et révolution, balayage de profils le long de chemins, décalage, épaississement de coques en solides, tranchage et découpage, plus les boîtes englobantes, sphères englobantes et requêtes de point le plus proche. Les distances sont en unités du modèle et les angles en degrés ; chaque opération renvoie une nouvelle forme. Les opérations booléennes se trouvent dans booleans, les arrondis dans fillets.

Constructors

constructor

new OCCTOperations(): OCCTOperations
Returns OCCTOperations

closest pts

closestPointsBetweenTwoShapes

closestPointsBetweenTwoShapes(
inputs: ClosestPointsBetweenTwoShapesDto<TopoDSShapePointer>,
): Promise<Point3[]>
Trouve la paire de points, un sur chaque forme, qui sont les plus proches l'un de l'autre.

La distance entre eux est l'écart entre les formes ; elle vaut 0 quand elles se touchent ou se chevauchent. Lève une erreur quand aucune paire ne peut être trouvée.
Parameters
- inputs: ClosestPointsBetweenTwoShapesDto<TopoDSShapePointer>
  Les deux formes
Returns Promise<Point3[]>
Le point sur la première forme et le point sur la seconde
Example
```
const [onBox, onSphere] = await bitbybit.occt.operations.closestPointsBetweenTwoShapes({ shape1: box, shape2: sphere });
```
- Defined in bitbybit-docs.d.ts:41510

closestPointsOnShapeFromPoints

closestPointsOnShapeFromPoints(
inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>,
): Promise<Point3[]>
Trouve, pour chaque point d'une liste, le point le plus proche sur une forme.

Un point déjà sur la forme se projette sur lui-même. Utile pour accrocher des points sur une surface.
Parameters
- inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>
  La forme et les points
Returns Promise<Point3[]>
Un point sur la forme par point d'entrée, dans le même ordre
Example
```
const snapped = await bitbybit.occt.operations.closestPointsOnShapeFromPoints({ shape: sphere, points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41525

closestPointsOnShapesFromPoints

closestPointsOnShapesFromPoints(
inputs: ClosestPointsOnShapesFromPointsDto<TopoDSShapePointer>,
): Promise<Point3[]>
Trouve le point le plus proche sur chacune de plusieurs formes pour chaque point d'une liste.

Le résultat est une seule liste plate : tous les points pour la première forme, dans l'ordre des points, puis tous les points pour la seconde forme, et ainsi de suite.
Parameters
- inputs: ClosestPointsOnShapesFromPointsDto<TopoDSShapePointer>
  Les formes et les points
Returns Promise<Point3[]>
Les points les plus proches, regroupés forme par forme
Example
```
const snapped = await bitbybit.occt.operations.closestPointsOnShapesFromPoints({ shapes: [box, sphere], points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41541

divisions

splitShapeWithShapes

splitShapeWithShapes(
inputs: SplitDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer[]>
Coupe une forme en morceaux avec d'autres formes, comme un couteau tranche un pain, sans retirer de matière.

Avec nonDestructive vrai, la valeur par défaut, les entrées sont laissées intactes et le résultat contient les morceaux de chaque forme impliquée, découpeurs compris ; avec faux, seuls les morceaux de shape reviennent. localFuzzyTolerance permet à une géométrie qui se touche presque de compter comme se touchant.
Parameters
- inputs: SplitDto<TopoDSShapePointer>
  La forme à découper, les formes avec lesquelles la découper et les options
Returns Promise<TopoDSShapePointer[]>
Les morceaux
Example
```
const pieces = await bitbybit.occt.operations.splitShapeWithShapes({ shape: box, shapes: [cuttingPlane], localFuzzyTolerance: 1e-4, nonDestructive: false });
```
- Defined in bitbybit-docs.d.ts:41751

slice

slice(
inputs: Bit.Inputs.OCCT.SliceDto<TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer>
Coupe un solide en tranches parallèles le long d'une direction, comme un pain, toutes les step unités du modèle du bas de la forme vers le haut.

Chaque tranche est la section plane où un plan de coupe rencontre le solide ; elles reviennent ensemble dans un seul composé. La forme doit être ou contenir des solides, sinon une erreur est levée.
Parameters
- inputs: Bit.Inputs.OCCT.SliceDto<TopoDSShapePointer>
  La forme, la distance entre les tranches et la direction de tranchage
Returns Promise<TopoDSCompoundPointer>
Un composé des faces de section
Example
```
const layers = await bitbybit.occt.operations.slice({ shape: sphere, step: 0.5, direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:41973

sliceInStepPattern

sliceInStepPattern(
inputs: SliceInStepPatternDto<TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer>
Coupe un solide en tranches parallèles comme slice, mais avec un motif répété d'écarts entre elles, tel que 0.1, 0.5, 0.1, 0.5.

Le motif est appliqué du bas de la forme vers le haut et se répète jusqu'à atteindre le sommet.
Parameters
- inputs: SliceInStepPatternDto<TopoDSShapePointer>
  La forme, le motif d'écarts et la direction de tranchage
Returns Promise<TopoDSCompoundPointer>
Un composé des faces de section
Example
```
const layers = await bitbybit.occt.operations.sliceInStepPattern({ shape: sphere, steps: [0.1, 0.5], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:41989

extrusions

extrude

extrude(
inputs: Bit.Inputs.OCCT.ExtrudeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Balaye une forme en ligne droite le long d'un vecteur, dont la longueur est la distance : une face devient un solide, un fil une coque, une arête une face.

La forme elle-même reste au départ de l'extrusion ; le vecteur est en unités du modèle, [0, 10, 0] extrude donc de 10 unités vers le haut.
Parameters
- inputs: Bit.Inputs.OCCT.ExtrudeDto<TopoDSShapePointer>
  La forme et le vecteur de direction, dont la longueur est la distance
Returns Promise<TopoDSShapePointer>
La forme extrudée
Example
```
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] });
```
- Defined in bitbybit-docs.d.ts:41720

extrudeShapes

extrudeShapes(
inputs: ExtrudeShapesDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer[]>
Balaye plusieurs formes le long du même vecteur, comme extrude le fait pour une seule.
Parameters
- inputs: ExtrudeShapesDto<TopoDSShapePointer>
  Les formes et le vecteur de direction, dont la longueur est la distance
Returns Promise<TopoDSShapePointer[]>
Les formes extrudées, dans le même ordre
Example
```
const walls = await bitbybit.occt.operations.extrudeShapes({ shapes: [faceA, faceB], direction: [0, 10, 0] });
```
- Defined in bitbybit-docs.d.ts:41733

rotatedExtrude

rotatedExtrude(
inputs: RotationExtrudeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Extrude une forme plane vers le haut le long de Y de height tout en la tordant de angle degrés autour de l'axe Y, comme une colonne torse.

La forme doit être posée à plat, comme le sont les profils que ce paquet crée. Avec makeSolid vrai, la valeur par défaut, un profil de face donne un solide fermé ; un fil donne une coque torsadée.
Parameters
- inputs: RotationExtrudeDto<TopoDSShapePointer>
  La forme de profil, la hauteur, l'angle de vrille en degrés et s'il faut faire un solide
Returns Promise<TopoDSShapePointer>
L'extrusion vrillée
Example
```
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 });
```
- Defined in bitbybit-docs.d.ts:41787

lofts

loft

loft(inputs: LoftDto<TopoDSWirePointer>): Promise<TopoDSShapePointer>
Construit une surface à travers une série de fils, comme une peau tendue sur des nervures : chaque fil est une section et la surface passe par elles dans l'ordre de la liste.

Les arêtes sont acceptées comme fils à une seule arête. Avec makeSolid vrai et des sections fermées, le résultat est fermé en un solide ; sinon c'est une coque. Les sections se correspondent le mieux avec des nombres d'arêtes égaux.
Parameters
- inputs: LoftDto<TopoDSWirePointer>
  Les fils ou arêtes de section, dans l'ordre, et s'il faut faire un solide
Returns Promise<TopoDSShapePointer>
La coque ou le solide lissé
Example
```
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 });
```
- Defined in bitbybit-docs.d.ts:41464

loftAdvanced

loftAdvanced(
inputs: LoftAdvancedDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
Construit une surface à travers une série de fils comme loft, avec un contrôle sur la façon dont la peau est ajustée.

straight fait des carreaux réglés entre les sections au lieu d'une transition lisse ; closed boucle la surface de la dernière section à la première, et periodic rend cette boucle lisse en rééchantillonnant les sections. startVertex et endVertex ferment les extrémités en points.
Parameters
- inputs: LoftAdvancedDto<TopoDSWirePointer>
  Les fils ou arêtes de section, s'il faut faire un solide, les options de fermeture et de lissage et des points d'extrémité facultatifs
Returns Promise<TopoDSShapePointer>
La coque ou le solide lissé
Example
```
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],
});
```
- Defined in bitbybit-docs.d.ts:41494

measure

distancesToShapeFromPoints

distancesToShapeFromPoints(
inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>,
): Promise<number[]>
Mesure la distance de chaque point d'une liste à une forme, comme la distance en ligne droite au point le plus proche sur elle, en unités du modèle.

La distance est à la surface de la forme, un point à l'intérieur d'un solide rapporte donc quand même sa distance à la peau.
Parameters
- inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>
  La forme et les points
Returns Promise<number[]>
Une distance par point, dans le même ordre
Example
```
const distances = await bitbybit.occt.operations.distancesToShapeFromPoints({ shape: sphere, points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41558

boundingBoxOfShape

boundingBoxOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<BoundingBoxPropsDto>
Calcule la boîte alignée sur les axes qui englobe une forme : ses coins minimum et maximum, son centre et sa taille le long de X, Y et Z.

Sur les formes courbes, la boîte peut être un peu plus grande que la forme elle-même, parce que le noyau borne la géométrie de contrôle plutôt que la surface exacte.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<BoundingBoxPropsDto>
La boîte sous forme de min, max, center et size
Example
```
const box = await bitbybit.occt.operations.boundingBoxOfShape({ shape });
console.log(box.size, box.center);
```
- Defined in bitbybit-docs.d.ts:41576

boundingBoxMinOfShape

boundingBoxMinOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
Lit le coin minimum de la boîte englobante alignée sur les axes d'une forme, le point de plus petits X, Y et Z.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<Point3>
Le coin minimum
Example
```
const min = await bitbybit.occt.operations.boundingBoxMinOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41590

boundingBoxMaxOfShape

boundingBoxMaxOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
Lit le coin maximum de la boîte englobante alignée sur les axes d'une forme, le point de plus grands X, Y et Z.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<Point3>
Le coin maximum
Example
```
const max = await bitbybit.occt.operations.boundingBoxMaxOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41604

boundingBoxCenterOfShape

boundingBoxCenterOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
Lit le centre de la boîte englobante alignée sur les axes d'une forme, à mi-chemin entre ses deux coins.

Ce n'est pas le centre de masse ; shapes.solid.getSolidCenterOfMass et ses semblables donnent celui-ci.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<Point3>
Le centre de la boîte
Example
```
const center = await bitbybit.occt.operations.boundingBoxCenterOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41620

boundingBoxSizeOfShape

boundingBoxSizeOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Vector3>
Lit la taille de la boîte englobante alignée sur les axes d'une forme le long de X, Y et Z, en unités du modèle.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<Vector3>
La largeur, la hauteur et la longueur de la boîte
Example
```
const size = await bitbybit.occt.operations.boundingBoxSizeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41633

boundingBoxShapeOfShape

boundingBoxShapeOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Construit la boîte englobante alignée sur les axes d'une forme sous forme de solide en boîte, pratique pour la dessiner ou l'utiliser dans une opération booléenne.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<TopoDSShapePointer>
Le solide de la boîte
Example
```
const boxSolid = await bitbybit.occt.operations.boundingBoxShapeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41647

boundingSphereOfShape

boundingSphereOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<BoundingSpherePropsDto>
Calcule une sphère qui englobe une forme : elle est centrée sur la boîte englobante et atteint ses coins, elle contient donc toujours la forme mais n'est pas la plus petite sphère possible.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<BoundingSpherePropsDto>
La sphère sous forme de center et radius
Example
```
const sphere = await bitbybit.occt.operations.boundingSphereOfShape({ shape });
console.log(sphere.radius);
```
- Defined in bitbybit-docs.d.ts:41662

boundingSphereCenterOfShape

boundingSphereCenterOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<Point3>
Lit le centre de la sphère englobante d'une forme, qui est le centre de sa boîte englobante.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<Point3>
Le centre de la sphère
Example
```
const center = await bitbybit.occt.operations.boundingSphereCenterOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41675

boundingSphereRadiusOfShape

boundingSphereRadiusOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<number>
Lit le rayon de la sphère englobante d'une forme, la distance du centre de la boîte englobante à son coin, en unités du modèle.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<number>
Le rayon
Example
```
const radius = await bitbybit.occt.operations.boundingSphereRadiusOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41689

boundingSphereShapeOfShape

boundingSphereShapeOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Construit la sphère englobante d'une forme sous forme de solide sphérique.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<TopoDSShapePointer>
Le solide de la sphère
Example
```
const sphereSolid = await bitbybit.occt.operations.boundingSphereShapeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41702

offsets

offset

offset(
inputs: Bit.Inputs.OCCT.OffsetDto<TopoDSShapePointer, TopoDSFacePointer>,
): Promise<TopoDSShapePointer>
Déplace la frontière d'une forme vers l'extérieur, ou vers l'intérieur pour une distance négative, d'une distance fixe : un fil grandit en un contour parallèle, une face ou un solide en un plus grand.

Un fil ou une arête est décalé dans son propre plan, ou sur face quand elle est donnée ; les coins sont arrondis. Une distance de 0 renvoie la forme telle quelle.
Parameters
- inputs: Bit.Inputs.OCCT.OffsetDto<TopoDSShapePointer, TopoDSFacePointer>
  La forme, une face facultative sur laquelle décaler un fil, la distance et la tolérance
Returns Promise<TopoDSShapePointer>
La forme décalée
Example
```
const bigger = await bitbybit.occt.operations.offset({ shape: box, distance: 1, tolerance: 0.1 });
```
- Defined in bitbybit-docs.d.ts:41888

offsetAdv

offsetAdv(
inputs: OffsetAdvancedDto<TopoDSShapePointer, TopoDSFacePointer>,
): Promise<TopoDSShapePointer>
Décale une forme comme offset, avec un choix de la façon dont les coins sont joints : arc les arrondit, intersection prolonge les côtés jusqu'à un coin vif, tangent les garde tangents.

removeIntEdges supprime les arêtes internes que le décalage peut laisser sur un solide.
Parameters
- inputs: OffsetAdvancedDto<TopoDSShapePointer, TopoDSFacePointer>
  La forme, une face facultative sur laquelle décaler un fil, la distance, la tolérance, le type de jonction des coins et s'il faut supprimer les arêtes internes
Returns Promise<TopoDSShapePointer>
La forme décalée
Example
```
const sharper = await bitbybit.occt.operations.offsetAdv({
    shape: rectangleWire,
    distance: 1,
    tolerance: 0.1,
    joinType: Bit.Inputs.OCCT.joinTypeEnum.intersection,
    removeIntEdges: false,
});
```
- Defined in bitbybit-docs.d.ts:41910

makeThickSolidSimple

makeThickSolidSimple(
inputs: ThisckSolidSimpleDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Donne une épaisseur à une face ou une coque, la transformant en une dalle ou une paroi solide de l'offset donné.

Un décalage positif épaissit vers la normale de la surface, un négatif dans l'autre sens. Utilisez-le pour transformer une peau lissée ou balayée en quelque chose d'imprimable.
Parameters
- inputs: ThisckSolidSimpleDto<TopoDSShapePointer>
  La face ou la coque et l'épaisseur
Returns Promise<TopoDSShapePointer>
Le solide épais
Example
```
const wall = await bitbybit.occt.operations.makeThickSolidSimple({ shape: loftedShell, offset: 0.5 });
```
- Defined in bitbybit-docs.d.ts:41927

makeThickSolidByJoin

makeThickSolidByJoin(
inputs: ThickSolidByJoinDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Évide un solide en une coque de l'épaisseur de paroi donnée en retirant les faces listées et en décalant le reste.

Retirer la face du haut d'une boîte, par exemple, donne un gobelet ouvert. offset est l'épaisseur de paroi, négative pour croître vers l'intérieur ; joinType dit comment les parois décalées se rejoignent aux coins, les autres indicateurs vont au constructeur de solides épais du noyau.
Parameters
- inputs: ThickSolidByJoinDto<TopoDSShapePointer>
  Le solide, les faces à supprimer, l'épaisseur de paroi, la tolérance et les options de jonction
Returns Promise<TopoDSShapePointer>
Le solide évidé
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:41956

offset3DWire

offset3DWire(
inputs: Offset3DWireDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
Décale un fil qui ne se trouve pas dans un seul plan, en l'extrudant le long de direction, en épaississant le résultat et en relisant l'arête décalée dessus.

Cela fonctionne le mieux sur des fils lisses ; arrondissez d'abord les coins vifs avec fillets.fillet3DWire. Quand les arêtes décalées ne peuvent pas être jointes en un seul fil, elles reviennent sous forme de liste d'arêtes.
Parameters
- inputs: Offset3DWireDto<TopoDSWirePointer>
  Le fil, la distance de décalage et la direction d'extrusion
Returns Promise<TopoDSWirePointer>
Le fil décalé, ou les arêtes isolées quand elles n'ont pas pu être assemblées
Example
```
const outer = await bitbybit.occt.operations.offset3DWire({ shape: smoothWire, offset: 1, direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:42006

pipeing

pipe

pipe(
inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Balaye une ou plusieurs formes de profil le long d'un fil de chemin et ferme le résultat en un solide.

Les profils doivent être placés sur le chemin ; avec plusieurs profils, le balayage passe progressivement de l'un au suivant en chemin.
Parameters
- inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSShapePointer>
  Le fil de chemin et les formes de profil placées dessus
Returns Promise<TopoDSShapePointer>
Le solide balayé
Example
```
const tube = await bitbybit.occt.operations.pipe({ shape: pathWire, shapes: [profileAtStart] });
```
- Defined in bitbybit-docs.d.ts:41803

pipePolylineWireNGon

pipePolylineWireNGon(
inputs: PipePolygonWireNGonDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
Balaye un polygone régulier le long d'un fil, donnant un tube à nrCorners côtés plats, par exemple une barre hexagonale le long d'un chemin.

Le polygone de radius est placé au début du fil, perpendiculairement à lui. makeSolid donne un solide au lieu d'une coque, trihedronEnum choisit comment le profil tourne le long du chemin, et forceApproxC1 lisse le résultat.
Parameters
- inputs: PipePolygonWireNGonDto<TopoDSWirePointer>
  Le fil de chemin, le rayon et le nombre de coins du polygone, et les options de balayage
Returns Promise<TopoDSShapePointer>
Le solide ou la coque balayé
Example
```
const bar = await bitbybit.occt.operations.pipePolylineWireNGon({
    shape: pathWire,
    radius: 0.5,
    nrCorners: 6,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41828

pipeWiresCylindrical

pipeWiresCylindrical(
inputs: PipeWiresCylindricalDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer[]>
Balaye un cercle le long de chacun de plusieurs fils, comme pipeWireCylindrical le fait pour un seul, tous avec le même rayon et les mêmes options.
Parameters
- inputs: PipeWiresCylindricalDto<TopoDSWirePointer>
  Les fils de chemin, le rayon et les options de balayage
Returns Promise<TopoDSShapePointer[]>
Un tube par fil, dans le même ordre
Example
```
const tubes = await bitbybit.occt.operations.pipeWiresCylindrical({
    shapes: [pathA, pathB],
    radius: 0.5,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41848

pipeWireCylindrical

pipeWireCylindrical(
inputs: PipeWireCylindricalDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
Balaye un cercle le long d'un fil, donnant un tube rond du rayon donné qui suit le chemin.

Le cercle est placé au début du fil, perpendiculairement à lui. makeSolid donne un solide au lieu d'une coque, trihedronEnum choisit comment le profil tourne en suivant le chemin, et forceApproxC1 lisse le résultat.
Parameters
- inputs: PipeWireCylindricalDto<TopoDSWirePointer>
  Le fil de chemin, le rayon et les options de balayage
Returns Promise<TopoDSShapePointer>
Le tube sous forme de solide ou de coque
Example
```
const tube = await bitbybit.occt.operations.pipeWireCylindrical({
    shape: pathWire,
    radius: 0.5,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41871

revolutions

revolve

revolve(
inputs: Bit.Inputs.OCCT.RevolveDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
Fait tourner une forme autour d'un axe passant par l'origine pour balayer une surface ou un solide : une face donne un solide, un fil une coque.

angle est en degrés ; 360 ou plus donne un tour complet. L'axe suit direction : un profil à côté de l'axe Y tourné autour de lui donne un vase. Le profil ne doit pas le croiser.
Parameters
- inputs: Bit.Inputs.OCCT.RevolveDto<TopoDSShapePointer>
  La forme de profil, l'angle en degrés, la direction de l'axe et s'il faut copier la géométrie
Returns Promise<TopoDSShapePointer>
La forme de révolution
Example
```
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 });
```
- Defined in bitbybit-docs.d.ts:41769

Class OCCTOperations

Index

Constructors

closest pts

divisions

extrusions

lofts

measure

offsets

pipeing

revolutions

Constructors

constructor

Returns OCCTOperations

closest pts

closestPointsBetweenTwoShapes

Parameters

Returns Promise<Point3[]>

Example

closestPointsOnShapeFromPoints

Parameters

Returns Promise<Point3[]>

Example

closestPointsOnShapesFromPoints

Parameters

Returns Promise<Point3[]>

Example

divisions

splitShapeWithShapes

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

slice

Parameters

Returns Promise<TopoDSCompoundPointer>

Example

sliceInStepPattern

Parameters

Returns Promise<TopoDSCompoundPointer>

Example

extrusions

extrude

Parameters

Returns Promise<TopoDSShapePointer>

Example

extrudeShapes

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

rotatedExtrude

Parameters

Returns Promise<TopoDSShapePointer>

Example

lofts

loft

Parameters

Returns Promise<TopoDSShapePointer>

Example

loftAdvanced

Parameters

Returns Promise<TopoDSShapePointer>

Example

measure

distancesToShapeFromPoints

Parameters

Returns Promise<number[]>

Example

boundingBoxOfShape

Parameters

Returns Promise<BoundingBoxPropsDto>

Example

boundingBoxMinOfShape

Parameters

Returns Promise<Point3>

Example

boundingBoxMaxOfShape

Parameters

Returns Promise<Point3>

Example

boundingBoxCenterOfShape