Class OCCTFace

OpenCascade में फेसेस: सतह के परिबद्ध टुकड़े, समतल या वक्र, एक बाहरी सीमा वायर और छेद बनाने वाले वैकल्पिक आंतरिक वायर के साथ। उन्हें वायर या सतहों से, या तैयार समतल शेप्स (वृत्त, आयत, तारे, बीम प्रोफ़ाइल) के रूप में बनाएँ जो direction के अन्यथा कहने तक ग्राउंड प्लेन पर रहते हैं; पॉइंट, नॉर्मल और वायर के ग्रिड पाने के लिए UV पैरामीटर के माध्यम से उनकी सतह पर चलें; उनमें छेद के पैटर्न काटें; और क्षेत्रफल और द्रव्यमान केंद्र मापें। U और V सतह की दो दिशाएँ हैं, जो यहाँ फेस की अपनी रेंज के 0 से 1 तक के अंशों के रूप में दी गई हैं। फेसेस एज से एज जुड़कर शैल बनते हैं, जिन्हें shapes.shell संभालता है।

Index

Constructors

constructor

new OCCTFace(): OCCTFace
Returns OCCTFace

beam profiles

createIBeamProfileFace

createIBeamProfileFace(inputs: IBeamProfileDto): Promise<TopoDSFacePointer>
I-बीम की समतल अनुप्रस्थ काट बनाता है: ऊर्ध्वाधर वेब से जुड़े दो क्षैतिज फ़्लैंज।

width फ़्लैंज की चौड़ाई है, height कुल ऊँचाई, webThickness और flangeThickness दीवार की मोटाइयाँ; alignment बताता है कि प्रोफ़ाइल के बॉक्स का कौन-सा पॉइंट center पर बैठता है, rotation उसे उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर रहता है, Y के साथ एक्सट्रूड के लिए तैयार।
Parameters
- inputs: IBeamProfileDto
  प्रोफ़ाइल का आकार, दो मोटाइयाँ, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
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>
H-बीम की समतल अनुप्रस्थ काट बनाता है: क्षैतिज वेब से जुड़े दो ऊर्ध्वाधर फ़्लैंज, करवट लिया I-बीम।

width कुल चौड़ाई है, height फ़्लैंज की ऊँचाई, webThickness और flangeThickness दीवार की मोटाइयाँ; alignment बताता है कि प्रोफ़ाइल के बॉक्स का कौन-सा पॉइंट center पर बैठता है, rotation उसे उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर रहता है।
Parameters
- inputs: HBeamProfileDto
  प्रोफ़ाइल का आकार, दो मोटाइयाँ, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
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>
T-बीम की समतल अनुप्रस्थ काट बनाता है: एक क्षैतिज फ़्लैंज जिसके मध्य से ऊर्ध्वाधर वेब लटकता है।

width फ़्लैंज की चौड़ाई है, height कुल ऊँचाई, webThickness और flangeThickness दीवार की मोटाइयाँ; alignment बताता है कि प्रोफ़ाइल के बॉक्स का कौन-सा पॉइंट center पर बैठता है, और rotation उसे उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर सपाट रहता है।
Parameters
- inputs: TBeamProfileDto
  प्रोफ़ाइल का आकार, दो मोटाइयाँ, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
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>
U-बीम, एक चैनल, की समतल अनुप्रस्थ काट बनाता है: एक वेब जिसके सिरों से flangeWidth के दो फ़्लैंज ऊपर खड़े हैं।

width और height कुल आकार हैं, webThickness और flangeThickness दीवार की मोटाइयाँ; alignment बताता है कि प्रोफ़ाइल के बॉक्स का कौन-सा पॉइंट center पर बैठता है, rotation उसे उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर सपाट रहता है।
Parameters
- inputs: UBeamProfileDto
  प्रोफ़ाइल का आकार, मोटाइयाँ, फ़्लैंज की चौड़ाई, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
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>
फेस के बारे में निदान तथ्य इकट्ठा करता है: उसकी सतह का प्रकार, U और V डिग्री, कंट्रोल पॉइंट और नॉट की गिनती, क्या U या V बंद, आवर्ती या रैशनल हैं, UV सीमाएँ, क्षेत्रफल, समतलता, ओरिएंटेशन और वायर व एजेस की संख्या।

खाली या null फेस अमान्य चिह्नित रिपोर्ट देता है।
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  जाँचा जाने वाला फेस
Returns Promise<FaceDebugInfo>
रिपोर्ट
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[]>
फेस की U और V रेंज में समान रूप से चलते हुए उस पर पॉइंट की ग्रिड बिछाता है।

nrDivisionsU गुणा nrDivisionsV पॉइंट फेस को किनारे से किनारे तक ढकते हैं, पंक्ति दर पंक्ति सूचीबद्ध: पहले U के लिए सभी V मान, फिर अगला U। हटाने वाले फ़्लैग पहली या अंतिम पंक्ति हटाते हैं; शिफ़्ट फ़्लैग हर पॉइंट को आधा चरण खिसकाते हैं।
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  फेस, U और V में पॉइंट की संख्या, और शिफ़्ट और हटाने के विकल्प
Returns Promise<Point3[]>
पॉइंट, पंक्ति दर पंक्ति
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[]>
फेस के आर-पार एक पैरामीटर दिशा में समान दूरी पर वायर खींचता है, लाइन वाली शीट की रेखाओं की तरह।

nrDivisions चरण उससे एक अधिक वायर देते हैं, सीमा रेखाएँ शामिल; removeStart और removeEnd उन्हें हटाते हैं, shiftHalfStep हर वायर को आधा चरण खिसकाता है। isU true होने पर हर वायर एक स्थिर U पर बैठकर V के आर-पार चलता है; false भूमिकाएँ बदलता है।
Parameters
- inputs: FaceSubdivisionToWiresDto<TopoDSFacePointer>
  फेस, विभाजनों की संख्या, दिशा और विकल्प
Returns Promise<TopoDSWirePointer[]>
वायर, चुनी गई दिशा के साथ क्रम में
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[]>
subdivideToPoints की तरह फेस पर पॉइंट की ग्रिड बिछाता है, पर हर nवीं पंक्ति या कॉलम के पॉइंट खिसकाता और हटाता है, ईंट जैसे और क्रमविचलित पैटर्न के लिए।

हर नियम एक युग्म है: shiftHalfStepNthU बताता है कि हर कितनीवीं V पंक्ति U में आधा चरण खिसकती है, shiftHalfStepUOffsetN कि गिनती कहाँ से शुरू होती है; हटाने के नियम एज पंक्ति का हर nवाँ पॉइंट हटाते हैं।
Parameters
- inputs: FaceSubdivisionControlledDto<TopoDSFacePointer>
  फेस, U और V में पॉइंट की संख्या, और हर n-वीं पंक्ति के शिफ़्ट और हटाने के नियम
Returns Promise<Point3[]>
पॉइंट, पंक्ति दर पंक्ति
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[]>
उस ग्रिड के हर पॉइंट पर सतह का नॉर्मल निकालता है जो subdivideToPoints फेस पर बिछाता, उन्हीं विकल्पों और उसी क्रम के साथ।

नॉर्मल इकाई वेक्टर हैं और फेस के ओरिएंटेशन का अनुसरण करते हैं, इसलिए उल्टा फेस उन्हें पलटा हुआ देता है। सतह पर खड़ी चीज़ें रखने के लिए सूची को subdivideToPoints के साथ जोड़ें।
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  फेस, U और V में पॉइंट की संख्या, और शिफ़्ट और हटाने के विकल्प
Returns Promise<Vector3[]>
इकाई नॉर्मल, पंक्ति दर पंक्ति
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[]>
उस ग्रिड के UV पैरामीटर युग्म सूचीबद्ध करता है जो subdivideToPoints फेस पर बिछाता, उन्हीं विकल्पों और उसी क्रम के साथ।

युग्म फेस के वास्तविक UV मानों में हैं, अंशों में नहीं।
Parameters
- inputs: FaceSubdivisionDto<TopoDSFacePointer>
  फेस, U और V में पॉइंट की संख्या, और शिफ़्ट और हटाने के विकल्प
Returns Promise<Point2[]>
UV जोड़े, पंक्ति दर पंक्ति
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>
दिए गए UV अंशों पर फेस का पॉइंट खोजता है।

paramU और paramV फेस की U और V रेंज पर 0 से 1 तक चलते हैं, इसलिए 0.5, 0.5 रेंज का मध्य है, जो ट्रिम किए फेस पर हमेशा फेस के भीतर नहीं होता।
Parameters
- inputs: DataOnUVDto<TopoDSFacePointer>
  फेस और U और V अंश
Returns Promise<Point3>
सतह पर स्थित पॉइंट
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>
दिए गए UV अंशों पर फेस की सतह का नॉर्मल खोजता है।

paramU और paramV फेस की U और V रेंज पर 0 से 1 तक चलते हैं। नॉर्मल इकाई वेक्टर है और फेस के ओरिएंटेशन का अनुसरण करता है, इसलिए उल्टा फेस उसे पलटा हुआ देता है।
Parameters
- inputs: DataOnUVDto<TopoDSFacePointer>
  फेस और U और V अंश
Returns Promise<Vector3>
इकाई नॉर्मल
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[]>
कई UV अंश युग्मों पर फेस के पॉइंट एक साथ खोजता है।

हर युग्म में U फिर V है, दोनों फेस की रेंज पर 0 से 1 तक।
Parameters
- inputs: DataOnUVsDto<TopoDSFacePointer>
  फेस और U और V अंश जोड़ों की सूची
Returns Promise<Point3[]>
प्रत्येक जोड़े के लिए एक पॉइंट, उसी क्रम में
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[]>
कई UV अंश युग्मों पर फेस की सतह के नॉर्मल एक साथ खोजता है।

हर युग्म में U फिर V है, दोनों फेस की रेंज पर 0 से 1 तक। नॉर्मल अंतर्निहित सतह के इकाई वेक्टर हैं; normalOnUV के विपरीत, वे उल्टे फेस के लिए पलटे नहीं जाते।
Parameters
- inputs: DataOnUVsDto<TopoDSFacePointer>
  फेस और U और V अंश जोड़ों की सूची
Returns Promise<Vector3[]>
प्रत्येक जोड़े के लिए एक इकाई नॉर्मल, उसी क्रम में
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[]>
फेस की UV रेंज के आर-पार एक सीधी रेखा के साथ समान दूरी पर पॉइंट रखता है।

isU true होने पर रेखा param (U रेंज का 0 से 1 तक का अंश) पर बैठती है और nrPoints पॉइंट पूरी V रेंज पर फैलते हैं; false होने पर भूमिकाएँ बदल जाती हैं। removeStartPoint और removeEndPoint सिरे हटाते हैं, और shiftHalfStep हर पॉइंट को आधा चरण खिसकाता है।
Parameters
- inputs: FaceLinearSubdivisionDto<TopoDSFacePointer>
  फेस, दिशा, उसके साथ का अंश, पॉइंट की संख्या और विकल्प
Returns Promise<Point3[]>
लाइन के साथ के पॉइंट, क्रम में
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>
फेस के आर-पार एक पैरामीटर रेखा के साथ एक वायर खींचता है, सतह का अनुसरण करते हुए।

isU true होने पर वायर param (U रेंज का 0 से 1 तक का अंश) पर बैठकर पूरी V रेंज पर चलता है; false होने पर भूमिकाएँ बदल जाती हैं।
Parameters
- inputs: WireAlongParamDto<TopoDSFacePointer>
  फेस, दिशा और उसके साथ का अंश
Returns Promise<TopoDSWirePointer>
सतह पर वायर
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[]>
फेस के आर-पार कई वायर खींचता है, प्रति पैरामीटर मान एक, सतह का अनुसरण करते हुए।

isU true होने पर हर वायर U रेंज के अपने अंश पर बैठकर पूरी V रेंज पर चलता है; false होने पर भूमिकाएँ बदल जाती हैं।
Parameters
- inputs: WiresAlongParamsDto<TopoDSFacePointer>
  फेस, दिशा और उसके साथ के अंश
Returns Promise<TopoDSWirePointer[]>
प्रत्येक अंश के लिए एक वायर, उसी क्रम में
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[]>
पॉइंट को फेस के भीतर, उसकी सीमा पर या उसके बाहर के रूप में छाँटता है, और चुने हुए समूह रखता है।

keepIn, keepOn, keepOut और keepUnknown समूह चुनते हैं; tolerance तय करता है कि सीमा के कितने निकट होना उस पर गिना जाए। useBndBox के साथ, gapTolerance से बढ़ाए गए बाउंडिंग बॉक्स के बाहर का पॉइंट बाहर है।
Parameters
- inputs: FilterFacePointsDto<TopoDSFacePointer>
  फेस, पॉइंट, टॉलरेंस, बाउंडिंग-बॉक्स शॉर्टकट और कौन-से समूह रखने हैं
Returns Promise<Point3[]>
पास हुए पॉइंट, अपने मूल क्रम में
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[][]>
कई फेसेस के विरुद्ध उन्हीं पॉइंट और विकल्पों के साथ filterFacePoints चलाता है।

डिफ़ॉल्ट रूप से परिणाम में प्रति फेस एक सूची होती है; flatPointsArray true होने पर सूचियाँ एक में जोड़ दी जाती हैं, इसलिए दो फेसेस पर स्थित पॉइंट दो बार दिखता है।
Parameters
- inputs: FilterFacesPointsDto<TopoDSFacePointer>
  फेसेस, पॉइंट, टॉलरेंस, कौन-से समूह रखने हैं और क्या परिणाम को समतल करना है
Returns Promise<Point3[] | Point3[][]>
प्रत्येक फेस के लिए पॉइंट की एक सूची, या एक ही जुड़ी हुई सूची
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[]>
प्रति वायर एक फेस बनाता है, हर एक मार्गदर्शक फेस की सतह से काटा गया ताकि वह उस सतह की वक्रता ले।

वायर सतह पर होने चाहिए। inside true होने पर हर वायर को इस तरह घुमाया जाता है कि उसका फेस उसके घेरे का क्षेत्र हो; false होने पर वायर की अपनी दिशा तय करती है, और दूसरी दिशा में चलने वाला वायर बाहरी क्षेत्र देता है।
Parameters
- inputs: FacesFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  वायर, मार्गदर्शक फेस और कौन-सा पक्ष रखना है
Returns Promise<TopoDSFacePointer[]>
प्रत्येक वायर के लिए एक फेस, उसी क्रम में
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>
मार्गदर्शक फेस की सतह पर स्थित वायर से फेस बनाता है, ताकि नया फेस उस सतह की वक्रता ले।

inside true होने पर वायर को इस तरह घुमाया जाता है कि फेस उसके घेरे का क्षेत्र हो; false होने पर वायर की अपनी दिशा तय करती है, और दूसरी दिशा में चलने वाला वायर उसके बाहर का क्षेत्र देता है।
Parameters
- inputs: FaceFromWireOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  वायर, मार्गदर्शक फेस और कौन-सा पक्ष रखना है
Returns Promise<TopoDSFacePointer>
नया फेस
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>
बंद वायर से घिरा फेस बनाता है।

planar true होने पर वायर एक प्लेन में होना चाहिए और फेस समतल होता है; false होने पर वायर के एजेस से होकर चिकनी सतह फ़िट की जाती है, जो सपाट न होने वाले वायर को भरती है। जो शेप वायर नहीं है वह त्रुटि फेंकता है।
Parameters
- inputs: FaceFromWireDto<TopoDSWirePointer>
  वायर और क्या फेस का समतल होना आवश्यक है
Returns Promise<TopoDSFacePointer>
नया फेस
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>
कई वायर से एक फेस बनाता है: पहला वायर बाहरी सीमा है और हर आगे का वायर उसमें छेद काटता है।

planar true होने पर वायर एक प्लेन में होने चाहिए। छेद के वायर बाहरी वायर के भीतर उसे या एक-दूसरे को काटे बिना बैठने चाहिए।
Parameters
- inputs: FaceFromWiresDto<TopoDSWirePointer>
  वायर, पहले बाहरी सीमा, और क्या फेस का समतल होना आवश्यक है
Returns Promise<TopoDSFacePointer>
छेदों वाला फेस
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>
मार्गदर्शक फेस की सतह पर कई वायर से एक फेस बनाता है: पहला वायर बाहरी सीमा है और हर आगे का वायर छेद काटता है।

फेस मार्गदर्शक सतह की वक्रता लेता है। inside पहले वायर पर लागू होता है: true उसे इस तरह घुमाता है कि फेस उसके घेरे का क्षेत्र हो; false उसकी अपनी दिशा को तय करने देता है।
Parameters
- inputs: FaceFromWiresOnFaceDto<TopoDSWirePointer, TopoDSFacePointer>
  वायर, पहले बाहरी सीमा, मार्गदर्शक फेस और कौन-सा पक्ष रखना है
Returns Promise<TopoDSFacePointer>
छेदों वाला फेस
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[]>
प्रति बंद वायर एक फेस बनाता है, हर एक जैसा createFaceFromWire बनाता।

planar true होने पर हर वायर एक प्लेन में होना चाहिए; false होने पर हर एक से होकर चिकनी सतह फ़िट की जाती है।
Parameters
- inputs: FacesFromWiresDto<TopoDSWirePointer>
  वायर और क्या फेसेस का समतल होना आवश्यक है
Returns Promise<TopoDSFacePointer[]>
प्रत्येक वायर के लिए एक फेस, उसी क्रम में
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>
वृत्तों को स्पर्शरेखा बेल्टों से जोड़ता है: हर जोड़ी के लिए वह दो बाहरी स्पर्शरेखाएँ और उनके बीच के बाहरी चाप खींचता है और उस बाहरी रेखा को समतल फेस से भरता है।

combination जोड़ियाँ चुनता है: allWithAll हर वृत्त हर दूसरे के साथ, inOrder सूची में पड़ोसी, inOrderClosed अंतिम को पहले के साथ भी। unify फेसेस को फ़्यूज़ करता है; अन्यथा वे कंपाउंड बनाते हैं।
Parameters
- inputs: FaceFromMultipleCircleTanWiresDto<TopoDSWirePointer>
  वृत्त वायर, उन्हें कैसे जोड़ी में रखना है, क्या परिणाम को फ़्यूज़ करना है और टॉलरेंस
Returns Promise<TopoDSShapePointer>
फ़्यूज़ किया गया शेप, या बेल्ट फेसेस का कंपाउंड
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>
लगातार सूचियों के वृत्तों को स्पर्शरेखा बेल्टों से जोड़ता है, जिस तरह createFaceFromMultipleCircleTanWires अकेले वृत्तों को जोड़ता है।

allWithAll एक सूची के हर वृत्त को अगली के हर वृत्त से जोड़ता है; inOrder पड़ोसी सूचियों में समान स्थिति के वृत्तों को जोड़ता है, जिन्हें समान लंबाई चाहिए; inOrderClosed हर सूची को रिंग में बंद भी करता है। unify फेसेस को फ़्यूज़ करता है; अन्यथा वे कंपाउंड बनाते हैं।
Parameters
- inputs: FaceFromMultipleCircleTanWireCollectionsDto<TopoDSWirePointer>
  वृत्त वायर की सूचियाँ, उन्हें कैसे जोड़ी में रखना है, क्या परिणाम को फ़्यूज़ करना है और टॉलरेंस
Returns Promise<TopoDSShapePointer>
फ़्यूज़ किया गया शेप, या बेल्ट फेसेस का कंपाउंड
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>
पूरी सतह ढकने वाला फेस बनाता है, सतह की स्वाभाविक सीमाओं तक।

tolerance विकृत एजेस, जैसे गोले के ध्रुव, का पता लगाने के लिए उपयोग होता है। सतहें geom.surfaces से आती हैं।
Parameters
- inputs: ShapeWithToleranceDto<GeomSurfacePointer>
  सतह और अपभ्रष्ट एजेस के लिए टॉलरेंस
Returns Promise<TopoDSFacePointer>
फेस
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>
सतह को उस पर स्थित वायर से काटकर फेस बनाता है।

inside true होने पर वायर को इस तरह घुमाया जाता है कि फेस उसके घेरे का क्षेत्र हो; false होने पर वायर की अपनी दिशा तय करती है, और दूसरी दिशा में चलने वाला वायर उसके बाहर का क्षेत्र देता है। सतहें geom.surfaces से आती हैं।
Parameters
- inputs: FaceFromSurfaceAndWireDto<GeomSurfacePointer, TopoDSWirePointer>
  सतह, उस पर का वायर और कौन-सा पक्ष रखना है
Returns Promise<TopoDSFacePointer>
फेस
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>
तीन पॉइंट से समतल त्रिभुजाकार फेस बनाता है।
Parameters
- inputs: TriangleBaseDto
  त्रिभुज, तीन पॉइंट के रूप में
Returns Promise<TopoDSFacePointer>
फेस
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[]>
मेश के हर त्रिभुज के लिए एक समतल त्रिभुजाकार फेस बनाता है।

जो त्रिभुज फेस नहीं बना सकता, जैसे दोहराए गए पॉइंट वाला, उसे कंसोल में चेतावनी के साथ छोड़ दिया जाता है।
Parameters
- inputs: MeshBaseDto
  मेश, त्रिभुजों की सूची के रूप में
Returns Promise<TopoDSFacePointer[]>
प्रत्येक ऐसे त्रिभुज के लिए एक फेस जिसे बनाया जा सका
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>
शेप में से एक फेस उसकी स्थिति से चुनता है, 0 से गिनते हुए, उस क्रम में जिसमें कर्नेल शेप पर चलता है।

शेप फेस या फेसेस से बनी कोई चीज़ होना चाहिए; अंतिम फेस से आगे का इंडेक्स त्रुटि फेंकता है।
Parameters
- inputs: ShapeIndexDto<TopoDSShapePointer>
  शेप और 0-आधारित इंडेक्स
Returns Promise<TopoDSFacePointer>
उस इंडेक्स पर फेस
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[]>
शेप के हर फेस को उस क्रम में सूचीबद्ध करता है जिसमें कर्नेल उस पर चलता है।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<TopoDSFacePointer[]>
शेप में मिले फेसेस
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>
फेस को पलटता है ताकि उसका नॉर्मल दूसरी ओर इशारा करे।

ज्यामिति वही रहती है; केवल ओरिएंटेशन बदलता है, जो शेल का बाहरी भाग और normalOnUV द्वारा बताई गई दिशा तय करता है।
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  फेस
Returns Promise<TopoDSFacePointer>
पलटा हुआ फेस
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>
फेस का सबसे छोटा U पैरामीटर मान पढ़ता है, सतह की अपनी इकाइयों में।

getUMaxBound, getVMinBound और getVMaxBound के साथ यह वह रेंज देता है जिस पर इस क्लास में अन्यत्र उपयोग होने वाले UV अंश मैप होते हैं।
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  फेस
Returns Promise<number>
निचली 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>
फेस का सबसे बड़ा U पैरामीटर मान पढ़ता है, सतह की अपनी इकाइयों में।
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  फेस
Returns Promise<number>
ऊपरी 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>
फेस का सबसे छोटा V पैरामीटर मान पढ़ता है, सतह की अपनी इकाइयों में।
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  फेस
Returns Promise<number>
निचली 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>
फेस का सबसे बड़ा V पैरामीटर मान पढ़ता है, सतह की अपनी इकाइयों में।
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  फेस
Returns Promise<number>
ऊपरी 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>
फेस का सतह क्षेत्रफल वर्ग मॉडल इकाइयों में मापता है।
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  फेस
Returns Promise<number>
क्षेत्रफल
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[]>
सूची के हर फेस का सतह क्षेत्रफल वर्ग मॉडल इकाइयों में मापता है।
Parameters
- inputs: ShapesDto<TopoDSFacePointer>
  फेसेस
Returns Promise<number[]>
प्रत्येक फेस के लिए एक क्षेत्रफल, उसी क्रम में
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>
फेस का द्रव्यमान केंद्र, वह पॉइंट जिस पर उसका क्षेत्रफल संतुलित होता है, खोजता है।

वक्र या रिंग के आकार के फेस पर यह पॉइंट सतह से बाहर हो सकता है।
Parameters
- inputs: ShapeDto<TopoDSFacePointer>
  फेस
Returns Promise<Point3>
द्रव्यमान केंद्र
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[]>
सूची के हर फेस का द्रव्यमान केंद्र खोजता है।
Parameters
- inputs: ShapesDto<TopoDSFacePointer>
  फेसेस
Returns Promise<Point3[]>
प्रत्येक फेस के लिए एक पॉइंट, उसी क्रम में
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[]>
फेस पर आयताकार वायर बिछाता है, उसकी UV रेंज के nrRectanglesU गुणा nrRectanglesV विभाजन के प्रति सेल एक, सतह का अनुसरण करते हुए।

बॉर्डर ऑफ़सेट हर सिरे पर रेंज को काटते हैं। हर आयत अपने सेल में केंद्रित बैठता है, स्केल पैटर्न से उसके अंश के रूप में आकार पाता है; फिलेट पैटर्न कोने गोल करता है, समावेशन पैटर्न सेल छोड़ता है।
Parameters
- inputs: FaceSubdivideToRectangleWiresDto<TopoDSFacePointer>
  फेस, सेल की संख्याएँ, बॉर्डर ऑफसेट और वैकल्पिक पैटर्न
Returns Promise<TopoDSWirePointer[]>
आयत वायर, सेल दर सेल
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[]>
फेस में आयताकार छेदों की ग्रिड काटता है और छिद्रित फेस लौटाता है।

छेद वही सेल और पैटर्न अपनाते हैं जो subdivideToRectangleWires; जब कोई स्केल पैटर्न न दिया हो तब हर छेद अपने सेल का आधा ढकता है। holesToFaces true होने पर परिणाम में छिद्रित फेस के बाद प्रति छेद एक फेस भी होता है, जो ढक्कनों या भराव के लिए काम आता है।
Parameters
- inputs: FaceSubdivideToRectangleHolesDto<TopoDSFacePointer>
  फेस, सेल की संख्याएँ, बॉर्डर ऑफसेट, वैकल्पिक पैटर्न और क्या छेद वाले फेसेस वापस देने हैं
Returns Promise<TopoDSFacePointer[]>
छिद्रित फेस, उसके बाद माँगे जाने पर छेद वाले फेसेस
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[]>
फेस पर षट्भुजाकार वायर का मधुकोश बिछाता है, उसकी UV रेंज में फ़िट किए nrHexagonsU गुणा nrHexagonsV, हर एक सतह का अनुसरण करते हुए।

बॉर्डर ऑफ़सेट हर सिरे पर रेंज का एक अंश काटते हैं; flatU सपाट भुजा को U की ओर मोड़ता है, extend फ़्लैग बाहरी पंक्तियों को किनारों के पार खींचते हैं। स्केल, फिलेट और समावेशन पैटर्न प्रति षट्भुज दोहराते हैं।
Parameters
- inputs: FaceSubdivideToHexagonWiresDto<TopoDSFacePointer>
  फेस, षट्भुजों की संख्याएँ, ओरिएंटेशन, बॉर्डर ऑफसेट, विस्तार फ़्लैग और वैकल्पिक पैटर्न
Returns Promise<TopoDSWirePointer[]>
षट्भुज वायर, पंक्ति दर पंक्ति
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[]>
फेस में षट्भुजाकार छेदों का मधुकोश काटता है और छिद्रित फेस लौटाता है।

छेद वही लेआउट और पैटर्न अपनाते हैं जो subdivideToHexagonWires; जब कोई स्केल पैटर्न न दिया हो तब हर छेद अपने षट्भुज के आधे आकार का होता है। holesToFaces true होने पर परिणाम में छिद्रित फेस के बाद प्रति छेद एक फेस भी होता है।
Parameters
- inputs: FaceSubdivideToHexagonHolesDto<TopoDSFacePointer>
  फेस, षट्भुजों की संख्याएँ, ओरिएंटेशन, बॉर्डर ऑफसेट, वैकल्पिक पैटर्न और क्या छेद वाले फेसेस वापस देने हैं
Returns Promise<TopoDSFacePointer[]>
छिद्रित फेस, उसके बाद माँगे जाने पर छेद वाले फेसेस
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>
कोने के पॉइंट की सूची से समतल फेस बनाता है, बाहरी रेखा को अंतिम पॉइंट से वापस पहले तक बंद करते हुए।

पॉइंट एक प्लेन में होने चाहिए।
Parameters
- inputs: PolygonDto
  कोने के पॉइंट, क्रम में
Returns Promise<TopoDSFacePointer>
फेस
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>
समतल वृत्ताकार फेस, एक डिस्क, बनाता है।

direction उसके प्लेन का नॉर्मल है: डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।
Parameters
- inputs: Bit.Inputs.OCCT.CircleDto
  त्रिज्या, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
डिस्क फेस
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[]>
ग्राउंड प्लेन पर एक आयत को समतल षट्भुजाकार फेसेस की ग्रिड से भरता है, मूल बिंदु पर केंद्रित।

षट्भुज इस तरह स्केल किए जाते हैं कि nrHexagonsInWidth width के आर-पार और nrHexagonsInHeight height के आर-पार समाएँ। स्केल, फिलेट और समावेशन पैटर्न षट्भुज दर षट्भुज पढ़े जाते हैं और दोहराते हैं; extend फ़्लैग बाहरी पंक्तियों को किनारों के पार खींचते हैं ताकि आयत ढक जाए।
Parameters
- inputs: HexagonsInGridDto
  आयत का आकार, षट्भुजों की संख्याएँ, विस्तार फ़्लैग और वैकल्पिक पैटर्न
Returns Promise<TopoDSFacePointer[]>
प्रत्येक षट्भुज के लिए एक फेस, पंक्ति दर पंक्ति
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>
समतल दीर्घवृत्ताकार फेस बनाता है।

direction उसके प्लेन का नॉर्मल है: डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है। radiusMajor कम से कम radiusMinor होना चाहिए।
Parameters
- inputs: Bit.Inputs.OCCT.EllipseDto
  दो त्रिज्याएँ, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
दीर्घवृत्त फेस
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>
center पर केंद्रित समतल वर्ग फेस बनाता है।

direction उसके प्लेन का नॉर्मल है: डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।
Parameters
- inputs: Bit.Inputs.OCCT.SquareDto
  भुजा की लंबाई, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
वर्ग फेस
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>
center पर केंद्रित समतल आयताकार फेस बनाता है।

ग्राउंड प्लेन पर width X के साथ और length Z के साथ चलता है; direction प्लेन का नॉर्मल है, और डिफ़ॉल्ट [0, 1, 0] फेस को ज़मीन पर सपाट रखता है।
Parameters
- inputs: Bit.Inputs.OCCT.RectangleDto
  चौड़ाई, लंबाई, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
आयत फेस
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>
समतल L-आकार का फेस बनाता है: एक कोने पर जुड़ी दो आयताकार भुजाएँ।

पहली भुजा में widthFirst और lengthFirst हैं, दूसरी में widthSecond और lengthSecond; align कोने को भुजाओं के बाहर, भीतर या बीच में रखता है, और rotation शेप को उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर सपाट रहता है जब तक direction कुछ और न कहे।
Parameters
- inputs: LPolygonDto
  दोनों भुजाओं के आकार, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
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>
numRays नोकों वाला समतल तारे के आकार का फेस बनाता है।

नोकें outerRadius तक पहुँचती हैं और उनके बीच के खाँचे innerRadius तक; half केवल किरणों का पहला आधा रखता है। offsetOuterEdges किरणों की नोकों को प्लेन से बाहर उठाता है और वायर के लिए है; समतल फेस को वह 0 पर चाहिए। यह ज़मीन पर सपाट रहता है जब तक direction कुछ और न कहे।
Parameters
- inputs: Bit.Inputs.OCCT.StarDto
  दो त्रिज्याएँ, किरणों की संख्या, केंद्र, प्लेन का नॉर्मल और विकल्प
Returns Promise<TopoDSFacePointer>
तारा फेस
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>
शैलीकृत क्रिसमस ट्री के आकार का समतल फेस बनाता है: शाखाओं की nrSkirts परतें, तने की रेखा से outerDist से innerDist तक सिकुड़ती हुई, trunkHeight और trunkWidth के तने पर।

यहाँ के अन्य समतल शेप्स के विपरीत यह XY प्लेन में सीधा खड़ा होता है, नोक Y के साथ; direction तने-से-नोक की दिशा है, rotation उसे उस अक्ष के चारों ओर घुमाता है, डिग्री में।
Parameters
- inputs: ChristmasTreeDto
  पेड़ के अनुपात, तने का आकार, विकल्प, मूल बिंदु और तने से शीर्ष की दिशा
Returns Promise<TopoDSFacePointer>
पेड़ का फेस
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>
समतल समांतर चतुर्भुज फेस बनाता है: width और height का आयत जिसकी भुजाएँ angle डिग्री से झुकी हैं।

aroundCenter true होने पर शेप center पर केंद्रित होता है; अन्यथा वह वहाँ से शुरू होकर धनात्मक दिशाओं में फैलता है। direction प्लेन का नॉर्मल है; डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।
Parameters
- inputs: ParallelogramDto
  चौड़ाई, ऊँचाई, झुकाव का कोण, क्या उसे केंद्रित करना है, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
समांतर चतुर्भुज फेस
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>
समतल दिल के आकार का फेस बनाता है जो लगभग sizeApprox के वर्ग में समाता है।

rotation उसे उसके प्लेन में घुमाता है, डिग्री में। direction प्लेन का नॉर्मल है; डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।
Parameters
- inputs: Heart2DDto
  अनुमानित आकार, रोटेशन, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
हृदय फेस
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>
nrCorners कोनों वाला समतल नियमित बहुभुज फेस बनाता है, सभी radius के वृत्त पर।

direction प्लेन का नॉर्मल है; डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।
Parameters
- inputs: NGonWireDto
  कोनों की संख्या, त्रिज्या, केंद्र और प्लेन का नॉर्मल
Returns Promise<TopoDSFacePointer>
बहुभुज फेस
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>
फेस की सतह को दी गई U और V डिग्री के B-spline के रूप में फिर से बनाता है।

डिग्री घटाना सतह को tolerance के भीतर सरल सन्निकटन में चिकना करता है; बढ़ाना सटीक है। keepTrim मूल सीमा वायर रखता है, जो बढ़ाते समय भरोसेमंद है; अन्यथा फेस पूरी नई सतह ढकता है। विफल होने वाला पुनर्निर्माण null फेस देता है।
Parameters
- inputs: RebuildFaceDegreeDto<TopoDSFacePointer>
  फेस, लक्ष्य U और V डिग्री, टॉलरेंस और क्या सीमा को बनाए रखना है
Returns Promise<TopoDSFacePointer>
पुनर्निर्मित फेस
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>
बदलता है कि UV पैरामीटर फेस पर कैसे चलते हैं: U और V की अदला-बदली, U उलटना, V उलटना, या कोई भी संयोजन।

ज्यामिति वही रहती है; केवल पैरामीटर दिशाएँ बदलती हैं, जो यहाँ के UV में काम करने वाले हर मेथड के लिए मायने रखता है, जैसे subdivideToPoints या wireAlongParam। फेस सतह की स्वाभाविक सीमाओं पर फिर से बनाया जाता है।
Parameters
- inputs: FlipFaceUVDto<TopoDSFacePointer>
  फेस और कौन-से फ्लिप लागू करने हैं
Returns Promise<TopoDSFacePointer>
बदले हुए पैरामीट्राइज़ेशन वाला फेस
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>
फेस को फिर से पैरामीट्राइज़ करता है ताकि U या V में समान चरण सतह पर लगभग समान दूरियाँ दें।

कई सतहें अपने पैरामीटर जगह-जगह सिकोड़ लेती हैं, इसलिए उन पर UV ग्रिड असमान दिखती है; यह सतह को प्रति दिशा samples पॉइंट पर फिर से सैंपल करके फिर से फ़िट करता है, जो subdivideToPoints और उसके साथियों को समतल करता है। फेस नई सीमाओं पर फिर से बनाया जाता है।
Parameters
- inputs: NormalizeFaceParametrizationDto<TopoDSFacePointer>
  फेस, कौन-सी दिशाएँ नॉर्मलाइज़ करनी हैं, सैंपल की संख्या और फ़िट टॉलरेंस
Returns Promise<TopoDSFacePointer>
पुनः पैरामीट्राइज़ किया गया फेस
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