Class OCCTOperations

वे मॉडलिंग ऑपरेशन जो OpenCascade वायर और फेसेस को सतहों और सॉलिड्स में बदलते हैं और शेप्स को मापते हैं: सेक्शनों से होकर लॉफ्ट करना, एक्सट्रूड और रिवॉल्व करना, पथों के साथ प्रोफ़ाइल स्वीप करना, ऑफसेट करना, शैल को मोटा करके सॉलिड बनाना, स्लाइस और विभाजित करना, साथ ही बाउंडिंग बॉक्स, बाउंडिंग गोले और निकटतम-पॉइंट क्वेरी। दूरियाँ मॉडल इकाइयों में और कोण डिग्री में हैं; हर ऑपरेशन एक नया शेप लौटाता है। बूलियन booleans में हैं, गोल करना fillets में।

Constructors

constructor

new OCCTOperations(): OCCTOperations
Returns OCCTOperations

closest pts

closestPointsBetweenTwoShapes

closestPointsBetweenTwoShapes(
inputs: ClosestPointsBetweenTwoShapesDto<TopoDSShapePointer>,
): Promise<Point3[]>
पॉइंट की वह जोड़ी खोजता है, हर शेप पर एक, जो एक-दूसरे के सबसे पास हैं।

उनके बीच की दूरी शेप्स के बीच का अंतराल है; जब वे छूते या ओवरलैप होते हैं तब वह 0 है। जब कोई जोड़ी न मिले तब त्रुटि फेंकता है।
Parameters
- inputs: ClosestPointsBetweenTwoShapesDto<TopoDSShapePointer>
  दोनों शेप्स
Returns Promise<Point3[]>
पहले शेप पर का पॉइंट और दूसरे पर का पॉइंट
Example
```
const [onBox, onSphere] = await bitbybit.occt.operations.closestPointsBetweenTwoShapes({ shape1: box, shape2: sphere });
```
- Defined in bitbybit-docs.d.ts:41510

closestPointsOnShapeFromPoints

closestPointsOnShapeFromPoints(
inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>,
): Promise<Point3[]>
सूची के हर पॉइंट के लिए शेप पर निकटतम पॉइंट खोजता है।

पहले से शेप पर स्थित पॉइंट खुद पर मैप होता है। पॉइंट को सतह पर स्नैप करने के लिए उपयोगी।
Parameters
- inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>
  शेप और पॉइंट
Returns Promise<Point3[]>
प्रत्येक इनपुट पॉइंट के लिए शेप पर एक पॉइंट, उसी क्रम में
Example
```
const snapped = await bitbybit.occt.operations.closestPointsOnShapeFromPoints({ shape: sphere, points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41525

closestPointsOnShapesFromPoints

closestPointsOnShapesFromPoints(
inputs: ClosestPointsOnShapesFromPointsDto<TopoDSShapePointer>,
): Promise<Point3[]>
सूची के हर पॉइंट के लिए कई शेप्स में से हर एक पर निकटतम पॉइंट खोजता है।

परिणाम एक सपाट सूची है: पहले शेप के लिए सभी पॉइंट, पॉइंट क्रम में, फिर दूसरे शेप के लिए सभी पॉइंट, और इसी तरह आगे।
Parameters
- inputs: ClosestPointsOnShapesFromPointsDto<TopoDSShapePointer>
  शेप्स और पॉइंट
Returns Promise<Point3[]>
निकटतम पॉइंट, शेप दर शेप समूहित
Example
```
const snapped = await bitbybit.occt.operations.closestPointsOnShapesFromPoints({ shapes: [box, sphere], points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41541

divisions

splitShapeWithShapes

splitShapeWithShapes(
inputs: SplitDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer[]>
शेप को दूसरे शेप्स से टुकड़ों में काटता है, जिस तरह चाकू पाव को बाँटता है, बिना कोई सामग्री हटाए।

nonDestructive true, डिफ़ॉल्ट, होने पर इनपुट अछूते छोड़े जाते हैं और परिणाम में शामिल हर शेप के टुकड़े होते हैं, काटने वाले भी; false होने पर केवल shape के टुकड़े वापस आते हैं। localFuzzyTolerance लगभग छूने वाली ज्यामिति को छूती हुई मानने देता है।
Parameters
- inputs: SplitDto<TopoDSShapePointer>
  विभाजित किया जाने वाला शेप, वे शेप्स जिनसे उसे विभाजित करना है और विकल्प
Returns Promise<TopoDSShapePointer[]>
टुकड़े
Example
```
const pieces = await bitbybit.occt.operations.splitShapeWithShapes({ shape: box, shapes: [cuttingPlane], localFuzzyTolerance: 1e-4, nonDestructive: false });
```
- Defined in bitbybit-docs.d.ts:41751

slice

slice(
inputs: Bit.Inputs.OCCT.SliceDto<TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer>
सॉलिड को एक दिशा में समानांतर स्लाइस में काटता है, पाव की तरह, शेप के तल से ऊपर तक हर step मॉडल इकाइयों पर।

हर स्लाइस वह समतल सेक्शन है जहाँ काटने वाला प्लेन सॉलिड से मिलता है; वे एक कंपाउंड में एक साथ वापस आते हैं। शेप सॉलिड होना या सॉलिड रखना चाहिए, अन्यथा त्रुटि फेंकी जाती है।
Parameters
- inputs: Bit.Inputs.OCCT.SliceDto<TopoDSShapePointer>
  शेप, स्लाइसों के बीच की दूरी और स्लाइसिंग की दिशा
Returns Promise<TopoDSCompoundPointer>
सेक्शन फेसेस का एक कंपाउंड
Example
```
const layers = await bitbybit.occt.operations.slice({ shape: sphere, step: 0.5, direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:41973

sliceInStepPattern

sliceInStepPattern(
inputs: SliceInStepPatternDto<TopoDSShapePointer>,
): Promise<TopoDSCompoundPointer>
सॉलिड को slice की तरह समानांतर स्लाइस में काटता है, पर उनके बीच अंतरालों के दोहराए जाने वाले पैटर्न के साथ, जैसे 0.1, 0.5, 0.1, 0.5।

पैटर्न शेप के तल से ऊपर तक लागू होता है और शीर्ष तक पहुँचने तक दोहराता है।
Parameters
- inputs: SliceInStepPatternDto<TopoDSShapePointer>
  शेप, अंतरालों का पैटर्न और स्लाइसिंग की दिशा
Returns Promise<TopoDSCompoundPointer>
सेक्शन फेसेस का एक कंपाउंड
Example
```
const layers = await bitbybit.occt.operations.sliceInStepPattern({ shape: sphere, steps: [0.1, 0.5], direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:41989

extrusions

extrude

extrude(
inputs: Bit.Inputs.OCCT.ExtrudeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
शेप को एक वेक्टर के साथ सीधी रेखा में स्वीप करता है, जिसकी लंबाई दूरी है: फेस सॉलिड बन जाता है, वायर शेल, एज फेस।

शेप खुद एक्सट्रूज़न की शुरुआत में रहता है; वेक्टर मॉडल इकाइयों में है, इसलिए [0, 10, 0] 10 इकाइयाँ ऊपर एक्सट्रूड करता है।
Parameters
- inputs: Bit.Inputs.OCCT.ExtrudeDto<TopoDSShapePointer>
  शेप और दिशा वेक्टर, जिसकी लंबाई दूरी है
Returns Promise<TopoDSShapePointer>
एक्सट्रूड किया गया शेप
Example
```
const disc = await bitbybit.occt.shapes.face.createCircleFace({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
const cylinder = await bitbybit.occt.operations.extrude({ shape: disc, direction: [0, 10, 0] });
```
- Defined in bitbybit-docs.d.ts:41720

extrudeShapes

extrudeShapes(
inputs: ExtrudeShapesDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer[]>
कई शेप्स को एक ही वेक्टर के साथ स्वीप करता है, जैसे extrude एक के लिए करता है।
Parameters
- inputs: ExtrudeShapesDto<TopoDSShapePointer>
  शेप्स और दिशा वेक्टर, जिसकी लंबाई दूरी है
Returns Promise<TopoDSShapePointer[]>
एक्सट्रूड किए गए शेप्स, उसी क्रम में
Example
```
const walls = await bitbybit.occt.operations.extrudeShapes({ shapes: [faceA, faceB], direction: [0, 10, 0] });
```
- Defined in bitbybit-docs.d.ts:41733

rotatedExtrude

rotatedExtrude(
inputs: RotationExtrudeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
समतल शेप को Y के साथ height ऊपर एक्सट्रूड करता है और साथ ही उसे Y अक्ष के चारों ओर angle डिग्री मरोड़ता है, मुड़े हुए स्तंभ की तरह।

शेप सपाट होना चाहिए, जैसे इस पैकेज द्वारा बनाई प्रोफ़ाइलें होती हैं। makeSolid true, डिफ़ॉल्ट, होने पर फेस प्रोफ़ाइल बंद सॉलिड देती है; वायर मुड़ा हुआ शेल देता है।
Parameters
- inputs: RotationExtrudeDto<TopoDSShapePointer>
  प्रोफ़ाइल शेप, ऊँचाई, मोड़ का कोण डिग्री में और क्या सॉलिड बनाना है
Returns Promise<TopoDSShapePointer>
मुड़ा हुआ एक्सट्रूज़न
Example
```
const square = await bitbybit.occt.shapes.face.createSquareFace({ size: 5, center: [0, 0, 0], direction: [0, 1, 0] });
const twisted = await bitbybit.occt.operations.rotatedExtrude({ shape: square, height: 20, angle: 90, makeSolid: true });
```
- Defined in bitbybit-docs.d.ts:41787

lofts

loft

loft(inputs: LoftDto<TopoDSWirePointer>): Promise<TopoDSShapePointer>
वायर की शृंखला से होकर सतह बनाता है, पसलियों पर खिंची त्वचा की तरह: हर वायर एक सेक्शन है और सतह सूची क्रम में उनसे होकर गुज़रती है।

एजेस एक-एज वायर के रूप में स्वीकार किए जाते हैं। makeSolid true और बंद सेक्शन होने पर परिणाम ढककर सॉलिड बनाया जाता है; अन्यथा वह शेल है। सेक्शन समान एज गिनतियों के साथ सबसे अच्छे मेल खाते हैं।
Parameters
- inputs: LoftDto<TopoDSWirePointer>
  सेक्शन वायर या एजेस, क्रम में, और क्या सॉलिड बनाना है
Returns Promise<TopoDSShapePointer>
लॉफ्ट किया गया शैल या सॉलिड
Example
```
const bottom = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });
const upper = await bitbybit.occt.shapes.wire.createSquareWire({ size: 6, center: [0, 10, 0], direction: [0, 1, 0] });
const vase = await bitbybit.occt.operations.loft({ shapes: [bottom, upper], makeSolid: true });
```
- Defined in bitbybit-docs.d.ts:41464

loftAdvanced

loftAdvanced(
inputs: LoftAdvancedDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
loft की तरह वायर की शृंखला से होकर सतह बनाता है, इस पर नियंत्रण के साथ कि त्वचा कैसे फ़िट की जाती है।

straight सेक्शनों के बीच चिकने मिश्रण के बजाय रूल्ड पैच बनाता है; closed सतह को अंतिम सेक्शन से वापस पहले तक लूप करता है, और periodic सेक्शनों को फिर से सैंपल करके उस लूप को चिकना बनाता है। startVertex और endVertex सिरों को पॉइंट तक बंद करते हैं।
Parameters
- inputs: LoftAdvancedDto<TopoDSWirePointer>
  सेक्शन वायर या एजेस, क्या सॉलिड बनाना है, बंद करने और स्मूदिंग के विकल्प और वैकल्पिक अंत पॉइंट
Returns Promise<TopoDSShapePointer>
लॉफ्ट किया गया शैल या सॉलिड
Example
```
const cone = await bitbybit.occt.operations.loftAdvanced({
    shapes: [circleBottom, circleMiddle],
    makeSolid: true,
    closed: false,
    periodic: false,
    straight: false,
    nrPeriodicSections: 10,
    useSmoothing: false,
    maxUDegree: 3,
    tolerance: 1e-7,
    parType: Bit.Inputs.OCCT.approxParametrizationTypeEnum.approxCentripetal,
    endVertex: [0, 20, 0],
});
```
- Defined in bitbybit-docs.d.ts:41494

measure

distancesToShapeFromPoints

distancesToShapeFromPoints(
inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>,
): Promise<number[]>
मापता है कि सूची का हर पॉइंट शेप से कितनी दूर है, उस पर निकटतम पॉइंट तक की सीधी दूरी के रूप में, मॉडल इकाइयों में।

दूरी शेप की सतह तक है, इसलिए सॉलिड के भीतर का पॉइंट भी त्वचा तक अपनी दूरी रिपोर्ट करता है।
Parameters
- inputs: ClosestPointsOnShapeFromPointsDto<TopoDSShapePointer>
  शेप और पॉइंट
Returns Promise<number[]>
प्रत्येक पॉइंट के लिए एक दूरी, उसी क्रम में
Example
```
const distances = await bitbybit.occt.operations.distancesToShapeFromPoints({ shape: sphere, points: [[0, 20, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:41558

boundingBoxOfShape

boundingBoxOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<BoundingBoxPropsDto>
शेप को घेरने वाला अक्ष-संरेखित बॉक्स निकालता है: उसके न्यूनतम और अधिकतम कोने, उसका केंद्र और X, Y और Z के साथ उसका आकार।

वक्र शेप्स पर बॉक्स शेप से थोड़ा बड़ा हो सकता है, क्योंकि कर्नेल सटीक सतह के बजाय कंट्रोल ज्यामिति को घेरता है।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<BoundingBoxPropsDto>
बॉक्स, min, max, center और size के रूप में
Example
```
const box = await bitbybit.occt.operations.boundingBoxOfShape({ shape });
console.log(box.size, box.center);
```
- Defined in bitbybit-docs.d.ts:41576

boundingBoxMinOfShape

boundingBoxMinOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
शेप के अक्ष-संरेखित बाउंडिंग बॉक्स का न्यूनतम कोना पढ़ता है, सबसे छोटे X, Y और Z वाला पॉइंट।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<Point3>
न्यूनतम कोना
Example
```
const min = await bitbybit.occt.operations.boundingBoxMinOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41590

boundingBoxMaxOfShape

boundingBoxMaxOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
शेप के अक्ष-संरेखित बाउंडिंग बॉक्स का अधिकतम कोना पढ़ता है, सबसे बड़े X, Y और Z वाला पॉइंट।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<Point3>
अधिकतम कोना
Example
```
const max = await bitbybit.occt.operations.boundingBoxMaxOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41604

boundingBoxCenterOfShape

boundingBoxCenterOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Point3>
शेप के अक्ष-संरेखित बाउंडिंग बॉक्स का केंद्र पढ़ता है, उसके दो कोनों के बीच का आधा रास्ता।

यह द्रव्यमान केंद्र नहीं है; shapes.solid.getSolidCenterOfMass और उसके साथी वह देते हैं।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<Point3>
बॉक्स का केंद्र
Example
```
const center = await bitbybit.occt.operations.boundingBoxCenterOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41620

boundingBoxSizeOfShape

boundingBoxSizeOfShape(inputs: ShapeDto<TopoDSShapePointer>): Promise<Vector3>
शेप के अक्ष-संरेखित बाउंडिंग बॉक्स का X, Y और Z के साथ आकार पढ़ता है, मॉडल इकाइयों में।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<Vector3>
बॉक्स की चौड़ाई, ऊँचाई और लंबाई
Example
```
const size = await bitbybit.occt.operations.boundingBoxSizeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41633

boundingBoxShapeOfShape

boundingBoxShapeOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
शेप का अक्ष-संरेखित बाउंडिंग बॉक्स बॉक्स सॉलिड के रूप में बनाता है, उसे ड्रॉ करने या बूलियन में उपयोग करने के लिए काम का।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<TopoDSShapePointer>
बॉक्स सॉलिड
Example
```
const boxSolid = await bitbybit.occt.operations.boundingBoxShapeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41647

boundingSphereOfShape

boundingSphereOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<BoundingSpherePropsDto>
शेप को घेरने वाला गोला निकालता है: वह बाउंडिंग बॉक्स पर केंद्रित है और उसके कोनों तक पहुँचता है, इसलिए वह हमेशा शेप को समेटता है पर सबसे छोटा संभव गोला नहीं है।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<BoundingSpherePropsDto>
गोला, center और radius के रूप में
Example
```
const sphere = await bitbybit.occt.operations.boundingSphereOfShape({ shape });
console.log(sphere.radius);
```
- Defined in bitbybit-docs.d.ts:41662

boundingSphereCenterOfShape

boundingSphereCenterOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<Point3>
शेप के बाउंडिंग गोले का केंद्र पढ़ता है, जो उसके बाउंडिंग बॉक्स का केंद्र है।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<Point3>
गोले का केंद्र
Example
```
const center = await bitbybit.occt.operations.boundingSphereCenterOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41675

boundingSphereRadiusOfShape

boundingSphereRadiusOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<number>
शेप के बाउंडिंग गोले की त्रिज्या पढ़ता है, बाउंडिंग बॉक्स के केंद्र से उसके कोने तक की दूरी, मॉडल इकाइयों में।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<number>
त्रिज्या
Example
```
const radius = await bitbybit.occt.operations.boundingSphereRadiusOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41689

boundingSphereShapeOfShape

boundingSphereShapeOfShape(
inputs: ShapeDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
शेप का बाउंडिंग गोला गोला सॉलिड के रूप में बनाता है।
Parameters
- inputs: ShapeDto<TopoDSShapePointer>
  शेप
Returns Promise<TopoDSShapePointer>
गोला सॉलिड
Example
```
const sphereSolid = await bitbybit.occt.operations.boundingSphereShapeOfShape({ shape });
```
- Defined in bitbybit-docs.d.ts:41702

offsets

offset

offset(
inputs: Bit.Inputs.OCCT.OffsetDto<TopoDSShapePointer, TopoDSFacePointer>,
): Promise<TopoDSShapePointer>
शेप की सीमा को एक निश्चित दूरी से बाहर की ओर, या ऋणात्मक दूरी के लिए भीतर की ओर, ले जाता है: वायर समानांतर बाहरी रेखा में बढ़ता है, फेस या सॉलिड बड़े में।

वायर या एज अपने प्लेन में, या दिए जाने पर face पर, ऑफ़सेट किया जाता है; कोने गोल किए जाते हैं। 0 की दूरी शेप को जैसा है वैसा लौटाती है।
Parameters
- inputs: Bit.Inputs.OCCT.OffsetDto<TopoDSShapePointer, TopoDSFacePointer>
  शेप, वायर को ऑफसेट करने के लिए एक वैकल्पिक फेस, दूरी और टॉलरेंस
Returns Promise<TopoDSShapePointer>
ऑफसेट किया गया शेप
Example
```
const bigger = await bitbybit.occt.operations.offset({ shape: box, distance: 1, tolerance: 0.1 });
```
- Defined in bitbybit-docs.d.ts:41888

offsetAdv

offsetAdv(
inputs: OffsetAdvancedDto<TopoDSShapePointer, TopoDSFacePointer>,
): Promise<TopoDSShapePointer>
offset की तरह शेप को ऑफ़सेट करता है, इस विकल्प के साथ कि कोने कैसे जोड़े जाएँ: arc उन्हें गोल करता है, intersection भुजाओं को तीखे कोने तक बढ़ाता है, tangent उन्हें स्पर्शी रखता है।

removeIntEdges उन आंतरिक एजेस को हटाता है जो ऑफ़सेट सॉलिड पर छोड़ सकता है।
Parameters
- inputs: OffsetAdvancedDto<TopoDSShapePointer, TopoDSFacePointer>
  शेप, वायर को ऑफसेट करने के लिए एक वैकल्पिक फेस, दूरी, टॉलरेंस, कोने के जोड़ का प्रकार और क्या आंतरिक एजेस हटाने हैं
Returns Promise<TopoDSShapePointer>
ऑफसेट किया गया शेप
Example
```
const sharper = await bitbybit.occt.operations.offsetAdv({
    shape: rectangleWire,
    distance: 1,
    tolerance: 0.1,
    joinType: Bit.Inputs.OCCT.joinTypeEnum.intersection,
    removeIntEdges: false,
});
```
- Defined in bitbybit-docs.d.ts:41910

makeThickSolidSimple

makeThickSolidSimple(
inputs: ThisckSolidSimpleDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
फेस या शेल को मोटाई देता है, उसे दिए गए offset की सॉलिड पटिया या दीवार में बदलते हुए।

धनात्मक ऑफ़सेट सतह के नॉर्मल की ओर मोटा करता है, ऋणात्मक दूसरी ओर। इसका उपयोग लॉफ्ट या स्वीप की गई त्वचा को प्रिंट करने लायक चीज़ में बदलने के लिए करें।
Parameters
- inputs: ThisckSolidSimpleDto<TopoDSShapePointer>
  फेस या शैल और मोटाई
Returns Promise<TopoDSShapePointer>
मोटा सॉलिड
Example
```
const wall = await bitbybit.occt.operations.makeThickSolidSimple({ shape: loftedShell, offset: 0.5 });
```
- Defined in bitbybit-docs.d.ts:41927

makeThickSolidByJoin

makeThickSolidByJoin(
inputs: ThickSolidByJoinDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
सूचीबद्ध फेसेस हटाकर और बाकी को ऑफ़सेट करके सॉलिड को दी गई दीवार मोटाई के शेल में खोखला करता है।

उदाहरण के लिए बॉक्स का ऊपरी फेस हटाने पर खुला प्याला मिलता है। offset दीवार की मोटाई है, भीतर की ओर बढ़ने के लिए ऋणात्मक; joinType बताता है कि ऑफ़सेट दीवारें कोनों पर कैसे मिलती हैं, बाकी फ़्लैग कर्नेल के थिक-सॉलिड बिल्डर को जाते हैं।
Parameters
- inputs: ThickSolidByJoinDto<TopoDSShapePointer>
  सॉलिड, हटाए जाने वाले फेसेस, दीवार की मोटाई, टॉलरेंस और जोड़ के विकल्प
Returns Promise<TopoDSShapePointer>
खोखला किया गया सॉलिड
Example
```
const box = await bitbybit.occt.shapes.solid.createBox({ width: 10, length: 10, height: 10, center: [0, 0, 0] });
const faces = await bitbybit.occt.shapes.face.getFaces({ shape: box });
const cup = await bitbybit.occt.operations.makeThickSolidByJoin({
    shape: box,
    shapes: [faces[0]],
    offset: -1,
    tolerance: 1e-3,
    intersection: false,
    selfIntersection: false,
    joinType: Bit.Inputs.OCCT.joinTypeEnum.arc,
    removeIntEdges: false,
});
```
- Defined in bitbybit-docs.d.ts:41956

offset3DWire

offset3DWire(
inputs: Offset3DWireDto<TopoDSWirePointer>,
): Promise<TopoDSWirePointer>
एक प्लेन में न होने वाले वायर को ऑफ़सेट करता है, उसे direction के साथ एक्सट्रूड करके, परिणाम को मोटा करके और ऑफ़सेट एज को उससे वापस पढ़कर।

यह चिकने वायर पर सबसे अच्छा काम करता है; तीखे कोनों को पहले fillets.fillet3DWire से फिलेट करें। जब ऑफ़सेट एजेस एक वायर में नहीं जोड़े जा सकते तब वे एजेस की सूची के रूप में वापस आते हैं।
Parameters
- inputs: Offset3DWireDto<TopoDSWirePointer>
  वायर, ऑफसेट दूरी और वह दिशा जिसके साथ एक्सट्रूड करना है
Returns Promise<TopoDSWirePointer>
ऑफसेट किया गया वायर, या जब उन्हें जोड़ा न जा सका तो ढीले एजेस
Example
```
const outer = await bitbybit.occt.operations.offset3DWire({ shape: smoothWire, offset: 1, direction: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:42006

pipeing

pipe

pipe(
inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
एक या अधिक प्रोफ़ाइल शेप्स को पथ वायर के साथ स्वीप करता है और परिणाम को सॉलिड में बंद करता है।

प्रोफ़ाइलें पथ पर रखी होनी चाहिए; कई प्रोफ़ाइलों के साथ स्वीप रास्ते में एक से अगली तक मिश्रित होता है।
Parameters
- inputs: ShapeShapesDto<TopoDSWirePointer, TopoDSShapePointer>
  पथ वायर और उस पर रखे प्रोफ़ाइल शेप्स
Returns Promise<TopoDSShapePointer>
स्वीप किया गया सॉलिड
Example
```
const tube = await bitbybit.occt.operations.pipe({ shape: pathWire, shapes: [profileAtStart] });
```
- Defined in bitbybit-docs.d.ts:41803

pipePolylineWireNGon

pipePolylineWireNGon(
inputs: PipePolygonWireNGonDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
नियमित बहुभुज को वायर के साथ स्वीप करता है, nrCorners सपाट भुजाओं वाली ट्यूब देते हुए, उदाहरण के लिए पथ के साथ षट्भुजाकार छड़।

radius का बहुभुज वायर की शुरुआत पर, उसके लंबवत, रखा जाता है। makeSolid शेल के बजाय सॉलिड देता है, trihedronEnum चुनता है कि प्रोफ़ाइल पथ के साथ कैसे मुड़ती है, और forceApproxC1 परिणाम को चिकना करता है।
Parameters
- inputs: PipePolygonWireNGonDto<TopoDSWirePointer>
  पथ वायर, बहुभुज की त्रिज्या और कोनों की संख्या, और स्वीप विकल्प
Returns Promise<TopoDSShapePointer>
स्वीप किया गया सॉलिड या शैल
Example
```
const bar = await bitbybit.occt.operations.pipePolylineWireNGon({
    shape: pathWire,
    radius: 0.5,
    nrCorners: 6,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41828

pipeWiresCylindrical

pipeWiresCylindrical(
inputs: PipeWiresCylindricalDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer[]>
कई वायर में से हर एक के साथ वृत्त स्वीप करता है, जैसे pipeWireCylindrical एक के लिए करता है, सभी एक ही त्रिज्या और विकल्पों के साथ।
Parameters
- inputs: PipeWiresCylindricalDto<TopoDSWirePointer>
  पथ वायर, त्रिज्या और स्वीप विकल्प
Returns Promise<TopoDSShapePointer[]>
प्रत्येक वायर के लिए एक ट्यूब, उसी क्रम में
Example
```
const tubes = await bitbybit.occt.operations.pipeWiresCylindrical({
    shapes: [pathA, pathB],
    radius: 0.5,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41848

pipeWireCylindrical

pipeWireCylindrical(
inputs: PipeWireCylindricalDto<TopoDSWirePointer>,
): Promise<TopoDSShapePointer>
वायर के साथ वृत्त स्वीप करता है, दी गई त्रिज्या की गोल ट्यूब देते हुए जो पथ का अनुसरण करती है।

वृत्त वायर की शुरुआत पर, उसके लंबवत, रखा जाता है। makeSolid शेल के बजाय सॉलिड देता है, trihedronEnum चुनता है कि पथ का अनुसरण करते हुए प्रोफ़ाइल कैसे मुड़ती है, और forceApproxC1 परिणाम को चिकना करता है।
Parameters
- inputs: PipeWireCylindricalDto<TopoDSWirePointer>
  पथ वायर, त्रिज्या और स्वीप विकल्प
Returns Promise<TopoDSShapePointer>
ट्यूब, सॉलिड या शैल के रूप में
Example
```
const tube = await bitbybit.occt.operations.pipeWireCylindrical({
    shape: pathWire,
    radius: 0.5,
    makeSolid: true,
    trihedronEnum: Bit.Inputs.OCCT.geomFillTrihedronEnum.isConstantNormal,
    forceApproxC1: false,
});
```
- Defined in bitbybit-docs.d.ts:41871

revolutions

revolve

revolve(
inputs: Bit.Inputs.OCCT.RevolveDto<TopoDSShapePointer>,
): Promise<TopoDSShapePointer>
शेप को मूल बिंदु से गुज़रने वाली अक्ष के चारों ओर घुमाकर सतह या सॉलिड स्वीप करता है: फेस सॉलिड देता है, वायर शेल।

angle डिग्री में है; 360 या अधिक पूरा चक्कर देता है। अक्ष direction के साथ चलती है: Y अक्ष के बगल की प्रोफ़ाइल उसके चारों ओर घुमाने पर फूलदान देती है। प्रोफ़ाइल उसे काटनी नहीं चाहिए।
Parameters
- inputs: Bit.Inputs.OCCT.RevolveDto<TopoDSShapePointer>
  प्रोफ़ाइल शेप, कोण डिग्री में, अक्ष की दिशा और क्या ज्यामिति की प्रतिलिपि बनानी है
Returns Promise<TopoDSShapePointer>
घुमाकर बनाया गया शेप
Example
```
const profile = await bitbybit.occt.shapes.wire.createPolylineWire({ points: [[2, 0, 0], [4, 0, 0], [3, 10, 0], [2, 12, 0]] });
const vase = await bitbybit.occt.operations.revolve({ shape: profile, angle: 360, direction: [0, 1, 0], copy: false });
```
- Defined in bitbybit-docs.d.ts:41769

Class OCCTOperations

Index

Constructors

closest pts

divisions

extrusions

lofts

measure

offsets

pipeing

revolutions

Constructors

constructor

Returns OCCTOperations

closest pts

closestPointsBetweenTwoShapes

Parameters

Returns Promise<Point3[]>

Example

closestPointsOnShapeFromPoints

Parameters

Returns Promise<Point3[]>

Example

closestPointsOnShapesFromPoints

Parameters

Returns Promise<Point3[]>

Example

divisions

splitShapeWithShapes

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

slice

Parameters

Returns Promise<TopoDSCompoundPointer>

Example

sliceInStepPattern

Parameters

Returns Promise<TopoDSCompoundPointer>

Example

extrusions

extrude

Parameters

Returns Promise<TopoDSShapePointer>

Example

extrudeShapes

Parameters

Returns Promise<TopoDSShapePointer[]>

Example

rotatedExtrude

Parameters

Returns Promise<TopoDSShapePointer>

Example

lofts

loft

Parameters

Returns Promise<TopoDSShapePointer>

Example

loftAdvanced

Parameters

Returns Promise<TopoDSShapePointer>

Example

measure

distancesToShapeFromPoints

Parameters

Returns Promise<number[]>

Example

boundingBoxOfShape

Parameters

Returns Promise<BoundingBoxPropsDto>

Example

boundingBoxMinOfShape

Parameters

Returns Promise<Point3>

Example

boundingBoxMaxOfShape

Parameters

Returns Promise<Point3>

Example

boundingBoxCenterOfShape