Class OCCTFace

Faces em OpenCascade: pedaços delimitados de uma superfície, planos ou curvos, com um fio de fronteira exterior e fios interiores opcionais que fazem furos. Construa-as a partir de fios ou superfícies, ou como formas planas prontas (círculos, retângulos, estrelas, perfis de viga) que assentam no plano do chão a menos que direction diga o contrário; percorra a sua superfície através de parâmetros UV para obter pontos, normais e grelhas de fios; corte padrões de furos nelas; e meça a área e o centro de massa. U e V são as duas direções de uma superfície, dadas aqui como frações de 0 a 1 do intervalo próprio da face. As faces unem-se aresta a aresta em cascas, que shapes.shell trata.

Index

Constructors

constructor

new OCCTFace(): OCCTFace
Returns OCCTFace

beam profiles

createIBeamProfileFace

createIBeamProfileFace(inputs: IBeamProfileDto): Promise<TopoDSFacePointer>
Cria a secção transversal plana de uma viga em I: dois banzos horizontais unidos por uma alma vertical.

width é a largura do banzo, height a altura total, webThickness e flangeThickness as espessuras das paredes; alignment diz qual ponto da caixa do perfil fica em center, rotation roda-a no seu plano, em graus. Assenta no chão, pronta a extrudir ao longo de Y.
Parameters
- inputs: IBeamProfileDto
  O tamanho do perfil, as duas espessuras, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face do perfil da viga em 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>
Cria a secção transversal plana de uma viga em H: dois banzos verticais unidos por uma alma horizontal, uma viga em I deitada de lado.

width é a largura total, height a altura do banzo, webThickness e flangeThickness as espessuras das paredes; alignment diz qual ponto da caixa do perfil fica em center, rotation roda-a no seu plano, em graus. Assenta no chão.
Parameters
- inputs: HBeamProfileDto
  O tamanho do perfil, as duas espessuras, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face do perfil da viga em 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>
Cria a secção transversal plana de uma viga em T: um banzo horizontal com uma alma vertical pendurada do seu meio.

width é a largura do banzo, height a altura total, webThickness e flangeThickness as espessuras das paredes; alignment diz qual ponto da caixa do perfil fica em center, e rotation roda-a no seu plano, em graus. Assenta plana no chão.
Parameters
- inputs: TBeamProfileDto
  O tamanho do perfil, as duas espessuras, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face do perfil da viga em 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>
Cria a secção transversal plana de uma viga em U, um canal: uma alma com dois banzos de flangeWidth erguidos a partir das suas extremidades.

width e height são o tamanho total, webThickness e flangeThickness as espessuras das paredes; alignment diz qual ponto da caixa do perfil fica em center, rotation roda-a no seu plano, em graus. Assenta plana no chão.
Parameters
- inputs: UBeamProfileDto
  O tamanho do perfil, as espessuras, a largura do banzo, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face do perfil da viga em 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>
Recolhe factos de diagnóstico sobre uma face: o seu tipo de superfície, graus U e V, contagens de pontos de controlo e de nós, se U ou V são fechados, periódicos ou racionais, os limites UV, a área, a planaridade, a orientação e o número de fios e arestas.

Uma face vazia ou nula dá um relatório marcado como inválido.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  A face a inspecionar
Returns Promise<FaceDebugInfo>
O relatório
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[]>
Estende uma grelha de pontos sobre uma face avançando uniformemente pelos seus intervalos U e V.

nrDivisionsU por nrDivisionsV pontos cobrem a face de aresta a aresta, listados fila a fila: todos os valores V para o primeiro U, depois o U seguinte. Os indicadores de remoção retiram a primeira ou a última fila; os indicadores de deslocamento empurram cada ponto meio passo.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  A face, o número de pontos em U e V, e as opções de desvio e remoção
Returns Promise<Point3[]>
Os pontos, linha a linha
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[]>
Desenha fios uniformemente espaçados através de uma face ao longo de uma direção de parâmetro, como as linhas de uma folha pautada.

nrDivisions passos dão mais um fio do que isso, incluindo as linhas de fronteira; removeStart e removeEnd retiram essas, shiftHalfStep move cada fio meio passo. Com isU verdadeiro cada fio fica num U fixo e corre ao longo de V; falso troca os papéis.
Parameters
- inputs: FaceSubdivisionToWiresDto<TopoDSFacePointer>
  A face, o número de divisões, a direção e as opções
Returns Promise<TopoDSWirePointer[]>
Os fios, por ordem ao longo da direção escolhida
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[]>
Estende uma grelha de pontos sobre uma face como subdivideToPoints, mas desloca e remove pontos em cada enésima fila ou coluna, para padrões de tijolo e desfasados.

Cada regra é um par: shiftHalfStepNthU diz de quantas em quantas filas V uma se move meio passo em U, shiftHalfStepUOffsetN onde a contagem começa; as regras de remoção retiram cada enésimo ponto de uma fila de borda.
Parameters
- inputs: FaceSubdivisionControlledDto<TopoDSFacePointer>
  A face, o número de pontos em U e V, e as regras de desvio e remoção de cada n-ésima linha
Returns Promise<Point3[]>
Os pontos, linha a linha
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 a normal da superfície em cada ponto da grelha que subdivideToPoints estenderia sobre uma face, com as mesmas opções e a mesma ordem.

As normais são vetores unitários e seguem a orientação da face, por isso uma face invertida dá-as invertidas. Emparelhe a lista com subdivideToPoints para colocar coisas de pé sobre a superfície.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  A face, o número de pontos em U e V, e as opções de desvio e remoção
Returns Promise<Vector3[]>
As normais unitárias, linha a linha
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 os pares de parâmetros UV da grelha que subdivideToPoints estenderia sobre uma face, com as mesmas opções e a mesma ordem.

Os pares estão nos valores UV reais da face, não em frações.
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  A face, o número de pontos em U e V, e as opções de desvio e remoção
Returns Promise<Point2[]>
Os pares UV, linha a linha
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>
Encontra o ponto numa face nas frações UV dadas.

paramU e paramV vão de 0 a 1 sobre o intervalo U e V da face, por isso 0.5, 0.5 é o meio do intervalo, que numa face aparada nem sempre está dentro da face.
Parameters
- inputs: DataOnUVDto<TopoDSFacePointer>
  A face e as frações U e V
Returns Promise<Point3>
O ponto na superfície
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>
Encontra a normal da superfície de uma face nas frações UV dadas.

paramU e paramV vão de 0 a 1 sobre o intervalo U e V da face. A normal é um vetor unitário e segue a orientação da face, por isso uma face invertida dá-a invertida.
Parameters
- inputs: DataOnUVDto<TopoDSFacePointer>
  A face e as frações U e V
Returns Promise<Vector3>
A normal unitária
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[]>
Encontra os pontos numa face em vários pares de frações UV de uma vez.

Cada par contém U e depois V, ambos de 0 a 1 sobre o intervalo da face.
Parameters
- inputs: DataOnUVsDto<TopoDSFacePointer>
  A face e a lista de pares de frações U e V
Returns Promise<Point3[]>
Um ponto por par, pela mesma ordem
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[]>
Encontra as normais da superfície de uma face em vários pares de frações UV de uma vez.

Cada par contém U e depois V, ambos de 0 a 1 sobre o intervalo da face. As normais são vetores unitários da superfície subjacente; ao contrário de normalOnUV, não são invertidas para uma face invertida.
Parameters
- inputs: DataOnUVsDto<TopoDSFacePointer>
  A face e a lista de pares de frações U e V
Returns Promise<Vector3[]>
Uma normal unitária por par, pela mesma ordem
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 pontos uniformemente espaçados ao longo de uma linha reta através do intervalo UV de uma face.

Com isU verdadeiro a linha fica em param (uma fração de 0 a 1 do intervalo U) e nrPoints pontos distribuem-se por todo o intervalo V; com falso os papéis trocam. removeStartPoint e removeEndPoint retiram as extremidades, e shiftHalfStep move cada ponto meio passo.
Parameters
- inputs: FaceLinearSubdivisionDto<TopoDSFacePointer>
  A face, a direção, a fração ao longo dela, o número de pontos e as opções
Returns Promise<Point3[]>
Os pontos ao longo da linha, por ordem
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>
Desenha um fio através de uma face ao longo de uma linha de parâmetro, seguindo a superfície.

Com isU verdadeiro o fio fica em param (uma fração de 0 a 1 do intervalo U) e corre por todo o intervalo V; com falso os papéis trocam.
Parameters
- inputs: WireAlongParamDto<TopoDSFacePointer>
  A face, a direção e a fração ao longo dela
Returns Promise<TopoDSWirePointer>
O fio na superfície
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[]>
Desenha vários fios através de uma face, um por valor de parâmetro, seguindo a superfície.

Com isU verdadeiro cada fio fica na sua fração do intervalo U e corre por todo o intervalo V; com falso os papéis trocam.
Parameters
- inputs: WiresAlongParamsDto<TopoDSFacePointer>
  A face, a direção e as frações ao longo dela
Returns Promise<TopoDSWirePointer[]>
Um fio por fração, pela mesma ordem
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[]>
Classifica os pontos como dentro de uma face, na sua fronteira ou fora dela, e mantém os grupos escolhidos.

keepIn, keepOn, keepOut e keepUnknown escolhem os grupos; tolerance decide quão perto da fronteira conta como estando nela. Com useBndBox, um ponto fora da caixa delimitadora aumentada por gapTolerance está fora.
Parameters
- inputs: FilterFacePointsDto<TopoDSFacePointer>
  A face, os pontos, a tolerância, o atalho da caixa delimitadora e quais os grupos a manter
Returns Promise<Point3[]>
Os pontos que passaram, pela sua ordem 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[][]>
Executa filterFacePoints contra várias faces com os mesmos pontos e opções.

Por predefinição o resultado contém uma lista por face; com flatPointsArray verdadeiro as listas são unidas numa só, de modo que um ponto em duas faces aparece duas vezes.
Parameters
- inputs: FilterFacesPointsDto<TopoDSFacePointer>
  As faces, os pontos, a tolerância, quais os grupos a manter e se deve aplanar o resultado
Returns Promise<Point3[] | Point3[][]>
Uma lista de pontos por face, ou uma única lista junta
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[]>
Cria uma face por fio, cada uma recortada da superfície de uma face guia de modo a tomar a curvatura dessa superfície.

Os fios têm de assentar na superfície. Com inside verdadeiro cada fio é orientado para que a sua face seja a região que ele delimita; com falso a direção própria do fio decide, e um fio que corra no sentido contrário dá a região exterior.
Parameters
- inputs: FacesFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Os fios, a face guia e qual o lado a manter
Returns Promise<TopoDSFacePointer[]>
Uma face por fio, pela mesma ordem
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>
Cria uma face a partir de um fio que assenta na superfície de uma face guia, de modo que a nova face toma a curvatura dessa superfície.

Com inside verdadeiro o fio é orientado para que a face seja a região que ele delimita; com falso a direção própria do fio decide, e um fio que corra no sentido contrário dá a região fora dele.
Parameters
- inputs: FaceFromWireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  O fio, a face guia e qual o lado a manter
Returns Promise<TopoDSFacePointer>
A nova 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>
Cria uma face delimitada por um fio fechado.

Com planar verdadeiro o fio tem de assentar num só plano e a face é plana; com falso uma superfície suave é ajustada através das arestas do fio, o que preenche um fio que não é plano. Uma forma que não seja um fio lança um erro.
Parameters
- inputs: FaceFromWireDto<TopoDSWirePointer>
  O fio e se a face tem de ser plana
Returns Promise<TopoDSFacePointer>
A nova 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>
Cria uma face a partir de vários fios: o primeiro fio é a fronteira exterior e cada fio seguinte recorta um furo nela.

Com planar verdadeiro os fios têm de assentar num só plano. Os fios dos furos têm de ficar dentro do exterior sem o cruzar nem se cruzarem entre si.
Parameters
- inputs: FaceFromWiresDto<TopoDSWirePointer>
  Os fios, a fronteira exterior primeiro, e se a face tem de ser plana
Returns Promise<TopoDSFacePointer>
A face com furos
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>
Cria uma face a partir de vários fios na superfície de uma face guia: o primeiro fio é a fronteira exterior e cada fio seguinte recorta um furo.

A face toma a curvatura da superfície guia. inside aplica-se ao primeiro fio: verdadeiro orienta-o para que a face seja a região que ele delimita; falso deixa a sua própria direção decidir.
Parameters
- inputs: FaceFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  Os fios, a fronteira exterior primeiro, a face guia e qual o lado a manter
Returns Promise<TopoDSFacePointer>
A face com furos
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[]>
Cria uma face por fio fechado, cada uma como createFaceFromWire faria.

Com planar verdadeiro cada fio tem de assentar num plano; com falso uma superfície suave é ajustada através de cada um.
Parameters
- inputs: FacesFromWiresDto<TopoDSWirePointer>
  Os fios e se as faces têm de ser planas
Returns Promise<TopoDSFacePointer[]>
Uma face por fio, pela mesma ordem
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 com cintas tangentes: para cada par desenha as duas linhas tangentes exteriores e os arcos exteriores entre elas e preenche esse contorno com uma face plana.

combination escolhe os pares: allWithAll cada círculo com todos os outros, inOrder vizinhos na lista, inOrderClosed também o último com o primeiro. unify funde as faces; caso contrário formam um composto.
Parameters
- inputs: FaceFromMultipleCircleTanWiresDto<TopoDSWirePointer>
  Os fios circulares, como emparelhá-los, se deve fundir o resultado e a tolerância
Returns Promise<TopoDSShapePointer>
A forma fundida, ou o composto das faces de correia
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 com cintas tangentes, da maneira como createFaceFromMultipleCircleTanWires une círculos individuais.

allWithAll une cada círculo de uma lista com cada círculo da seguinte; inOrder une círculos na mesma posição em listas vizinhas, que precisam de comprimentos iguais; inOrderClosed também fecha cada lista num anel. unify funde as faces; caso contrário formam um composto.
Parameters
- inputs: FaceFromMultipleCircleTanWireCollectionsDto<TopoDSWirePointer>
  As listas de fios circulares, como emparelhá-los, se deve fundir o resultado e a tolerância
Returns Promise<TopoDSShapePointer>
A forma fundida, ou o composto das faces de correia
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>
Cria uma face que cobre uma superfície inteira, até aos limites naturais da superfície.

tolerance é usada para detetar arestas degeneradas, como o polo de uma esfera. As superfícies vêm de geom.surfaces.
Parameters
- inputs: ShapeWithToleranceDto<GeomSurfacePointer>
  A superfície e a tolerância para arestas degeneradas
Returns Promise<TopoDSFacePointer>
A 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>
Cria uma face cortando uma superfície com um fio que assenta nela.

Com inside verdadeiro o fio é orientado para que a face seja a região que ele delimita; com falso a direção própria do fio decide, e um fio que corra no sentido contrário dá a região fora dele. As superfícies vêm de geom.surfaces.
Parameters
- inputs: FaceFromSurfaceAndWireDto<GeomSurfacePointer, TopoDSWirePointer>
  A superfície, o fio sobre ela e qual o lado a manter
Returns Promise<TopoDSFacePointer>
A 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>
Cria uma face triangular plana a partir de três pontos.
Parameters
- inputs: TriangleBaseDto
  O triângulo como três pontos
Returns Promise<TopoDSFacePointer>
A 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[]>
Cria uma face triangular plana por triângulo de uma malha.

Um triângulo que não possa formar uma face, por exemplo um com pontos repetidos, é saltado com um aviso na consola.
Parameters
- inputs: MeshBaseDto
  A malha como uma lista de triângulos
Returns Promise<TopoDSFacePointer[]>
Uma face por triângulo que foi possível 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>
Escolhe uma face de uma forma pela sua posição, a contar de 0, pela ordem em que o kernel percorre a forma.

A forma tem de ser uma face ou algo construído a partir de faces; um índice para lá da última face lança um erro.
Parameters
- inputs: ShapeIndexDto<TopoDSShapePointer>
  A forma e o índice a começar em 0
Returns Promise<TopoDSFacePointer>
A face nesse í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 todas as faces de uma forma pela ordem em que o kernel a percorre.
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  A forma
Returns Promise<TopoDSFacePointer[]>
As faces encontradas na 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>
Inverte uma face de modo que a sua normal aponta no sentido contrário.

A geometria fica igual; só a orientação muda, o que decide o exterior de uma casca e a direção que normalOnUV reporta.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  A face
Returns Promise<TopoDSFacePointer>
A face 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>
Lê o menor valor do parâmetro U de uma face, nas unidades próprias da superfície.

Junto com getUMaxBound, getVMinBound e getVMaxBound dá o intervalo sobre o qual as frações UV usadas noutros sítios nesta classe são mapeadas.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  A face
Returns Promise<number>
O limite 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>
Lê o maior valor do parâmetro U de uma face, nas unidades próprias da superfície.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  A face
Returns Promise<number>
O limite 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>
Lê o menor valor do parâmetro V de uma face, nas unidades próprias da superfície.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  A face
Returns Promise<number>
O limite 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>
Lê o maior valor do parâmetro V de uma face, nas unidades próprias da superfície.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  A face
Returns Promise<number>
O limite 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>
Mede a área da superfície de uma face, em unidades do modelo quadradas.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  A face
Returns Promise<number>
A á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[]>
Mede a área da superfície de cada face de uma lista, em unidades do modelo quadradas.
Parameters
- inputs: ShapesDto<TopoDSFacePointer>
  As faces
Returns Promise<number[]>
Uma área por face, pela mesma ordem
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>
Encontra o centro de massa de uma face, o ponto em que a sua área se equilibra.

Numa face curva ou em forma de anel este ponto pode ficar fora da superfície.
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  A face
Returns Promise<Point3>
O centro de massa
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[]>
Encontra o centro de massa de cada face de uma lista.
Parameters
- inputs: ShapesDto<TopoDSFacePointer>
  As faces
Returns Promise<Point3[]>
Um ponto por face, pela mesma ordem
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[]>
Estende fios retangulares sobre uma face, um por célula de uma divisão de nrRectanglesU por nrRectanglesV do seu intervalo UV, seguindo a superfície.

Os deslocamentos de borda aparam o intervalo em cada extremidade. Cada retângulo fica centrado na sua célula, dimensionado pelos padrões de escala como uma fração dela; o padrão de arredondamento arredonda os cantos, o padrão de inclusão salta células.
Parameters
- inputs: FaceSubdivideToRectangleWiresDto<TopoDSFacePointer>
  A face, as contagens de células, os deslocamentos da margem e os padrões opcionais
Returns Promise<TopoDSWirePointer[]>
Os fios retangulares, célula a célula
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 uma grelha de furos retangulares numa face e devolve a face perfurada.

Os furos seguem as mesmas células e padrões de subdivideToRectangleWires; quando não é dado nenhum padrão de escala cada furo cobre metade da sua célula. Com holesToFaces verdadeiro o resultado traz também uma face por furo, a seguir à face perfurada, o que é útil para tampas ou enchimentos.
Parameters
- inputs: FaceSubdivideToRectangleHolesDto<TopoDSFacePointer>
  A face, as contagens de células, os deslocamentos da margem, os padrões opcionais e se deve devolver as faces dos furos
Returns Promise<TopoDSFacePointer[]>
A face perfurada, seguida das faces dos furos quando pedidas
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[]>
Estende um favo de mel de fios hexagonais sobre uma face, nrHexagonsU por nrHexagonsV deles ajustados ao seu intervalo UV, cada um seguindo a superfície.

Os deslocamentos de borda aparam uma fração do intervalo em cada extremidade; flatU vira um lado plano para U, os indicadores de extensão esticam as filas exteriores para lá das margens. Os padrões de escala, arredondamento e inclusão repetem-se por hexágono.
Parameters
- inputs: FaceSubdivideToHexagonWiresDto<TopoDSFacePointer>
  A face, as contagens de hexágonos, a orientação, os deslocamentos da margem, os indicadores de extensão e os padrões opcionais
Returns Promise<TopoDSWirePointer[]>
Os fios hexagonais, linha a linha
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 um favo de mel de furos hexagonais numa face e devolve a face perfurada.

Os furos seguem a mesma disposição e padrões de subdivideToHexagonWires; quando não é dado nenhum padrão de escala cada furo tem metade do tamanho do seu hexágono. Com holesToFaces verdadeiro o resultado traz também uma face por furo, a seguir à face perfurada.
Parameters
- inputs: FaceSubdivideToHexagonHolesDto<TopoDSFacePointer>
  A face, as contagens de hexágonos, a orientação, os deslocamentos da margem, os padrões opcionais e se deve devolver as faces dos furos
Returns Promise<TopoDSFacePointer[]>
A face perfurada, seguida das faces dos furos quando pedidas
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>
Cria uma face plana a partir de uma lista de pontos de canto, fechando o contorno do último ponto de volta ao primeiro.

Os pontos têm de assentar num só plano.
Parameters
- inputs: PolygonDto
  Os pontos dos cantos por ordem
Returns Promise<TopoDSFacePointer>
A 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>
Cria uma face circular plana, um disco.

direction é a normal do seu plano: a predefinição [0, 1, 0] deita-o plano no chão.
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  O raio, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face em 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[]>
Preenche um retângulo no plano do chão com uma grelha de faces hexagonais planas, centrada na origem.

Os hexágonos são escalados para que nrHexagonsInWidth caibam ao longo de width e nrHexagonsInHeight ao longo de height. Os padrões de escala, arredondamento e inclusão são lidos hexágono a hexágono e repetem-se; os indicadores de extensão esticam as filas exteriores para lá das margens para cobrir o retângulo.
Parameters
- inputs: HexagonsInGridDto
  O tamanho do retângulo, as contagens de hexágonos, os indicadores de extensão e os padrões opcionais
Returns Promise<TopoDSFacePointer[]>
Uma face por hexágono, linha a linha
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>
Cria uma face elíptica plana.

direction é a normal do seu plano: a predefinição [0, 1, 0] deita-a plana no chão. radiusMajor tem de ser pelo menos radiusMinor.
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  Os dois raios, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face 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>
Cria uma face quadrada plana centrada em center.

direction é a normal do seu plano: a predefinição [0, 1, 0] deita-a plana no chão.
Parameters
- inputs: Bit.Inputs.OCCT.SquareDto
  O comprimento do lado, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face quadrada
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>
Cria uma face retangular plana centrada em center.

No plano do chão width corre ao longo de X e length ao longo de Z; direction é a normal do plano, e a predefinição [0, 1, 0] mantém a face plana no chão.
Parameters
- inputs: Bit.Inputs.OCCT.RectangleDto
  A largura, o comprimento, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face retangular
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>
Cria uma face plana em forma de L: duas pernas retangulares unidas num canto.

A primeira perna tem widthFirst e lengthFirst, a segunda widthSecond e lengthSecond; align coloca o canto no exterior, no interior ou no meio das pernas, e rotation roda a forma no seu plano, em graus. Assenta plana no chão a menos que direction diga o contrário.
Parameters
- inputs: LPolygonDto
  Os dois tamanhos das abas, o alinhamento, a rotação, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face em 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>
Cria uma face plana em forma de estrela com numRays pontas.

As pontas chegam a outerRadius e os entalhes entre elas a innerRadius; half mantém só a primeira metade dos raios. offsetOuterEdges levanta as pontas dos raios para fora do plano e destina-se ao fio; uma face plana precisa dele a 0. Assenta plana no chão a menos que direction diga o contrário.
Parameters
- inputs: Bit.Inputs.OCCT.StarDto
  Os dois raios, o número de pontas, o centro, a normal do plano e as opções
Returns Promise<TopoDSFacePointer>
A face em estrela
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>
Cria uma face plana com a forma de uma árvore de Natal estilizada: nrSkirts camadas de ramos, estreitando de outerDist para innerDist a partir da linha do tronco, sobre um tronco de trunkHeight e trunkWidth.

Ao contrário das outras formas planas aqui, fica de pé no plano XY, com a ponta ao longo de Y; direction é a direção do tronco para a ponta, rotation roda-a em torno desse eixo, em graus.
Parameters
- inputs: ChristmasTreeDto
  As proporções da árvore, o tamanho do tronco, as opções, a origem e a direção do tronco para o topo
Returns Promise<TopoDSFacePointer>
A face em árvore
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>
Cria uma face de paralelogramo plana: um retângulo de width e height cujos lados se inclinam angle graus.

Com aroundCenter verdadeiro a forma é centrada em center; caso contrário parte daí e estende-se nas direções positivas. direction é a normal do plano; a predefinição [0, 1, 0] deita-a plana no chão.
Parameters
- inputs: ParallelogramDto
  A largura, a altura, o ângulo de inclinação, se deve centrá-la, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face em 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>
Cria uma face plana em forma de coração que cabe aproximadamente num quadrado de sizeApprox.

rotation roda-a no seu plano, em graus. direction é a normal do plano; a predefinição [0, 1, 0] deita-a plana no chão.
Parameters
- inputs: Heart2DDto
  O tamanho aproximado, a rotação, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face em coração
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>
Cria uma face de polígono regular plana com nrCorners cantos, todos sobre um círculo de radius.

direction é a normal do plano; a predefinição [0, 1, 0] deita-a plana no chão.
Parameters
- inputs: NGonWireDto
  O número de cantos, o raio, o centro e a normal do plano
Returns Promise<TopoDSFacePointer>
A face 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>
Reconstrói a superfície de uma face como uma B-spline dos graus U e V dados.

Baixar um grau suaviza a superfície numa aproximação mais simples dentro de tolerance; subi-lo é exato. keepTrim mantém os fios de fronteira originais, o que é fiável ao subir; caso contrário a face cobre toda a nova superfície. Uma reconstrução que falhe dá uma face nula.
Parameters
- inputs: RebuildFaceDegreeDto<TopoDSFacePointer>
  A face, os graus U e V pretendidos, a tolerância e se deve manter a fronteira
Returns Promise<TopoDSFacePointer>
A face reconstruída
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>
Altera como os parâmetros UV correm sobre uma face: trocar U e V, inverter U, inverter V, ou qualquer combinação.

A geometria fica igual; só as direções dos parâmetros mudam, o que importa para todos os métodos aqui que trabalham em UV, como subdivideToPoints ou wireAlongParam. A face é reconstruída sobre os limites naturais da superfície.
Parameters
- inputs: FlipFaceUVDto<TopoDSFacePointer>
  A face e quais as inversões a aplicar
Returns Promise<TopoDSFacePointer>
A face com a parametrização alterada
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 uma face para que passos iguais em U ou V deem distâncias aproximadamente iguais na superfície.

Muitas superfícies concentram os seus parâmetros em certos sítios, por isso uma grelha UV sobre elas parece irregular; isto reamostra a superfície em samples pontos por direção e reajusta-a, o que uniformiza subdivideToPoints e os seus irmãos. A face é reconstruída sobre os novos limites.
Parameters
- inputs: NormalizeFaceParametrizationDto<TopoDSFacePointer>
  A face, quais as direções a normalizar, o número de amostras e a tolerância de ajuste
Returns Promise<TopoDSFacePointer>
A face 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