Class OCCTFace

Caras en OpenCascade: trozos acotados de una superficie, planos o curvos, con un alambre de contorno exterior y alambres interiores opcionales que hacen agujeros. Constrúyelas a partir de alambres o superficies, o como formas planas ya hechas (círculos, rectángulos, estrellas, perfiles de viga) que se apoyan en el plano del suelo a menos que direction diga otra cosa; recorre su superficie mediante parámetros UV para obtener puntos, normales y cuadrículas de alambres; corta patrones de agujeros en ellas; y mide el área y el centro de masas. U y V son las dos direcciones de una superficie, dadas aquí como fracciones de 0 a 1 del rango propio de la cara. Las caras se unen arista con arista en carcasas, de las que se ocupa shapes.shell.

Index

Constructors

constructor

new OCCTFace(): OCCTFace
Returns OCCTFace

beam profiles

createIBeamProfileFace

createIBeamProfileFace(inputs: IBeamProfileDto): Promise<TopoDSFacePointer>
Crea la sección transversal plana de una viga en I: dos alas horizontales unidas por un alma vertical.

width es la anchura del ala, height la altura total, webThickness y flangeThickness los grosores de pared; alignment dice qué punto de la caja del perfil se sitúa en center, rotation la gira en su plano, en grados. Está en el suelo, lista para extruir a lo largo de Y.
Parameters
- inputs: IBeamProfileDto
  El tamaño del perfil, los dos espesores, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara de perfil de viga 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>
Crea la sección transversal plana de una viga en H: dos alas verticales unidas por un alma horizontal, una viga en I tumbada.

width es la anchura total, height la altura del ala, webThickness y flangeThickness los grosores de pared; alignment dice qué punto de la caja del perfil se sitúa en center, rotation la gira en su plano, en grados. Está en el suelo.
Parameters
- inputs: HBeamProfileDto
  El tamaño del perfil, los dos espesores, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara de perfil de viga 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>
Crea la sección transversal plana de una viga en T: un ala horizontal con un alma vertical que cuelga de su centro.

width es la anchura del ala, height la altura total, webThickness y flangeThickness los grosores de pared; alignment dice qué punto de la caja del perfil se sitúa en center, y rotation la gira en su plano, en grados. Está tumbada en el suelo.
Parameters
- inputs: TBeamProfileDto
  El tamaño del perfil, los dos espesores, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara de perfil de viga 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>
Crea la sección transversal plana de una viga en U, un canal: un alma con dos alas de flangeWidth levantadas desde sus extremos.

width y height son el tamaño total, webThickness y flangeThickness los grosores de pared; alignment dice qué punto de la caja del perfil se sitúa en center, rotation la gira en su plano, en grados. Está tumbada en el suelo.
Parameters
- inputs: UBeamProfileDto
  El tamaño del perfil, los espesores, la anchura del ala, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara de perfil de viga 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>
Recopila datos de diagnóstico sobre una cara: su tipo de superficie, los grados U y V, el número de puntos de control y de nodos, si U o V están cerrados, son periódicos o racionales, los límites UV, el área, la planaridad, la orientación y el número de alambres y aristas.

Una cara vacía o null da un informe marcado como no válido.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La cara que inspeccionar
Returns Promise<FaceDebugInfo>
El informe
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[]>
Tiende una cuadrícula de puntos sobre una cara avanzando uniformemente por sus rangos U y V.

nrDivisionsU por nrDivisionsV puntos cubren la cara de borde a borde, listados fila a fila: todos los valores V para la primera U, luego la siguiente U. Los indicadores de eliminación descartan la primera o la última fila; los indicadores de desplazamiento empujan cada punto medio paso.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  La cara, el número de puntos en U y V, y las opciones de desplazamiento y eliminación
Returns Promise<Point3[]>
Los puntos, fila por fila
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[]>
Dibuja alambres espaciados uniformemente a través de una cara a lo largo de una dirección de parámetro, como las líneas de una hoja pautada.

nrDivisions pasos dan un alambre más que eso, líneas de contorno incluidas; removeStart y removeEnd las descartan, shiftHalfStep mueve cada alambre medio paso. Con isU en true cada alambre se sitúa en una U fija y recorre V; false intercambia los papeles.
Parameters
- inputs: FaceSubdivisionToWiresDto<TopoDSFacePointer>
  La cara, el número de divisiones, la dirección y las opciones
Returns Promise<TopoDSWirePointer[]>
Los alambres, en orden a lo largo de la dirección elegida
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[]>
Tiende una cuadrícula de puntos sobre una cara como subdivideToPoints, pero desplaza y elimina puntos en cada enésima fila o columna, para patrones de ladrillo y escalonados.

Cada regla es un par: shiftHalfStepNthU dice cada cuántas filas V se mueve medio paso en U, shiftHalfStepUOffsetN dónde empieza el recuento; las reglas de eliminación descartan cada enésimo punto de una fila de borde.
Parameters
- inputs: FaceSubdivisionControlledDto<TopoDSFacePointer>
  La cara, el número de puntos en U y V, y las reglas de desplazamiento y eliminación de cada enésima fila
Returns Promise<Point3[]>
Los puntos, fila por fila
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[]>
Calcula la normal de la superficie en cada punto de la cuadrícula que subdivideToPoints tendería sobre una cara, con las mismas opciones y el mismo orden.

Las normales son vectores unitarios y siguen la orientación de la cara, así que una cara invertida las da invertidas. Empareja la lista con subdivideToPoints para colocar cosas erguidas sobre la superficie.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  La cara, el número de puntos en U y V, y las opciones de desplazamiento y eliminación
Returns Promise<Vector3[]>
Las normales unitarias, fila por fila
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[]>
Lista los pares de parámetros UV de la cuadrícula que subdivideToPoints tendería sobre una cara, con las mismas opciones y el mismo orden.

Los pares están en los valores UV reales de la cara, no en fracciones.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  La cara, el número de puntos en U y V, y las opciones de desplazamiento y eliminación
Returns Promise<Point2[]>
Los pares UV, fila por fila
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>
Encuentra el punto de una cara en las fracciones UV dadas.

paramU y paramV van de 0 a 1 sobre el rango U y V de la cara, así que 0.5, 0.5 es el medio del rango, que en una cara recortada no siempre está dentro de la cara.
Parameters
- inputs: DataOnUVDto<TopoDSFacePointer>
  La cara y las fracciones U y V
Returns Promise<Point3>
El punto en la superficie
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>
Encuentra la normal de la superficie de una cara en las fracciones UV dadas.

paramU y paramV van de 0 a 1 sobre el rango U y V de la cara. La normal es un vector unitario y sigue la orientación de la cara, así que una cara invertida la da invertida.
Parameters
- inputs: DataOnUVDto<TopoDSFacePointer>
  La cara y las fracciones U y V
Returns Promise<Vector3>
La normal unitaria
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[]>
Encuentra los puntos de una cara en varios pares de fracciones UV a la vez.

Cada par contiene U y luego V, ambos de 0 a 1 sobre el rango de la cara.
Parameters
- inputs: DataOnUVsDto<TopoDSFacePointer>
  La cara y la lista de pares de fracciones U y V
Returns Promise<Point3[]>
Un punto por par, en el mismo orden
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[]>
Encuentra las normales de la superficie de una cara en varios pares de fracciones UV a la vez.

Cada par contiene U y luego V, ambos de 0 a 1 sobre el rango de la cara. Las normales son vectores unitarios de la superficie subyacente; a diferencia de normalOnUV, no se invierten para una cara invertida.
Parameters
- inputs: DataOnUVsDto<TopoDSFacePointer>
  La cara y la lista de pares de fracciones U y V
Returns Promise<Vector3[]>
Una normal unitaria por par, en el mismo orden
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[]>
Coloca puntos espaciados uniformemente a lo largo de una línea recta a través del rango UV de una cara.

Con isU en true la línea se sitúa en param (una fracción de 0 a 1 del rango U) y nrPoints puntos se reparten por todo el rango V; con false los papeles se intercambian. removeStartPoint y removeEndPoint descartan los extremos, y shiftHalfStep mueve cada punto medio paso.
Parameters
- inputs: FaceLinearSubdivisionDto<TopoDSFacePointer>
  La cara, la dirección, la fracción a lo largo de ella, el número de puntos y las opciones
Returns Promise<Point3[]>
Los puntos a lo largo de la línea, en orden
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>
Dibuja un alambre a través de una cara a lo largo de una línea de parámetro, siguiendo la superficie.

Con isU en true el alambre se sitúa en param (una fracción de 0 a 1 del rango U) y recorre todo el rango V; con false los papeles se intercambian.
Parameters
- inputs: WireAlongParamDto<TopoDSFacePointer>
  La cara, la dirección y la fracción a lo largo de ella
Returns Promise<TopoDSWirePointer>
El alambre sobre la superficie
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[]>
Dibuja varios alambres a través de una cara, uno por valor de parámetro, siguiendo la superficie.

Con isU en true cada alambre se sitúa en su fracción del rango U y recorre todo el rango V; con false los papeles se intercambian.
Parameters
- inputs: WiresAlongParamsDto<TopoDSFacePointer>
  La cara, la dirección y las fracciones a lo largo de ella
Returns Promise<TopoDSWirePointer[]>
Un alambre por fracción, en el mismo orden
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[]>
Clasifica los puntos como dentro de una cara, en su contorno o fuera de ella, y conserva los grupos elegidos.

keepIn, keepOn, keepOut y keepUnknown eligen los grupos; tolerance decide cuán cerca del contorno cuenta como sobre él. Con useBndBox, un punto fuera de la caja delimitadora ampliada en gapTolerance está fuera.
Parameters
- inputs: FilterFacePointsDto<TopoDSFacePointer>
  La cara, los puntos, la tolerancia, el atajo de la caja delimitadora y qué grupos conservar
Returns Promise<Point3[]>
Los puntos que pasaron, en su orden original
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[][]>
Ejecuta filterFacePoints contra varias caras con los mismos puntos y opciones.

De forma predeterminada el resultado contiene una lista por cara; con flatPointsArray en true las listas se unen en una sola, de modo que un punto sobre dos caras aparece dos veces.
Parameters
- inputs: FilterFacesPointsDto<TopoDSFacePointer>
  Las caras, los puntos, la tolerancia, qué grupos conservar y si aplanar el resultado
Returns Promise<Point3[] | Point3[][]>
Una lista de puntos por cara, o una única lista unida
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[]>
Crea una cara por alambre, cada una recortada de la superficie de una cara guía de modo que toma la curvatura de esa superficie.

Los alambres deben estar sobre la superficie. Con inside en true cada alambre se orienta de modo que su cara es la región que encierra; con false decide la propia dirección del alambre, y un alambre que va en sentido contrario da la región exterior.
Parameters
- inputs: FacesFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Los alambres, la cara guía y qué lado conservar
Returns Promise<TopoDSFacePointer[]>
Una cara por alambre, en el mismo orden
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>
Crea una cara a partir de un alambre que está sobre la superficie de una cara guía, de modo que la cara nueva toma la curvatura de esa superficie.

Con inside en true el alambre se orienta de modo que la cara es la región que encierra; con false decide la propia dirección del alambre, y un alambre que va en sentido contrario da la región fuera de él.
Parameters
- inputs: FaceFromWireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  El alambre, la cara guía y qué lado conservar
Returns Promise<TopoDSFacePointer>
La nueva cara
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>
Crea una cara delimitada por un alambre cerrado.

Con planar en true el alambre debe estar en un mismo plano y la cara es plana; con false se ajusta una superficie suave a través de las aristas del alambre, lo que rellena un alambre que no es plano. Una forma que no es un alambre lanza un error.
Parameters
- inputs: FaceFromWireDto<TopoDSWirePointer>
  El alambre y si la cara debe ser plana
Returns Promise<TopoDSFacePointer>
La nueva cara
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>
Crea una cara a partir de varios alambres: el primer alambre es el contorno exterior y cada alambre adicional recorta un agujero en él.

Con planar en true los alambres deben estar en un mismo plano. Los alambres de agujero deben quedar dentro del exterior sin cruzarlo ni cruzarse entre sí.
Parameters
- inputs: FaceFromWiresDto<TopoDSWirePointer>
  Los alambres, primero el contorno exterior, y si la cara debe ser plana
Returns Promise<TopoDSFacePointer>
La cara con agujeros
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>
Crea una cara a partir de varios alambres sobre la superficie de una cara guía: el primer alambre es el contorno exterior y cada alambre adicional recorta un agujero.

La cara toma la curvatura de la superficie guía. inside se aplica al primer alambre: true lo orienta de modo que la cara es la región que encierra; false deja que decida su propia dirección.
Parameters
- inputs: FaceFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Los alambres, primero el contorno exterior, la cara guía y qué lado conservar
Returns Promise<TopoDSFacePointer>
La cara con agujeros
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[]>
Crea una cara por cada alambre cerrado, cada una como lo haría createFaceFromWire.

Con planar en true cada alambre debe estar en un plano; con false se ajusta una superficie suave a través de cada uno.
Parameters
- inputs: FacesFromWiresDto<TopoDSWirePointer>
  Los alambres y si las caras deben ser planas
Returns Promise<TopoDSFacePointer[]>
Una cara por alambre, en el mismo orden
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>
Une círculos con correas tangentes: para cada par dibuja las dos líneas tangentes exteriores y los arcos exteriores entre ellas y rellena ese contorno con una cara plana.

combination elige los pares: allWithAll cada círculo con todos los demás, inOrder los vecinos en la lista, inOrderClosed también el último con el primero. unify fusiona las caras; en caso contrario forman un compuesto.
Parameters
- inputs: FaceFromMultipleCircleTanWiresDto<TopoDSWirePointer>
  Los alambres circulares, cómo emparejarlos, si fusionar el resultado y la tolerancia
Returns Promise<TopoDSShapePointer>
La forma fusionada, o el compuesto de caras de correa
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>
Une círculos de listas consecutivas con correas tangentes, como createFaceFromMultipleCircleTanWires une círculos individuales.

allWithAll une cada círculo de una lista con cada círculo de la siguiente; inOrder une los círculos en la misma posición de listas vecinas, que necesitan longitudes iguales; inOrderClosed también cierra cada lista en un anillo. unify fusiona las caras; en caso contrario forman un compuesto.
Parameters
- inputs: FaceFromMultipleCircleTanWireCollectionsDto<TopoDSWirePointer>
  Las listas de alambres circulares, cómo emparejarlos, si fusionar el resultado y la tolerancia
Returns Promise<TopoDSShapePointer>
La forma fusionada, o el compuesto de caras de correa
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>
Crea una cara que cubre una superficie entera, hasta los límites naturales de la superficie.

tolerance se usa para detectar aristas degeneradas, como el polo de una esfera. Las superficies vienen de geom.surfaces.
Parameters
- inputs: ShapeWithToleranceDto<GeomSurfacePointer>
  La superficie y la tolerancia para las aristas degeneradas
Returns Promise<TopoDSFacePointer>
La cara
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>
Crea una cara recortando una superficie con un alambre que está sobre ella.

Con inside en true el alambre se orienta de modo que la cara es la región que encierra; con false decide la propia dirección del alambre, y un alambre que va en sentido contrario da la región fuera de él. Las superficies vienen de geom.surfaces.
Parameters
- inputs: FaceFromSurfaceAndWireDto<GeomSurfacePointer, TopoDSWirePointer>
  La superficie, el alambre sobre ella y qué lado conservar
Returns Promise<TopoDSFacePointer>
La cara
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>
Crea una cara triangular plana a partir de tres puntos.
Parameters
- inputs: TriangleBaseDto
  El triángulo como tres puntos
Returns Promise<TopoDSFacePointer>
La cara
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[]>
Crea una cara triangular plana por cada triángulo de una malla.

Un triángulo que no puede formar una cara, por ejemplo uno con puntos repetidos, se salta con un aviso en la consola.
Parameters
- inputs: MeshBaseDto
  La malla como lista de triángulos
Returns Promise<TopoDSFacePointer[]>
Una cara por cada triángulo que se pudo construir
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>
Elige una cara de una forma por su posición, contando desde 0, en el orden en que el núcleo recorre la forma.

La forma debe ser una cara o algo construido a partir de caras; un índice más allá de la última cara lanza un error.
Parameters
- inputs: ShapeIndexDto<TopoDSShapePointer>
  La forma y el índice, empezando en 0
Returns Promise<TopoDSFacePointer>
La cara en ese índice
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[]>
Lista cada cara de una forma en el orden en que la recorre el núcleo.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  La forma
Returns Promise<TopoDSFacePointer[]>
Las caras encontradas en la forma
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>
Invierte una cara de modo que su normal apunta en sentido contrario.

La geometría sigue igual; solo cambia la orientación, que decide el exterior de una carcasa y la dirección que informa normalOnUV.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La cara
Returns Promise<TopoDSFacePointer>
La cara invertida
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>
Lee el valor de parámetro U más pequeño de una cara, en las unidades propias de la superficie.

Junto con getUMaxBound, getVMinBound y getVMaxBound da el rango al que se asignan las fracciones UV usadas en otros sitios de esta clase.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La cara
Returns Promise<number>
El límite inferior de 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>
Lee el valor de parámetro U más grande de una cara, en las unidades propias de la superficie.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La cara
Returns Promise<number>
El límite superior de 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>
Lee el valor de parámetro V más pequeño de una cara, en las unidades propias de la superficie.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La cara
Returns Promise<number>
El límite inferior de 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>
Lee el valor de parámetro V más grande de una cara, en las unidades propias de la superficie.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La cara
Returns Promise<number>
El límite superior de 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>
Mide el área de la superficie de una cara, en unidades del modelo al cuadrado.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La cara
Returns Promise<number>
El área
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[]>
Mide el área de la superficie de cada cara de una lista, en unidades del modelo al cuadrado.
Parameters
- inputs: ShapesDto<TopoDSFacePointer>
  Las caras
Returns Promise<number[]>
Un área por cara, en el mismo orden
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>
Encuentra el centro de masas de una cara, el punto sobre el que se equilibra su área.

En una cara curva o en forma de anillo este punto puede quedar fuera de la superficie.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  La cara
Returns Promise<Point3>
El centro de masas
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[]>
Encuentra el centro de masas de cada cara de una lista.
Parameters
- inputs: ShapesDto<TopoDSFacePointer>
  Las caras
Returns Promise<Point3[]>
Un punto por cara, en el mismo orden
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[]>
Tiende alambres rectangulares sobre una cara, uno por celda de una división nrRectanglesU por nrRectanglesV de su rango UV, siguiendo la superficie.

Los desplazamientos de borde recortan el rango en cada extremo. Cada rectángulo se sitúa centrado en su celda, dimensionado por los patrones de escala como fracción de ella; el patrón de redondeo redondea las esquinas, el patrón de inclusión salta celdas.
Parameters
- inputs: FaceSubdivideToRectangleWiresDto<TopoDSFacePointer>
  La cara, los números de celdas, los desfases del borde y los patrones opcionales
Returns Promise<TopoDSWirePointer[]>
Los alambres rectangulares, celda por celda
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[]>
Recorta una cuadrícula de agujeros rectangulares en una cara y devuelve la cara perforada.

Los agujeros siguen las mismas celdas y patrones que subdivideToRectangleWires; cuando no se da ningún patrón de escala cada agujero cubre la mitad de su celda. Con holesToFaces en true el resultado también lleva una cara por agujero, después de la cara perforada, lo que es práctico para tapas o rellenos.
Parameters
- inputs: FaceSubdivideToRectangleHolesDto<TopoDSFacePointer>
  La cara, los números de celdas, los desfases del borde, los patrones opcionales y si devolver las caras de los agujeros
Returns Promise<TopoDSFacePointer[]>
La cara perforada, seguida de las caras de los agujeros cuando se piden
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[]>
Tiende un panal de alambres hexagonales sobre una cara, nrHexagonsU por nrHexagonsV de ellos ajustados a su rango UV, cada uno siguiendo la superficie.

Los desplazamientos de borde recortan una fracción del rango en cada extremo; flatU orienta un lado plano hacia U, los indicadores de extensión estiran las filas exteriores más allá de los bordes. Los patrones de escala, redondeo e inclusión se repiten por hexágono.
Parameters
- inputs: FaceSubdivideToHexagonWiresDto<TopoDSFacePointer>
  La cara, los números de hexágonos, la orientación, los desfases del borde, los indicadores de extensión y los patrones opcionales
Returns Promise<TopoDSWirePointer[]>
Los alambres hexagonales, fila por fila
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[]>
Recorta un panal de agujeros hexagonales en una cara y devuelve la cara perforada.

Los agujeros siguen la misma disposición y patrones que subdivideToHexagonWires; cuando no se da ningún patrón de escala cada agujero es la mitad del tamaño de su hexágono. Con holesToFaces en true el resultado también lleva una cara por agujero, después de la cara perforada.
Parameters
- inputs: FaceSubdivideToHexagonHolesDto<TopoDSFacePointer>
  La cara, los números de hexágonos, la orientación, los desfases del borde, los patrones opcionales y si devolver las caras de los agujeros
Returns Promise<TopoDSFacePointer[]>
La cara perforada, seguida de las caras de los agujeros cuando se piden
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>
Crea una cara plana a partir de una lista de puntos de esquina, cerrando el contorno del último punto de vuelta al primero.

Los puntos deben estar en un mismo plano.
Parameters
- inputs: PolygonDto
  Los puntos de las esquinas en orden
Returns Promise<TopoDSFacePointer>
La cara
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>
Crea una cara circular plana, un disco.

direction es la normal de su plano: el valor predeterminado [0, 1, 0] lo tumba en el suelo.
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  El radio, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara de disco
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[]>
Rellena un rectángulo en el plano del suelo con una cuadrícula de caras hexagonales planas, centrada en el origen.

Los hexágonos se escalan para que nrHexagonsInWidth quepan a lo ancho de width y nrHexagonsInHeight a lo largo de height. Los patrones de escala, redondeo e inclusión se leen hexágono a hexágono y se repiten; los indicadores de extensión estiran las filas exteriores más allá de los bordes para cubrir el rectángulo.
Parameters
- inputs: HexagonsInGridDto
  El tamaño del rectángulo, los números de hexágonos, los indicadores de extensión y los patrones opcionales
Returns Promise<TopoDSFacePointer[]>
Una cara por hexágono, fila por fila
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>
Crea una cara elíptica plana.

direction es la normal de su plano: el valor predeterminado [0, 1, 0] la tumba en el suelo. radiusMajor debe ser al menos radiusMinor.
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  Los dos radios, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara elíptica
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>
Crea una cara cuadrada plana centrada en center.

direction es la normal de su plano: el valor predeterminado [0, 1, 0] la tumba en el suelo.
Parameters
- inputs: Bit.Inputs.OCCT.SquareDto
  La longitud del lado, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara cuadrada
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>
Crea una cara rectangular plana centrada en center.

En el plano del suelo width va a lo largo de X y length a lo largo de Z; direction es la normal del plano, y el valor predeterminado [0, 1, 0] mantiene la cara tumbada en el suelo.
Parameters
- inputs: Bit.Inputs.OCCT.RectangleDto
  La anchura, la longitud, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara rectangular
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>
Crea una cara plana en forma de L: dos patas rectangulares unidas en una esquina.

La primera pata tiene widthFirst y lengthFirst, la segunda widthSecond y lengthSecond; align pone la esquina en el exterior, el interior o el medio de las patas, y rotation gira la forma en su plano, en grados. Está tumbada en el suelo salvo que direction diga lo contrario.
Parameters
- inputs: LPolygonDto
  Los dos tamaños de las patas, la alineación, la rotación, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara en forma de 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>
Crea una cara plana en forma de estrella con numRays puntas.

Las puntas llegan a outerRadius y las muescas entre ellas a innerRadius; half conserva solo la primera mitad de los rayos. offsetOuterEdges levanta las puntas de los rayos fuera del plano y está pensado para el alambre; una cara plana lo necesita en 0. Está tumbada en el suelo salvo que direction diga lo contrario.
Parameters
- inputs: Bit.Inputs.OCCT.StarDto
  Los dos radios, el número de puntas, el centro, la normal del plano y las opciones
Returns Promise<TopoDSFacePointer>
La cara de estrella
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>
Crea una cara plana con forma de árbol de Navidad estilizado: nrSkirts capas de ramas, que se estrechan de outerDist a innerDist respecto a la línea del tronco, sobre un tronco de trunkHeight y trunkWidth.

A diferencia de las otras formas planas de aquí, se levanta erguida en el plano XY, con la punta a lo largo de Y; direction es la dirección del tronco a la punta, rotation la gira alrededor de ese eje, en grados.
Parameters
- inputs: ChristmasTreeDto
  Las proporciones del árbol, el tamaño del tronco, las opciones, el origen y la dirección del tronco a la punta
Returns Promise<TopoDSFacePointer>
La cara del árbol
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>
Crea una cara de paralelogramo plana: un rectángulo de width y height cuyos lados se inclinan angle grados.

Con aroundCenter en true la forma se centra en center; en caso contrario empieza ahí y se extiende en las direcciones positivas. direction es la normal del plano; el valor predeterminado [0, 1, 0] la tumba en el suelo.
Parameters
- inputs: ParallelogramDto
  La anchura, la altura, el ángulo de inclinación, si centrarla, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara de paralelogramo
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>
Crea una cara plana en forma de corazón que cabe aproximadamente en un cuadrado de sizeApprox.

rotation la gira en su plano, en grados. direction es la normal del plano; el valor predeterminado [0, 1, 0] la tumba en el suelo.
Parameters
- inputs: Heart2DDto
  El tamaño aproximado, la rotación, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara de corazón
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>
Crea una cara de polígono regular plana con nrCorners esquinas, todas sobre un círculo de radius.

direction es la normal del plano; el valor predeterminado [0, 1, 0] la tumba en el suelo.
Parameters
- inputs: NGonWireDto
  El número de esquinas, el radio, el centro y la normal del plano
Returns Promise<TopoDSFacePointer>
La cara poligonal
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>
Reconstruye la superficie de una cara como una B-spline de los grados U y V dados.

Bajar un grado suaviza la superficie en una aproximación más simple dentro de tolerance; subirlo es exacto. keepTrim conserva los alambres de contorno originales, lo que es fiable al subir; en caso contrario la cara cubre toda la superficie nueva. Una reconstrucción que falla da una cara null.
Parameters
- inputs: RebuildFaceDegreeDto<TopoDSFacePointer>
  La cara, los grados objetivo en U y V, la tolerancia y si conservar el contorno
Returns Promise<TopoDSFacePointer>
La cara reconstruida
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>
Cambia cómo recorren los parámetros UV una cara: intercambiar U y V, invertir U, invertir V, o cualquier combinación.

La geometría sigue igual; solo cambian las direcciones de los parámetros, lo que importa para cada método de aquí que trabaja en UV, como subdivideToPoints o wireAlongParam. La cara se reconstruye sobre los límites naturales de la superficie.
Parameters
- inputs: FlipFaceUVDto<TopoDSFacePointer>
  La cara y qué inversiones aplicar
Returns Promise<TopoDSFacePointer>
La cara con la parametrización cambiada
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>
Reparametriza una cara de modo que pasos iguales en U o V den distancias aproximadamente iguales sobre la superficie.

Muchas superficies concentran sus parámetros en algunos sitios, así que una cuadrícula UV sobre ellas parece desigual; esto remuestrea la superficie en samples puntos por dirección y la reajusta, lo que uniformiza subdivideToPoints y sus hermanos. La cara se reconstruye sobre los nuevos límites.
Parameters
- inputs: NormalizeFaceParametrizationDto<TopoDSFacePointer>
  La cara, qué direcciones normalizar, el número de muestras y la tolerancia de ajuste
Returns Promise<TopoDSFacePointer>
La cara reparametrizada
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