Class OCCTFace

Faces dans OpenCascade : des morceaux bornés d'une surface, plans ou courbes, avec un fil de frontière extérieure et des fils intérieurs facultatifs qui font des trous. Construisez-les à partir de fils ou de surfaces, ou comme formes planes prêtes à l'emploi (cercles, rectangles, étoiles, profils de poutres) qui reposent sur le plan du sol sauf si direction dit autrement ; parcourez leur surface par les paramètres UV pour obtenir des points, des normales et des grilles de fils ; découpez-y des motifs de trous ; et mesurez l'aire et le centre de masse. U et V sont les deux directions d'une surface, données ici comme fractions de 0 à 1 de la plage propre à la face. Les faces se joignent arête à arête en coques, que shapes.shell gère.

Index

Constructors

constructor

new OCCTFace(): OCCTFace
Returns OCCTFace

beam profiles

createIBeamProfileFace

createIBeamProfileFace(inputs: IBeamProfileDto): Promise<TopoDSFacePointer>
Crée la section plane d'une poutre en I : deux ailes horizontales jointes par une âme verticale.

width est la largeur des ailes, height la hauteur totale, webThickness et flangeThickness les épaisseurs de paroi ; alignment dit quel point de la boîte du profil se place sur center, rotation la tourne dans son plan, en degrés. Elle est posée sur le sol, prête à extruder le long de Y.
Parameters
- inputs: IBeamProfileDto
  La taille du profil, les deux épaisseurs, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face de profil de poutre en I
Example
```
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] });
```
- Defined in bitbybit-docs.d.ts:43610

createHBeamProfileFace

createHBeamProfileFace(inputs: HBeamProfileDto): Promise<TopoDSFacePointer>
Crée la section plane d'une poutre en H : deux ailes verticales jointes par une âme horizontale, une poutre en I sur le côté.

width est la largeur totale, height la hauteur des ailes, webThickness et flangeThickness les épaisseurs de paroi ; alignment dit quel point de la boîte du profil se place sur center, rotation la tourne dans son plan, en degrés. Elle est posée sur le sol.
Parameters
- inputs: HBeamProfileDto
  La taille du profil, les deux épaisseurs, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face de profil de poutre en H
Example
```
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],
});
```
- Defined in bitbybit-docs.d.ts:43637

createTBeamProfileFace

createTBeamProfileFace(inputs: TBeamProfileDto): Promise<TopoDSFacePointer>
Crée la section plane d'une poutre en T : une aile horizontale avec une âme verticale suspendue à son milieu.

width est la largeur de l'aile, height la hauteur totale, webThickness et flangeThickness les épaisseurs de paroi ; alignment dit quel point de la boîte du profil se place sur center, et rotation la tourne dans son plan, en degrés. Elle est posée à plat sur le sol.
Parameters
- inputs: TBeamProfileDto
  La taille du profil, les deux épaisseurs, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face de profil de poutre en T
Example
```
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],
});
```
- Defined in bitbybit-docs.d.ts:43664

createUBeamProfileFace

createUBeamProfileFace(inputs: UBeamProfileDto): Promise<TopoDSFacePointer>
Crée la section plane d'une poutre en U, un profilé en C : une âme avec deux ailes de flangeWidth dressées à ses extrémités.

width et height sont la taille totale, webThickness et flangeThickness les épaisseurs de paroi ; alignment dit quel point de la boîte du profil se place sur center, rotation la tourne dans son plan, en degrés. Elle est posée à plat sur le sol.
Parameters
- inputs: UBeamProfileDto
  La taille du profil, les épaisseurs, la largeur des ailes, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face de profil de poutre en U
Example
```
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],
});
```
- Defined in bitbybit-docs.d.ts:43692

debug

debugInfo

debugInfo(inputs: ShapeDto<TopoDSFacePointer>): Promise<FaceDebugInfo>
Rassemble des informations de diagnostic sur une face : son type de surface, ses degrés U et V, le nombre de points de contrôle et de nœuds, si U ou V sont fermés, périodiques ou rationnels, les limites UV, l'aire, la planéité, l'orientation et le nombre de fils et d'arêtes.

Une face vide ou null donne un rapport marqué invalide.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La face à inspecter
Returns Promise<FaceDebugInfo>
Le rapport
Example
```
const info = await bitbybit.occt.shapes.face.debugInfo({ shape: face });
console.log(info.type, info.isPlanar, info.area);
```
- Defined in bitbybit-docs.d.ts:43137

extract

subdivideToPoints

subdivideToPoints(
inputs: FaceSubdivisionDto<TopoDSFacePointer>,
): Promise<Point3[]>
Pose une grille de points sur une face en parcourant régulièrement ses plages U et V.

nrDivisionsU par nrDivisionsV points couvrent la face de bord à bord, listés rangée par rangée : toutes les valeurs V pour le premier U, puis le U suivant. Les indicateurs de suppression retirent la première ou la dernière rangée ; les indicateurs de décalage poussent chaque point d'un demi-pas.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  La face, le nombre de points en U et V, et les options de décalage et de suppression
Returns Promise<Point3[]>
Les points, rangée par rangée
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43765

subdivideToWires

subdivideToWires(
inputs: FaceSubdivisionToWiresDto<TopoDSFacePointer>,
): Promise<TopoDSWirePointer[]>
Trace des fils régulièrement espacés à travers une face le long d'une direction de paramètre, comme les lignes d'une feuille réglée.

nrDivisions pas donnent un fil de plus que cela, lignes de bord comprises ; removeStart et removeEnd les retirent, shiftHalfStep déplace chaque fil d'un demi-pas. Avec isU vrai, chaque fil se trouve à un U fixe et traverse V ; faux échange les rôles.
Parameters
- inputs: FaceSubdivisionToWiresDto<TopoDSFacePointer>
  La face, le nombre de divisions, la direction et les options
Returns Promise<TopoDSWirePointer[]>
Les fils, dans l'ordre le long de la direction choisie
Example
```
const lines = await bitbybit.occt.shapes.face.subdivideToWires({ shape: face, nrDivisions: 10, isU: true, shiftHalfStep: false, removeStart: false, removeEnd: false });
```
- Defined in bitbybit-docs.d.ts:43783

subdivideToPointsControlled

subdivideToPointsControlled(
inputs: FaceSubdivisionControlledDto<TopoDSFacePointer>,
): Promise<Point3[]>
Pose une grille de points sur une face comme subdivideToPoints, mais décale et supprime des points sur chaque n-ième rangée ou colonne, pour des motifs en briques et décalés.

Chaque règle est une paire : shiftHalfStepNthU dit toutes les combien de rangées V l'une se décale d'un demi-pas en U, shiftHalfStepUOffsetN où le comptage commence ; les règles de suppression retirent chaque n-ième point d'une rangée de bord.
Parameters
- inputs: FaceSubdivisionControlledDto<TopoDSFacePointer>
  La face, le nombre de points en U et V, et les règles de décalage et de suppression toutes les n rangées
Returns Promise<Point3[]>
Les points, rangée par rangée
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43931

subdivideToNormals

subdivideToNormals(
inputs: FaceSubdivisionDto<TopoDSFacePointer>,
): Promise<Vector3[]>
Calcule la normale de surface en chaque point de la grille que subdivideToPoints poserait sur une face, avec les mêmes options et le même ordre.

Les normales sont des vecteurs unitaires et suivent l'orientation de la face, une face inversée les donne donc retournées. Associez la liste à subdivideToPoints pour placer des choses debout sur la surface.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  La face, le nombre de points en U et V, et les options de décalage et de suppression
Returns Promise<Vector3[]>
Les normales unitaires, rangée par rangée
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43958

subdivideToUV

subdivideToUV(inputs: FaceSubdivisionDto<TopoDSFacePointer>): Promise<Point2[]>
Liste les paires de paramètres UV de la grille que subdivideToPoints poserait sur une face, avec les mêmes options et le même ordre.

Les paires sont dans les vraies valeurs UV de la face, pas en fractions.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  La face, le nombre de points en U et V, et les options de décalage et de suppression
Returns Promise<Point2[]>
Les paires UV, rangée par rangée
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43984

pointOnUV

pointOnUV(inputs: DataOnUVDto<TopoDSFacePointer>): Promise<Point3>
Trouve le point sur une face aux fractions UV données.

paramU et paramV vont de 0 à 1 sur la plage U et V de la face, 0.5, 0.5 est donc le milieu de la plage, qui sur une face limitée n'est pas toujours à l'intérieur de la face.
Parameters
- inputs: DataOnUVDto<TopoDSFacePointer>
  La face et les fractions U et V
Returns Promise<Point3>
Le point sur la surface
Example
```
const middle = await bitbybit.occt.shapes.face.pointOnUV({ shape: face, paramU: 0.5, paramV: 0.5 });
```
- Defined in bitbybit-docs.d.ts:44000

normalOnUV

normalOnUV(inputs: DataOnUVDto<TopoDSFacePointer>): Promise<Vector3>
Trouve la normale de surface d'une face aux fractions UV données.

paramU et paramV vont de 0 à 1 sur la plage U et V de la face. La normale est un vecteur unitaire et suit l'orientation de la face, une face inversée la donne donc retournée.
Parameters
- inputs: DataOnUVDto<TopoDSFacePointer>
  La face et les fractions U et V
Returns Promise<Vector3>
La normale unitaire
Example
```
const normal = await bitbybit.occt.shapes.face.normalOnUV({ shape: face, paramU: 0.5, paramV: 0.5 });
```
- Defined in bitbybit-docs.d.ts:44016

pointsOnUVs

pointsOnUVs(inputs: DataOnUVsDto<TopoDSFacePointer>): Promise<Point3[]>
Trouve les points sur une face à plusieurs paires de fractions UV à la fois.

Chaque paire contient U puis V, tous deux de 0 à 1 sur la plage de la face.
Parameters
- inputs: DataOnUVsDto<TopoDSFacePointer>
  La face et la liste des paires de fractions U et V
Returns Promise<Point3[]>
Un point par paire, dans le même ordre
Example
```
const points = await bitbybit.occt.shapes.face.pointsOnUVs({ shape: face, paramsUV: [[0, 0], [0.5, 0.5], [1, 1]] });
```
- Defined in bitbybit-docs.d.ts:44031

normalsOnUVs

normalsOnUVs(inputs: DataOnUVsDto<TopoDSFacePointer>): Promise<Vector3[]>
Trouve les normales de surface d'une face à plusieurs paires de fractions UV à la fois.

Chaque paire contient U puis V, tous deux de 0 à 1 sur la plage de la face. Les normales sont des vecteurs unitaires de la surface sous-jacente ; contrairement à normalOnUV, elles ne sont pas retournées pour une face inversée.
Parameters
- inputs: DataOnUVsDto<TopoDSFacePointer>
  La face et la liste des paires de fractions U et V
Returns Promise<Vector3[]>
Une normale unitaire par paire, dans le même ordre
Example
```
const normals = await bitbybit.occt.shapes.face.normalsOnUVs({ shape: face, paramsUV: [[0, 0], [0.5, 0.5], [1, 1]] });
```
- Defined in bitbybit-docs.d.ts:44048

subdivideToPointsOnParam

subdivideToPointsOnParam(
inputs: FaceLinearSubdivisionDto<TopoDSFacePointer>,
): Promise<Point3[]>
Place des points régulièrement espacés le long d'une ligne droite à travers la plage UV d'une face.

Avec isU vrai, la ligne se trouve à param (une fraction de 0 à 1 de la plage U) et nrPoints points se répartissent sur toute la plage V ; avec faux, les rôles s'échangent. removeStartPoint et removeEndPoint retirent les extrémités, et shiftHalfStep déplace chaque point d'un demi-pas.
Parameters
- inputs: FaceLinearSubdivisionDto<TopoDSFacePointer>
  La face, la direction, la fraction le long de celle-ci, le nombre de points et les options
Returns Promise<Point3[]>
Les points le long de la ligne, dans l'ordre
Example
```
const midline = await bitbybit.occt.shapes.face.subdivideToPointsOnParam({ shape: face, isU: true, param: 0.5, nrPoints: 10, shiftHalfStep: false, removeStartPoint: false, removeEndPoint: false });
```
- Defined in bitbybit-docs.d.ts:44066

wireAlongParam

wireAlongParam(
inputs: WireAlongParamDto<TopoDSFacePointer>,
): Promise<TopoDSWirePointer>
Trace un fil à travers une face le long d'une ligne de paramètre, en suivant la surface.

Avec isU vrai, le fil se trouve à param (une fraction de 0 à 1 de la plage U) et parcourt toute la plage V ; avec faux, les rôles s'échangent.
Parameters
- inputs: WireAlongParamDto<TopoDSFacePointer>
  La face, la direction et la fraction le long de celle-ci
Returns Promise<TopoDSWirePointer>
Le fil sur la surface
Example
```
const middle = await bitbybit.occt.shapes.face.wireAlongParam({ shape: face, isU: true, param: 0.5 });
```
- Defined in bitbybit-docs.d.ts:44082

wiresAlongParams

wiresAlongParams(
inputs: WiresAlongParamsDto<TopoDSFacePointer>,
): Promise<TopoDSWirePointer[]>
Trace plusieurs fils à travers une face, un par valeur de paramètre, en suivant la surface.

Avec isU vrai, chaque fil se trouve à sa fraction de la plage U et parcourt toute la plage V ; avec faux, les rôles s'échangent.
Parameters
- inputs: WiresAlongParamsDto<TopoDSFacePointer>
  La face, la direction et les fractions le long de celle-ci
Returns Promise<TopoDSWirePointer[]>
Un fil par fraction, dans le même ordre
Example
```
const wires = await bitbybit.occt.shapes.face.wiresAlongParams({ shape: face, isU: false, params: [0.25, 0.5, 0.75] });
```
- Defined in bitbybit-docs.d.ts:44098

filter

filterFacePoints

filterFacePoints(
inputs: FilterFacePointsDto<TopoDSFacePointer>,
): Promise<Point3[]>
Classe les points comme à l'intérieur d'une face, sur sa frontière ou à l'extérieur, et conserve les groupes choisis.

keepIn, keepOn, keepOut et keepUnknown choisissent les groupes ; tolerance décide à quelle distance de la frontière un point compte comme dessus. Avec useBndBox, un point hors de la boîte englobante agrandie de gapTolerance est à l'extérieur.
Parameters
- inputs: FilterFacePointsDto<TopoDSFacePointer>
  La face, les points, la tolérance, le raccourci par boîte englobante et les groupes à conserver
Returns Promise<Point3[]>
Les points retenus, dans leur ordre d'origine
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:44234

filterFacesPoints

filterFacesPoints(
inputs: FilterFacesPointsDto<TopoDSFacePointer>,
): Promise<Point3[] | Point3[][]>
Exécute filterFacePoints contre plusieurs faces avec les mêmes points et options.

Par défaut le résultat contient une liste par face ; avec flatPointsArray vrai, les listes sont réunies en une seule, un point sur deux faces apparaît donc deux fois.
Parameters
- inputs: FilterFacesPointsDto<TopoDSFacePointer>
  Les faces, les points, la tolérance, les groupes à conserver et s'il faut aplatir le résultat
Returns Promise<Point3[] | Point3[][]>
Une liste de points par face, ou une seule liste réunie
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:44261

from

createFacesFromWiresOnFace

createFacesFromWiresOnFace(
inputs: FacesFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>,
): Promise<TopoDSFacePointer[]>
Crée une face par fil, chacune découpée dans la surface d'une face de guidage pour qu'elle prenne la courbure de cette surface.

Les fils doivent se trouver sur la surface. Avec inside vrai, chaque fil est orienté pour que sa face soit la région qu'il enferme ; avec faux, le sens propre du fil décide, et un fil allant dans l'autre sens donne la région extérieure.
Parameters
- inputs: FacesFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Les fils, la face de guidage et le côté à conserver
Returns Promise<TopoDSFacePointer[]>
Une face par fil, dans le même ordre
Example
```
const patches = await bitbybit.occt.shapes.face.createFacesFromWiresOnFace({ wires: circlesOnSphere, face: sphereFace, inside: true });
```
- Defined in bitbybit-docs.d.ts:43186

createFaceFromWireOnFace

createFaceFromWireOnFace(
inputs: FaceFromWireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>,
): Promise<TopoDSFacePointer>
Crée une face à partir d'un fil qui se trouve sur la surface d'une face de guidage, de sorte que la nouvelle face prend la courbure de cette surface.

Avec inside vrai, le fil est orienté pour que la face soit la région qu'il enferme ; avec faux, le sens propre du fil décide, et un fil allant dans l'autre sens donne la région extérieure.
Parameters
- inputs: FaceFromWireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Le fil, la face de guidage et le côté à conserver
Returns Promise<TopoDSFacePointer>
La nouvelle face
Example
```
const patch = await bitbybit.occt.shapes.face.createFaceFromWireOnFace({ wire: circleOnCylinder, face: cylinderFace, inside: true });
```
- Defined in bitbybit-docs.d.ts:43203

createFaceFromWire

createFaceFromWire(
inputs: FaceFromWireDto<TopoDSWirePointer>,
): Promise<TopoDSFacePointer>
Crée une face délimitée par un fil fermé.

Avec planar vrai, le fil doit se trouver dans un seul plan et la face est plane ; avec faux, une surface lisse est ajustée à travers les arêtes du fil, ce qui remplit un fil qui n'est pas plan. Une forme qui n'est pas un fil lève une erreur.
Parameters
- inputs: FaceFromWireDto<TopoDSWirePointer>
  Le fil et si la face doit être plane
Returns Promise<TopoDSFacePointer>
La nouvelle face
Example
```
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 });
```
- Defined in bitbybit-docs.d.ts:43221

createFaceFromWires

createFaceFromWires(
inputs: FaceFromWiresDto<TopoDSWirePointer>,
): Promise<TopoDSFacePointer>
Crée une seule face à partir de plusieurs fils : le premier fil est le bord extérieur et chaque fil suivant y découpe un trou.

Avec planar vrai, les fils doivent se trouver dans un seul plan. Les fils de trous doivent se trouver à l'intérieur du fil extérieur sans le croiser ni se croiser entre eux.
Parameters
- inputs: FaceFromWiresDto<TopoDSWirePointer>
  Les fils, frontière extérieure en premier, et si la face doit être plane
Returns Promise<TopoDSFacePointer>
La face avec des trous
Example
```
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 });
```
- Defined in bitbybit-docs.d.ts:43240

createFaceFromWiresOnFace

createFaceFromWiresOnFace(
inputs: FaceFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>,
): Promise<TopoDSFacePointer>
Crée une seule face à partir de plusieurs fils sur la surface d'une face de guidage : le premier fil est le bord extérieur et chaque fil suivant découpe un trou.

La face prend la courbure de la surface de guidage. inside s'applique au premier fil : vrai l'oriente pour que la face soit la région qu'il enferme ; faux laisse son propre sens décider.
Parameters
- inputs: FaceFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Les fils, frontière extérieure en premier, la face de guidage et le côté à conserver
Returns Promise<TopoDSFacePointer>
La face avec des trous
Example
```
const perforated = await bitbybit.occt.shapes.face.createFaceFromWiresOnFace({ wires: [outerOnCylinder, holeOnCylinder], face: cylinderFace, inside: true });
```
- Defined in bitbybit-docs.d.ts:43257

createFacesFromWires

createFacesFromWires(
inputs: FacesFromWiresDto<TopoDSWirePointer>,
): Promise<TopoDSFacePointer[]>
Crée une face par fil fermé, chacune comme le ferait createFaceFromWire.

Avec planar vrai, chaque fil doit se trouver dans un plan ; avec faux, une surface lisse est ajustée à travers chacun.
Parameters
- inputs: FacesFromWiresDto<TopoDSWirePointer>
  Les fils et si les faces doivent être planes
Returns Promise<TopoDSFacePointer[]>
Une face par fil, dans le même ordre
Example
```
const faces = await bitbybit.occt.shapes.face.createFacesFromWires({ shapes: wires, planar: true });
```
- Defined in bitbybit-docs.d.ts:43273

createFaceFromMultipleCircleTanWires

createFaceFromMultipleCircleTanWires(
inputs: FaceFromMultipleCircleTanWiresDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
Relie des cercles par des courroies tangentes : pour chaque paire, il trace les deux lignes tangentes extérieures et les arcs extérieurs entre elles et remplit ce contour d'une face plane.

combination choisit les paires : allWithAll chaque cercle avec chaque autre, inOrder les voisins dans la liste, inOrderClosed aussi le dernier avec le premier. unify fusionne les faces ; sinon elles forment un composé.
Parameters
- inputs: FaceFromMultipleCircleTanWiresDto<TopoDSWirePointer>
  Les fils circulaires, comment les apparier, s'il faut fusionner le résultat et la tolérance
Returns Promise<TopoDSShapePointer>
La forme fusionnée, ou le composé des faces de courroie
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43299

createFaceFromMultipleCircleTanWireCollections

createFaceFromMultipleCircleTanWireCollections(
inputs: FaceFromMultipleCircleTanWireCollectionsDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
Relie les cercles de listes consécutives par des courroies tangentes, comme createFaceFromMultipleCircleTanWires relie des cercles isolés.

allWithAll relie chaque cercle d'une liste à chaque cercle de la suivante ; inOrder relie les cercles à la même position dans des listes voisines, qui doivent avoir la même longueur ; inOrderClosed ferme aussi chaque liste en anneau. unify fusionne les faces ; sinon elles forment un composé.
Parameters
- inputs: FaceFromMultipleCircleTanWireCollectionsDto<TopoDSWirePointer>
  Les listes de fils circulaires, comment les apparier, s'il faut fusionner le résultat et la tolérance
Returns Promise<TopoDSShapePointer>
La forme fusionnée, ou le composé des faces de courroie
Example
```
const mesh = await bitbybit.occt.shapes.face.createFaceFromMultipleCircleTanWireCollections({
    listsOfCircles: [bottomRow, middleRow, topRow],
    combination: Bit.Inputs.OCCT.combinationCirclesForFaceEnum.inOrderClosed,
    unify: true,
    tolerance: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:43322

faceFromSurface

faceFromSurface(
inputs: ShapeWithToleranceDto<GeomSurfacePointer>,
): Promise<TopoDSFacePointer>
Crée une face qui couvre une surface entière, jusqu'aux limites naturelles de la surface.

tolerance sert à détecter les arêtes dégénérées, comme le pôle d'une sphère. Les surfaces viennent de geom.surfaces.
Parameters
- inputs: ShapeWithToleranceDto<GeomSurfacePointer>
  La surface et la tolérance pour les arêtes dégénérées
Returns Promise<TopoDSFacePointer>
La face
Example
```
const face = await bitbybit.occt.shapes.face.faceFromSurface({ shape: surface, tolerance: 1e-7 });
```
- Defined in bitbybit-docs.d.ts:43338

faceFromSurfaceAndWire

faceFromSurfaceAndWire(
inputs: FaceFromSurfaceAndWireDto<GeomSurfacePointer, TopoDSWirePointer>,
): Promise<TopoDSFacePointer>
Crée une face en découpant une surface avec un fil qui se trouve dessus.

Avec inside vrai, le fil est orienté pour que la face soit la région qu'il enferme ; avec faux, le sens propre du fil décide, et un fil allant dans l'autre sens donne la région extérieure. Les surfaces viennent de geom.surfaces.
Parameters
- inputs: FaceFromSurfaceAndWireDto<GeomSurfacePointer, TopoDSWirePointer>
  La surface, le fil posé dessus et le côté à conserver
Returns Promise<TopoDSFacePointer>
La face
Example
```
const patch = await bitbybit.occt.shapes.face.faceFromSurfaceAndWire({ surface, wire: wireOnSurface, inside: true });
```
- Defined in bitbybit-docs.d.ts:43355

from base

fromBaseTriangle

fromBaseTriangle(inputs: TriangleBaseDto): Promise<TopoDSFacePointer>
Crée une face triangulaire plane à partir de trois points.
Parameters
- inputs: TriangleBaseDto
  Le triangle sous forme de trois points
Returns Promise<TopoDSFacePointer>
La face
Example
```
const face = await bitbybit.occt.shapes.face.fromBaseTriangle({ triangle: [[0, 0, 0], [10, 0, 0], [0, 0, 10]] });
```
- Defined in bitbybit-docs.d.ts:43150

fromBaseMesh

fromBaseMesh(inputs: MeshBaseDto): Promise<TopoDSFacePointer[]>
Crée une face triangulaire plane par triangle d'un maillage.

Un triangle qui ne peut pas former de face, par exemple avec des points répétés, est sauté avec un avertissement dans la console.
Parameters
- inputs: MeshBaseDto
  Le maillage sous forme de liste de triangles
Returns Promise<TopoDSFacePointer[]>
Une face par triangle qui a pu être construit
Example
```
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]]],
});
```
- Defined in bitbybit-docs.d.ts:43168

get

getFace

getFace(inputs: ShapeIndexDto<TopoDSShapePointer>): Promise<TopoDSFacePointer>
Choisit une face d'une forme par sa position, en comptant à partir de 0, dans l'ordre où le noyau parcourt la forme.

La forme doit être une face ou quelque chose construit à partir de faces ; un index au-delà de la dernière face lève une erreur.
Parameters
- inputs: ShapeIndexDto<TopoDSShapePointer>
  La forme et l'index à partir de 0
Returns Promise<TopoDSFacePointer>
La face à cet index
Example
```
const first = await bitbybit.occt.shapes.face.getFace({ shape: box, index: 0 });
```
- Defined in bitbybit-docs.d.ts:43709

getFaces

getFaces(inputs: ShapeDto<TopoDSShapePointer>): Promise<TopoDSFacePointer[]>
Liste chaque face d'une forme dans l'ordre où le noyau la parcourt.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forme
Returns Promise<TopoDSFacePointer[]>
Les faces trouvées dans la forme
Example
```
const faces = await bitbybit.occt.shapes.face.getFaces({ shape: box });
```
- Defined in bitbybit-docs.d.ts:43722

reversedFace

reversedFace(inputs: ShapeDto<TopoDSFacePointer>): Promise<TopoDSFacePointer>
Retourne une face pour que sa normale pointe dans l'autre sens.

La géométrie reste la même ; seule l'orientation change, ce qui décide de l'extérieur d'une coque et de la direction que normalOnUV rapporte.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La face
Returns Promise<TopoDSFacePointer>
La face retournée
Example
```
const flipped = await bitbybit.occt.shapes.face.reversedFace({ shape: face });
```
- Defined in bitbybit-docs.d.ts:43738

getUMinBound

getUMinBound(inputs: ShapeDto<TopoDSFacePointer>): Promise<number>
Lit la plus petite valeur du paramètre U d'une face, dans les unités propres de la surface.

Avec getUMaxBound, getVMinBound et getVMaxBound, elle donne la plage sur laquelle les fractions UV utilisées ailleurs dans cette classe se projettent.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La face
Returns Promise<number>
La borne inférieure en U
Example
```
const uMin = await bitbybit.occt.shapes.face.getUMinBound({ shape: face });
```
- Defined in bitbybit-docs.d.ts:44114

getUMaxBound

getUMaxBound(inputs: ShapeDto<TopoDSFacePointer>): Promise<number>
Lit la plus grande valeur du paramètre U d'une face, dans les unités propres de la surface.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La face
Returns Promise<number>
La borne supérieure en U
Example
```
const uMax = await bitbybit.occt.shapes.face.getUMaxBound({ shape: face });
```
- Defined in bitbybit-docs.d.ts:44127

getVMinBound

getVMinBound(inputs: ShapeDto<TopoDSFacePointer>): Promise<number>
Lit la plus petite valeur du paramètre V d'une face, dans les unités propres de la surface.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La face
Returns Promise<number>
La borne inférieure en V
Example
```
const vMin = await bitbybit.occt.shapes.face.getVMinBound({ shape: face });
```
- Defined in bitbybit-docs.d.ts:44140

getVMaxBound

getVMaxBound(inputs: ShapeDto<TopoDSFacePointer>): Promise<number>
Lit la plus grande valeur du paramètre V d'une face, dans les unités propres de la surface.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La face
Returns Promise<number>
La borne supérieure en V
Example
```
const vMax = await bitbybit.occt.shapes.face.getVMaxBound({ shape: face });
```
- Defined in bitbybit-docs.d.ts:44153

getFaceArea

getFaceArea(inputs: ShapeDto<TopoDSFacePointer>): Promise<number>
Mesure l'aire de la surface d'une face, en unités du modèle au carré.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La face
Returns Promise<number>
L'aire
Example
```
const area = await bitbybit.occt.shapes.face.getFaceArea({ shape: face });
```
- Defined in bitbybit-docs.d.ts:44166

getFacesAreas

getFacesAreas(inputs: ShapesDto<TopoDSFacePointer>): Promise<number[]>
Mesure l'aire de la surface de chaque face d'une liste, en unités du modèle au carré.
Parameters
- inputs: ShapesDto<TopoDSFacePointer>
  Les faces
Returns Promise<number[]>
Une aire par face, dans le même ordre
Example
```
const areas = await bitbybit.occt.shapes.face.getFacesAreas({ shapes: faces });
```
- Defined in bitbybit-docs.d.ts:44179

getFaceCenterOfMass

getFaceCenterOfMass(inputs: ShapeDto<TopoDSFacePointer>): Promise<Point3>
Trouve le centre de masse d'une face, le point sur lequel son aire s'équilibre.

Sur une face courbe ou en anneau, ce point peut se trouver hors de la surface.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La face
Returns Promise<Point3>
Le centre de masse
Example
```
const center = await bitbybit.occt.shapes.face.getFaceCenterOfMass({ shape: face });
```
- Defined in bitbybit-docs.d.ts:44194

getFacesCentersOfMass

getFacesCentersOfMass(inputs: ShapesDto<TopoDSFacePointer>): Promise<Point3[]>
Trouve le centre de masse de chaque face d'une liste.
Parameters
- inputs: ShapesDto<TopoDSFacePointer>
  Les faces
Returns Promise<Point3[]>
Un point par face, dans le même ordre
Example
```
const centers = await bitbybit.occt.shapes.face.getFacesCentersOfMass({ shapes: faces });
```
- Defined in bitbybit-docs.d.ts:44207

patterns

subdivideToRectangleWires

subdivideToRectangleWires(
inputs: FaceSubdivideToRectangleWiresDto<TopoDSFacePointer>,
): Promise<TopoDSWirePointer[]>
Pose des fils rectangulaires sur une face, un par cellule d'une division nrRectanglesU par nrRectanglesV de sa plage UV, en suivant la surface.

Les décalages de bordure réduisent la plage à chaque extrémité. Chaque rectangle est centré dans sa cellule, dimensionné par les motifs d'échelle en fraction de celle-ci ; le motif de congé arrondit les coins, le motif d'inclusion saute des cellules.
Parameters
- inputs: FaceSubdivideToRectangleWiresDto<TopoDSFacePointer>
  La face, les nombres de cellules, les décalages de bordure et les motifs facultatifs
Returns Promise<TopoDSWirePointer[]>
Les fils rectangulaires, cellule par cellule
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43811

subdivideToRectangleHoles

subdivideToRectangleHoles(
inputs: FaceSubdivideToRectangleHolesDto<TopoDSFacePointer>,
): Promise<TopoDSFacePointer[]>
Découpe une grille de trous rectangulaires dans une face et renvoie la face perforée.

Les trous suivent les mêmes cellules et motifs que subdivideToRectangleWires ; quand aucun motif d'échelle n'est donné, chaque trou couvre la moitié de sa cellule. Avec holesToFaces vrai, le résultat porte aussi une face par trou, après la face perforée, ce qui est pratique pour des couvercles ou des bouchons.
Parameters
- inputs: FaceSubdivideToRectangleHolesDto<TopoDSFacePointer>
  La face, les nombres de cellules, les décalages de bordure, les motifs facultatifs et s'il faut renvoyer les faces des trous
Returns Promise<TopoDSFacePointer[]>
La face perforée, suivie des faces des trous si demandées
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43839

subdivideToHexagonWires

subdivideToHexagonWires(
inputs: FaceSubdivideToHexagonWiresDto<TopoDSFacePointer>,
): Promise<TopoDSWirePointer[]>
Pose un nid d'abeilles de fils hexagonaux sur une face, nrHexagonsU par nrHexagonsV d'entre eux ajustés dans sa plage UV, chacun suivant la surface.

Les décalages de bordure réduisent une fraction de la plage à chaque extrémité ; flatU tourne un côté plat vers U, les indicateurs d'extension étirent les rangées extérieures au-delà des bords. Les motifs d'échelle, de congé et d'inclusion se répètent par hexagone.
Parameters
- inputs: FaceSubdivideToHexagonWiresDto<TopoDSFacePointer>
  La face, les nombres d'hexagones, l'orientation, les décalages de bordure, les indicateurs d'extension et les motifs facultatifs
Returns Promise<TopoDSWirePointer[]>
Les fils hexagonaux, rangée par rangée
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43868

subdivideToHexagonHoles

subdivideToHexagonHoles(
inputs: FaceSubdivideToHexagonHolesDto<TopoDSFacePointer>,
): Promise<TopoDSFacePointer[]>
Découpe un nid d'abeilles de trous hexagonaux dans une face et renvoie la face perforée.

Les trous suivent la même disposition et les mêmes motifs que subdivideToHexagonWires ; quand aucun motif d'échelle n'est donné, chaque trou fait la moitié de la taille de son hexagone. Avec holesToFaces vrai, le résultat porte aussi une face par trou, après la face perforée.
Parameters
- inputs: FaceSubdivideToHexagonHolesDto<TopoDSFacePointer>
  La face, les nombres d'hexagones, l'orientation, les décalages de bordure, les motifs facultatifs et s'il faut renvoyer les faces des trous
Returns Promise<TopoDSFacePointer[]>
La face perforée, suivie des faces des trous si demandées
Example
```
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,
});
```
- Defined in bitbybit-docs.d.ts:43897

primitives

createPolygonFace

createPolygonFace(inputs: PolygonDto): Promise<TopoDSFacePointer>
Crée une face plane à partir d'une liste de points de coin, en fermant le contour du dernier point au premier.

Les points doivent se trouver dans un seul plan.
Parameters
- inputs: PolygonDto
  Les points de coin dans l'ordre
Returns Promise<TopoDSFacePointer>
La face
Example
```
const face = await bitbybit.occt.shapes.face.createPolygonFace({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10], [0, 0, 10]] });
```
- Defined in bitbybit-docs.d.ts:43371

createCircleFace

createCircleFace(inputs: Bit.Inputs.OCCT.CircleDto): Promise<TopoDSFacePointer>
Crée une face circulaire plane, un disque.

direction est la normale de son plan : la valeur par défaut [0, 1, 0] la pose à plat sur le sol.
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  Le rayon, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face en disque
Example
```
const disc = await bitbybit.occt.shapes.face.createCircleFace({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:43386

hexagonsInGrid

hexagonsInGrid(inputs: HexagonsInGridDto): Promise<TopoDSFacePointer[]>
Remplit un rectangle sur le plan du sol avec une grille de faces hexagonales planes, centrée sur l'origine.

Les hexagones sont mis à l'échelle pour que nrHexagonsInWidth tiennent sur width et nrHexagonsInHeight sur height. Les motifs d'échelle, de congé et d'inclusion sont lus hexagone par hexagone et se répètent ; les indicateurs d'extension étirent les rangées extérieures au-delà des bords pour couvrir le rectangle.
Parameters
- inputs: HexagonsInGridDto
  La taille du rectangle, les nombres d'hexagones, les indicateurs d'extension et les motifs facultatifs
Returns Promise<TopoDSFacePointer[]>
Une face par hexagone, rangée par rangée
Example
```
const cells = await bitbybit.occt.shapes.face.hexagonsInGrid({
    width: 20,
    height: 10,
    nrHexagonsInWidth: 8,
    nrHexagonsInHeight: 4,
    flatTop: false,
    scalePatternWidth: [0.9],
    scalePatternHeight: [0.9],
});
```
- Defined in bitbybit-docs.d.ts:43412

createEllipseFace

createEllipseFace(
inputs: Bit.Inputs.OCCT.EllipseDto,
): Promise<TopoDSFacePointer>
Crée une face elliptique plane.

direction est la normale de son plan : la valeur par défaut [0, 1, 0] la pose à plat sur le sol. radiusMajor doit valoir au moins radiusMinor.
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  Les deux rayons, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face elliptique
Example
```
const face = await bitbybit.occt.shapes.face.createEllipseFace({ radiusMinor: 3, radiusMajor: 6, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:43428

createSquareFace

createSquareFace(inputs: Bit.Inputs.OCCT.SquareDto): Promise<TopoDSFacePointer>
Crée une face carrée plane centrée sur center.

direction est la normale de son plan : la valeur par défaut [0, 1, 0] la pose à plat sur le sol.
Parameters
- inputs: Bit.Inputs.OCCT.SquareDto
  La longueur du côté, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face carrée
Example
```
const face = await bitbybit.occt.shapes.face.createSquareFace({ size: 10, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:43443

createRectangleFace

createRectangleFace(
inputs: Bit.Inputs.OCCT.RectangleDto,
): Promise<TopoDSFacePointer>
Crée une face rectangulaire plane centrée sur center.

Sur le plan du sol, width suit X et length suit Z ; direction est la normale du plan, et la valeur par défaut [0, 1, 0] garde la face à plat sur le sol.
Parameters
- inputs: Bit.Inputs.OCCT.RectangleDto
  La largeur, la longueur, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face rectangulaire
Example
```
const face = await bitbybit.occt.shapes.face.createRectangleFace({ width: 20, length: 10, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:43459

createLPolygonFace

createLPolygonFace(inputs: LPolygonDto): Promise<TopoDSFacePointer>
Crée une face plane en forme de L : deux branches rectangulaires jointes à un coin.

La première branche a widthFirst et lengthFirst, la seconde widthSecond et lengthSecond ; align place le coin à l'extérieur, à l'intérieur ou au milieu des branches, et rotation tourne la forme dans son plan, en degrés. Elle est posée à plat sur le sol sauf si direction dit autrement.
Parameters
- inputs: LPolygonDto
  Les tailles des deux branches, l'alignement, la rotation, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face en L
Example
```
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],
});
```
- Defined in bitbybit-docs.d.ts:43486

createStarFace

createStarFace(inputs: Bit.Inputs.OCCT.StarDto): Promise<TopoDSFacePointer>
Crée une face plane en forme d'étoile à numRays pointes.

Les pointes atteignent outerRadius et les creux entre elles innerRadius ; half ne garde que la première moitié des rayons. offsetOuterEdges soulève les bouts des rayons hors du plan et est destiné au fil ; une face plane l'exige à 0. Elle est posée à plat sur le sol sauf si direction dit autrement.
Parameters
- inputs: Bit.Inputs.OCCT.StarDto
  Les deux rayons, le nombre de branches, le centre, la normale du plan et les options
Returns Promise<TopoDSFacePointer>
La face en étoile
Example
```
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 });
```
- Defined in bitbybit-docs.d.ts:43504

createChristmasTreeFace

createChristmasTreeFace(inputs: ChristmasTreeDto): Promise<TopoDSFacePointer>
Crée une face plane en forme de sapin de Noël stylisé : nrSkirts couches de branches, se rétrécissant de outerDist à innerDist par rapport à la ligne du tronc, sur un tronc de trunkHeight et trunkWidth.

Contrairement aux autres formes plates d'ici, elle se dresse dans le plan XY, la pointe le long de Y ; direction est la direction du tronc vers la pointe, rotation la fait tourner autour de cet axe, en degrés.
Parameters
- inputs: ChristmasTreeDto
  Les proportions du sapin, la taille du tronc, les options, l'origine et la direction du tronc vers la cime
Returns Promise<TopoDSFacePointer>
La face en sapin
Example
```
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],
});
```
- Defined in bitbybit-docs.d.ts:43533

createParallelogramFace

createParallelogramFace(inputs: ParallelogramDto): Promise<TopoDSFacePointer>
Crée une face de parallélogramme plane : un rectangle de width et height dont les côtés penchent de angle degrés.

Avec aroundCenter vrai, la forme est centrée sur center ; sinon elle y commence et s'étend dans les directions positives. direction est la normale du plan ; la valeur par défaut [0, 1, 0] la pose à plat sur le sol.
Parameters
- inputs: ParallelogramDto
  La largeur, la hauteur, l'angle d'inclinaison, s'il faut la centrer, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face en parallélogramme
Example
```
const face = await bitbybit.occt.shapes.face.createParallelogramFace({ width: 10, height: 5, angle: 30, aroundCenter: true, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:43551

createHeartFace

createHeartFace(inputs: Heart2DDto): Promise<TopoDSFacePointer>
Crée une face plane en forme de cœur qui tient à peu près dans un carré de sizeApprox.

rotation la tourne dans son plan, en degrés. direction est la normale du plan ; la valeur par défaut [0, 1, 0] la pose à plat sur le sol.
Parameters
- inputs: Heart2DDto
  La taille approximative, la rotation, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face en cœur
Example
```
const heart = await bitbybit.occt.shapes.face.createHeartFace({ sizeApprox: 10, rotation: 0, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:43567

createNGonFace

createNGonFace(inputs: NGonWireDto): Promise<TopoDSFacePointer>
Crée une face polygonale régulière plane à nrCorners coins, tous sur un cercle de radius.

direction est la normale du plan ; la valeur par défaut [0, 1, 0] la pose à plat sur le sol.
Parameters
- inputs: NGonWireDto
  Le nombre de coins, le rayon, le centre et la normale du plan
Returns Promise<TopoDSFacePointer>
La face polygonale
Example
```
const hexagon = await bitbybit.occt.shapes.face.createNGonFace({ nrCorners: 6, radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:43582

rebuild

rebuildFaceDegree

rebuildFaceDegree(
inputs: RebuildFaceDegreeDto<TopoDSFacePointer>,
): Promise<TopoDSFacePointer>
Reconstruit la surface d'une face en B-spline des degrés U et V donnés.

Baisser un degré lisse la surface en une approximation plus simple à tolerance près ; l'augmenter est exact. keepTrim garde les fils de bord d'origine, ce qui est fiable en augmentant ; sinon la face couvre toute la nouvelle surface. Une reconstruction qui échoue donne une face null.
Parameters
- inputs: RebuildFaceDegreeDto<TopoDSFacePointer>
  La face, les degrés cibles en U et V, la tolérance et s'il faut conserver la frontière
Returns Promise<TopoDSFacePointer>
La face reconstruite
Example
```
const smoother = await bitbybit.occt.shapes.face.rebuildFaceDegree({ shape: face, uDegree: 2, vDegree: 2, tolerance: 0.01, keepTrim: true });
```
- Defined in bitbybit-docs.d.ts:43084

flipFaceUV

flipFaceUV(inputs: FlipFaceUVDto<TopoDSFacePointer>): Promise<TopoDSFacePointer>
Change la façon dont les paramètres UV parcourent une face : échanger U et V, inverser U, inverser V, ou toute combinaison.

La géométrie reste la même ; seules les directions des paramètres changent, ce qui compte pour chaque méthode d'ici qui travaille en UV, comme subdivideToPoints ou wireAlongParam. La face est reconstruite sur les limites naturelles de la surface.
Parameters
- inputs: FlipFaceUVDto<TopoDSFacePointer>
  La face et les inversions à appliquer
Returns Promise<TopoDSFacePointer>
La face avec la paramétrisation modifiée
Example
```
const flipped = await bitbybit.occt.shapes.face.flipFaceUV({ shape: face, swapUV: true, reverseU: false, reverseV: false });
```
- Defined in bitbybit-docs.d.ts:43102

normalizeFaceParametrization

normalizeFaceParametrization(
inputs: NormalizeFaceParametrizationDto<TopoDSFacePointer>,
): Promise<TopoDSFacePointer>
Reparamétrise une face pour que des pas égaux en U ou V donnent des distances à peu près égales sur la surface.

Beaucoup de surfaces resserrent leurs paramètres par endroits, une grille UV posée dessus paraît donc irrégulière ; ceci rééchantillonne la surface en samples points par direction et la réajuste, ce qui régularise subdivideToPoints et ses semblables. La face est reconstruite sur les nouvelles limites.
Parameters
- inputs: NormalizeFaceParametrizationDto<TopoDSFacePointer>
  La face, les directions à normaliser, le nombre d'échantillons et la tolérance d'ajustement
Returns Promise<TopoDSFacePointer>
La face reparamétrée
Example
```
const even = await bitbybit.occt.shapes.face.normalizeFaceParametrization({ shape: face, normalizeU: true, normalizeV: true, samples: 50, tolerance: 0.001 });
```
- Defined in bitbybit-docs.d.ts:43119

Class OCCTFace

Index

Constructors

beam profiles

debug

extract

filter

from

from base

get

patterns

primitives

rebuild

Constructors

constructor

Returns OCCTFace

beam profiles

createIBeamProfileFace

Parameters

Returns Promise<TopoDSFacePointer>

Example

createHBeamProfileFace

Parameters

Returns Promise<TopoDSFacePointer>

Example

createTBeamProfileFace

Parameters

Returns Promise<TopoDSFacePointer>

Example

createUBeamProfileFace

Parameters

Returns Promise<TopoDSFacePointer>

Example

debug

debugInfo

Parameters

Returns Promise<FaceDebugInfo>

Example

extract

subdivideToPoints

Parameters

Returns Promise<Point3[]>

Example

subdivideToWires

Parameters

Returns Promise<TopoDSWirePointer[]>

Example

subdivideToPointsControlled

Parameters

Returns Promise<Point3[]>

Example

subdivideToNormals

Parameters

Returns Promise<Vector3[]>

Example

subdivideToUV

Parameters

Returns Promise<Point2[]>

Example

pointOnUV

Parameters

Returns Promise<Point3>

Example

normalOnUV

Parameters

Returns Promise<Vector3>

Example

pointsOnUVs

Parameters

Returns Promise<Point3[]>

Example

normalsOnUVs

Parameters

Returns Promise<Vector3[]>

Example

subdivideToPointsOnParam

Parameters

Returns Promise<Point3[]>

Example

wireAlongParam