Bitbybit Docs
    Preparing search index...

    Class OCCTWire

    OpenCascade में वायर: सिरे से सिरा जुड़े एजेस की श्रृंखलाएँ, पथ की तरह खुली या बाहरी रेखा की तरह बंद। उन्हें पॉइंट और कर्व (पॉलीलाइनें, B-spline, Bezier, इंटरपोलेशन, हेलिक्स, सर्पिल) से, तैयार समतल बाहरी रेखाओं (वृत्त, आयत, तारे, बीम प्रोफ़ाइल, टेक्स्ट) के रूप में जो direction के अन्यथा कहने तक ग्राउंड प्लेन पर रहती हैं, या मौजूदा एजेस और वायर को जोड़कर और विभाजित करके बनाएँ; उन्हें पॉइंट, स्पर्शरेखाओं, लंबाइयों और केंद्रों के रूप में वापस पढ़ें; उन्हें फेसेस पर मैप करें या शेप्स पर प्रोजेक्ट करें। वायर के साथ पैरामीटर उसके आरंभ पर 0 से उसके अंत पर 1 तक चलते हैं और दूरी के बजाय हर एज के अपने पैरामीटर का अनुसरण करते हैं। बंद वायर ही वह है जिसे shapes.face भरकर फेस बनाता है।

    Index

    Constructors

    constructor

    beam profiles

    createIBeamProfileWire createHBeamProfileWire createTBeamProfileWire createUBeamProfileWire

    build

    combineEdgesAndWiresIntoAWire createWireFromEdge addEdgesAndWiresToWire

    debug

    debugInfo

    edit

    closeOpenWire

    extract

    splitOnPoints wiresToPoints divideWireByParamsToPoints divideWireByEqualDistanceToPoints pointOnWireAtParam pointOnWireAtLength pointsOnWireAtLengths pointsOnWireAtEqualLength pointsOnWireAtPatternOfLengths tangentOnWireAtParam tangentOnWireAtLength derivativesOnWireAtLength derivativesOnWireAtParam startPointOnWire midPointOnWire endPointOnWire

    extract from wires

    divideWiresByParamsToPoints divideWiresByEqualDistanceToPoints

    from base

    fromBaseLine fromBaseLines fromBaseSegment fromBaseSegments fromPoints fromBasePolyline fromBaseTriangle fromBaseMesh

    get

    getWire getWires getWireCenterOfMass getWiresCentersOfMass reversedWire reversedWireFromReversedEdges isWireClosed getWireLength getWiresLengths

    multiple

    createPolygons createLines createPolylines createBezierWires interpolateWires createBSplines

    place

    placeWireOnFace placeWiresOnFace project projectWires

    primitives

    createCircleWire hexagonsInGrid createSquareWire createStarWire createChristmasTreeWire createNGonWire createParallelogramWire createHeartWire createRectangleWire createLPolygonWire createEllipseWire createHelixWire createHelixWireByTurns createTaperedHelixWire createFlatSpiralWire textWires textWiresWithData

    rebuild

    rebuildWireDegree

    seam

    moveWireSeamByParameter moveWireSeamByLength

    via points

    createPolygonWire createLineWire createLineWireWithExtensions createPolylineWire createBezier createBezierWeights interpolatePoints interpolatePointsSymmetric createBSpline

    via wires

    createZigZagBetweenTwoWires createWiresBetweenStartEndPointsOfWiresAndEdges createWiresBetweenSubdividedPointsOfWiresAndEdges createWireFromTwoCirclesTan

    Constructors

    beam profiles

    • I-बीम अनुप्रस्थ काट की बंद बाहरी रेखा बनाता है: ऊर्ध्वाधर वेब से जुड़े दो क्षैतिज फ़्लैंज।

      width फ़्लैंज की चौड़ाई है, height कुल ऊँचाई, webThickness और flangeThickness दीवार की मोटाइयाँ; alignment बताता है कि प्रोफ़ाइल के बॉक्स का कौन-सा पॉइंट center पर बैठता है, rotation उसे उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर रहता है, एक्सट्रूड के लिए तैयार।

      Parameters

      • inputs: IBeamProfileDto

        प्रोफ़ाइल का आकार, दो मोटाइयाँ, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      I-बीम बाहरी रेखा वायर

      const profile = await bitbybit.occt.shapes.wire.createIBeamProfileWire({
          width: 10,
          height: 20,
          webThickness: 2,
          flangeThickness: 3,
          alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
          rotation: 0,
          center: [0, 0, 0],
          direction: [0, 1, 0],
      });

    • H-बीम अनुप्रस्थ काट की बंद बाहरी रेखा बनाता है: क्षैतिज वेब से जुड़े दो ऊर्ध्वाधर फ़्लैंज, करवट लिया I-बीम।

      width कुल चौड़ाई है, height फ़्लैंज की ऊँचाई, webThickness और flangeThickness दीवार की मोटाइयाँ; alignment बताता है कि प्रोफ़ाइल के बॉक्स का कौन-सा पॉइंट center पर बैठता है, rotation उसे उसके प्लेन में घुमाता है, डिग्री में।

      Parameters

      • inputs: HBeamProfileDto

        प्रोफ़ाइल का आकार, दो मोटाइयाँ, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      H-बीम बाहरी रेखा वायर

      const profile = await bitbybit.occt.shapes.wire.createHBeamProfileWire({
          width: 20,
          height: 10,
          webThickness: 2,
          flangeThickness: 3,
          alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
          rotation: 0,
          center: [0, 0, 0],
          direction: [0, 1, 0],
      });

    • T-बीम अनुप्रस्थ काट की बंद बाहरी रेखा बनाता है: एक क्षैतिज फ़्लैंज जिसके मध्य से ऊर्ध्वाधर वेब लटकता है।

      width फ़्लैंज की चौड़ाई है, height कुल ऊँचाई, webThickness और flangeThickness दीवार की मोटाइयाँ; alignment बताता है कि प्रोफ़ाइल के बॉक्स का कौन-सा पॉइंट center पर बैठता है, rotation उसे उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर रहता है।

      Parameters

      • inputs: TBeamProfileDto

        प्रोफ़ाइल का आकार, दो मोटाइयाँ, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      T-बीम बाहरी रेखा वायर

      const profile = await bitbybit.occt.shapes.wire.createTBeamProfileWire({
          width: 10,
          height: 12,
          webThickness: 2,
          flangeThickness: 2,
          alignment: Bit.Inputs.Base.basicAlignmentEnum.midMid,
          rotation: 0,
          center: [0, 0, 0],
          direction: [0, 1, 0],
      });

    • U-बीम अनुप्रस्थ काट, एक चैनल, की बंद बाहरी रेखा बनाता है: एक वेब जिसके सिरों से flangeWidth के दो फ़्लैंज ऊपर खड़े हैं।

      width और height कुल आकार हैं, webThickness और flangeThickness दीवार की मोटाइयाँ; alignment बताता है कि प्रोफ़ाइल के बॉक्स का कौन-सा पॉइंट center पर बैठता है, rotation उसे उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर रहता है।

      Parameters

      • inputs: UBeamProfileDto

        प्रोफ़ाइल का आकार, मोटाइयाँ, फ़्लैंज की चौड़ाई, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      U-बीम बाहरी रेखा वायर

      const profile = await bitbybit.occt.shapes.wire.createUBeamProfileWire({
          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],
      });

    build

    • सिरे से सिरे छूने वाले एजेस और वायर को एक वायर में जोड़ता है।

      टुकड़े जुड़ने चाहिए; अंतराल या भटके हुए टुकड़े वाला सेट त्रुटि फेंकता है। सूची में अन्य प्रकार के शेप्स अनदेखे किए जाते हैं।

      Parameters

      Returns Promise<TopoDSWirePointer>

      जोड़ा गया वायर

      const outline = await bitbybit.occt.shapes.wire.combineEdgesAndWiresIntoAWire({ shapes: [arc, line1, line2] });

    • एक अकेले एज को वायर में लपेटता है, ताकि वह वहाँ जा सके जहाँ वायर अपेक्षित है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      उस एज को रखने वाला वायर

      const wire = await bitbybit.occt.shapes.wire.createWireFromEdge({ shape: edge });

    • वायर को उससे सिरे से सिरे छूने वाले और एजेस और वायर से बढ़ाता है।

      टुकड़े वायर से या एक-दूसरे से जुड़ने चाहिए; अंतराल त्रुटि फेंकता है। सूची में अन्य प्रकार के शेप्स अनदेखे किए जाते हैं।

      Parameters

      Returns Promise<TopoDSWirePointer>

      बढ़ाया गया वायर

      const longer = await bitbybit.occt.shapes.wire.addEdgesAndWiresToWire({ shape: wire, shapes: [nextEdge, nextWire] });

    debug

    • वायर के बारे में निदान तथ्य इकट्ठा करता है: उसमें कितने एजेस हैं, क्या वह बंद है, उसकी कुल लंबाई और, हर एज के लिए, वह वक्र रिपोर्ट जो shapes.edge.debugInfo देता है।

      खाली या null वायर शून्य गिनतियों के साथ अमान्य चिह्नित रिपोर्ट देता है।

      Parameters

      Returns Promise<WireDebugInfo>

      रिपोर्ट, जिसमें एजेस की संख्या, बंद होने का फ़्लैग, लंबाई और प्रत्येक एज के लिए एक प्रविष्टि है

      const info = await bitbybit.occt.shapes.wire.debugInfo({ shape: wire });
      console.log(info.nbEdges, info.closed, info.totalLength);

    edit

    • खुले वायर को उसके अंतिम पॉइंट से वापस उसके शुरुआती पॉइंट तक सीधे एज से बंद करता है।

      जिस वायर के सिरे पहले से मिलते हैं वह जैसा है वैसा लौटाया जाता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      बंद वायर

      const closedWire = await bitbybit.occt.shapes.wire.closeOpenWire({ shape: openWire });

    extract

    • वायर को दिए गए पॉइंट पर टुकड़ों में काटता है।

      काटने से पहले हर पॉइंट वायर पर निकटतम जगह तक ले जाया जाता है, इसलिए उसका ठीक उस पर होना ज़रूरी नहीं; दोहराए गए पॉइंट अनदेखे किए जाते हैं। टुकड़े वायर के साथ क्रम में वापस आते हैं, उसकी शुरुआत से उसके अंत तक।

      Parameters

      Returns Promise<TopoDSWirePointer[]>

      वायर के टुकड़े, क्रम में

      const pieces = await bitbybit.occt.shapes.wire.splitOnPoints({ shape: wire, points: [[3, 0, 0], [7, 0, 0]] });

    • शेप के हर वायर को पॉइंट की ऐसी शृंखला में बदलता है जो उसे ड्रॉ करने लायक बारीकी से उसके वक्रों का अनुसरण करती है, प्रति वायर एक सूची।

      डिफ़्लेक्शन सेटिंग बताती हैं कि पॉइंट वक्र एजेस से कितनी कसकर चिपकते हैं; जहाँ एक एज खत्म होता है और अगला शुरू होता है वहाँ साझा पॉइंट एक बार दिखता है।

      Parameters

      Returns Promise<Point3[][]>

      प्रत्येक वायर के लिए पॉइंट की एक सूची

      const polylines = await bitbybit.occt.shapes.wire.wiresToPoints({
          shape: wire,
          angularDeflection: 0.1,
          curvatureDeflection: 0.1,
          minimumOfPoints: 2,
          uTolerance: 1e-9,
          minimumLength: 1e-7,
      });

    • वायर के साथ उसके पैरामीटर के समान चरणों पर पॉइंट रखता है, शुरुआत से अंत तक।

      nrOfDivisions चरण उससे एक अधिक पॉइंट देते हैं; removeStartPoint और removeEndPoint सिरे हटाते हैं। पैरामीटर हर एज के अपने वक्र पैरामीटर का अनुसरण करता है, इसलिए समान चरण समान दूरियाँ नहीं होते; उनके लिए divideWireByEqualDistanceToPoints का उपयोग करें।

      Parameters

      • inputs: DivideDto<TopoDSWirePointer>

        वायर, विभाजनों की संख्या और क्या अंत पॉइंट छोड़ने हैं

      Returns Promise<Point3[]>

      वायर के साथ के पॉइंट, क्रम में

      const points = await bitbybit.occt.shapes.wire.divideWireByParamsToPoints({ shape: wire, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });

    • वायर के साथ उसके वक्रों पर मापी गई समान दूरियों पर पॉइंट रखता है, शुरुआत से अंत तक।

      nrOfDivisions चरण उससे एक अधिक पॉइंट देते हैं; removeStartPoint और removeEndPoint सिरे हटाते हैं।

      Parameters

      • inputs: DivideDto<TopoDSWirePointer>

        वायर, विभाजनों की संख्या और क्या अंत पॉइंट छोड़ने हैं

      Returns Promise<Point3[]>

      वायर के साथ के पॉइंट, क्रम में

      const points = await bitbybit.occt.shapes.wire.divideWireByEqualDistanceToPoints({ shape: wire, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });

    • वायर पर एक अंश की दूरी पर स्थित पॉइंट खोजता है: 0 शुरुआत है, 1 अंत।

      अंश एजेस के पैरामीटर का अनुसरण करता है, दूरी का नहीं, इसलिए 0.5 हमेशा लंबाई के हिसाब से मध्य नहीं होता; दूरी के लिए pointOnWireAtLength का उपयोग करें।

      Parameters

      Returns Promise<Point3>

      वायर पर स्थित पॉइंट

      const point = await bitbybit.occt.shapes.wire.pointOnWireAtParam({ shape: wire, param: 0.25 });

    • वायर पर उसकी शुरुआत से दी गई दूरी पर स्थित पॉइंट खोजता है, उसके वक्रों के साथ मॉडल इकाइयों में मापी गई।

      Parameters

      Returns Promise<Point3>

      वायर पर स्थित पॉइंट

      const point = await bitbybit.occt.shapes.wire.pointOnWireAtLength({ shape: wire, length: 2.5 });

    • वायर पर उसकी शुरुआत से कई दूरियों पर स्थित पॉइंट खोजता है, उसके वक्रों के साथ मॉडल इकाइयों में मापी गई।

      Parameters

      Returns Promise<Point3[]>

      प्रत्येक दूरी के लिए एक पॉइंट, उसी क्रम में

      const points = await bitbybit.occt.shapes.wire.pointsOnWireAtLengths({ shape: wire, lengths: [1, 2.5, 4] });

    • वायर के साथ उसकी शुरुआत से हर length मॉडल इकाइयों पर पॉइंट रखता है, जितने समाएँ।

      includeFirst शुरुआत का पॉइंट रखता है, includeLast दूरी चाहे जो हो अंतिम पॉइंट जोड़ता है, और tryNext अंतिम समाए पॉइंट से एक चरण आगे एक और पॉइंट माँगता है।

      Parameters

      Returns Promise<Point3[]>

      वायर के साथ के पॉइंट, क्रम में

      const points = await bitbybit.occt.shapes.wire.pointsOnWireAtEqualLength({ shape: wire, length: 2, tryNext: false, includeFirst: true, includeLast: false });

    • वायर के साथ अंतरालों के दोहराए जाने वाले पैटर्न, जैसे 1, 3, 1, 3, पर पॉइंट रखता है, जब तक वायर खत्म न हो जाए।

      lengths मॉडल इकाइयों में अंतरालों का पैटर्न है, शुरुआत से दोहराया गया; includeFirst शुरुआती पॉइंट रखता है, includeLast अंतिम पॉइंट जोड़ता है, और tryNext अंतिम के बाद अगले अंतराल पर एक और पॉइंट माँगता है।

      Parameters

      Returns Promise<Point3[]>

      वायर के साथ के पॉइंट, क्रम में

      const points = await bitbybit.occt.shapes.wire.pointsOnWireAtPatternOfLengths({ shape: wire, lengths: [1, 3], tryNext: false, includeFirst: true, includeLast: false });

    • वह दिशा खोजता है जिसमें वायर एक अंश की दूरी पर जा रहा है, शुरुआत में 0 से अंत में 1 तक।

      अंश एजेस के पैरामीटर का अनुसरण करता है, दूरी का नहीं।

      Parameters

      Returns Promise<Vector3>

      स्पर्शरेखा दिशा

      const tangent = await bitbybit.occt.shapes.wire.tangentOnWireAtParam({ shape: wire, param: 0.5 });

    • वह दिशा खोजता है जिसमें वायर अपनी शुरुआत से दी गई दूरी पर जा रहा है, उसके वक्रों के साथ मॉडल इकाइयों में मापी गई।

      Parameters

      Returns Promise<Vector3>

      स्पर्शरेखा दिशा

      const tangent = await bitbybit.occt.shapes.wire.tangentOnWireAtLength({ shape: wire, length: 2.5 });

    • वायर के वक्र के पहले, दूसरे और तीसरे अवकलज उसकी शुरुआत से दी गई दूरी पर निकालता है।

      पहला अवकलज गति सहित स्पर्शरेखा है, दूसरा बताता है कि वक्र कैसे मुड़ता है, तीसरा कि वह मुड़ाव कैसे बदलता है; सभी वक्र के पैरामीटर के सापेक्ष हैं। दूरी वक्रों के साथ मॉडल इकाइयों में मापी जाती है।

      Parameters

      Returns Promise<[Vector3, Vector3, Vector3]>

      तीन अवकलज वेक्टर, पहले से तीसरे तक

      const [first, second, third] = await bitbybit.occt.shapes.wire.derivativesOnWireAtLength({ shape: wire, length: 2.5 });

    • वायर के वक्र के पहले, दूसरे और तीसरे अवकलज उसके साथ एक अंश की दूरी पर निकालता है, शुरुआत में 0 से अंत में 1 तक।

      पहला अवकलज गति सहित स्पर्शरेखा है, दूसरा बताता है कि वक्र कैसे मुड़ता है, तीसरा कि वह मुड़ाव कैसे बदलता है; सभी वक्र के पैरामीटर के सापेक्ष हैं।

      Parameters

      Returns Promise<[Vector3, Vector3, Vector3]>

      तीन अवकलज वेक्टर, पहले से तीसरे तक

      const [first, second, third] = await bitbybit.occt.shapes.wire.derivativesOnWireAtParam({ shape: wire, param: 0.5 });

    • वह पॉइंट पढ़ता है जहाँ वायर शुरू होता है, वायर की अपनी दिशा में।

      Parameters

      Returns Promise<Point3>

      आरंभ पॉइंट

      const start = await bitbybit.occt.shapes.wire.startPointOnWire({ shape: wire });

    • वायर की पैरामीटर रेंज के आधे रास्ते पर स्थित पॉइंट खोजता है।

      पैरामीटर एजेस के अपने वक्रों का अनुसरण करता है, दूरी का नहीं, इसलिए असमान एजेस वाले वायर पर यह हमेशा लंबाई के हिसाब से मध्य नहीं होता; getWireLength के आधे के साथ pointOnWireAtLength वह देता है।

      Parameters

      Returns Promise<Point3>

      पैरामीटर 0.5 पर स्थित पॉइंट

      const middle = await bitbybit.occt.shapes.wire.midPointOnWire({ shape: wire });

    • वह पॉइंट पढ़ता है जहाँ वायर खत्म होता है, वायर की अपनी दिशा में।

      Parameters

      Returns Promise<Point3>

      अंत पॉइंट

      const end = await bitbybit.occt.shapes.wire.endPointOnWire({ shape: wire });

    extract from wires

    • कई वायर पर एक ही सेटिंग से divideWireByParamsToPoints चलाता है।

      Parameters

      • inputs: DivideShapesDto<TopoDSWirePointer>

        वायर, विभाजनों की संख्या और क्या अंत पॉइंट छोड़ने हैं

      Returns Promise<Point3[][]>

      प्रत्येक वायर के लिए पॉइंट की एक सूची, उसी क्रम में

      const lists = await bitbybit.occt.shapes.wire.divideWiresByParamsToPoints({ shapes: wires, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });

    • कई वायर पर एक ही सेटिंग से divideWireByEqualDistanceToPoints चलाता है।

      Parameters

      • inputs: DivideShapesDto<TopoDSWirePointer>

        वायर, विभाजनों की संख्या और क्या अंत पॉइंट छोड़ने हैं

      Returns Promise<Point3[][]>

      प्रत्येक वायर के लिए पॉइंट की एक सूची, उसी क्रम में

      const lists = await bitbybit.occt.shapes.wire.divideWiresByEqualDistanceToPoints({ shapes: wires, nrOfDivisions: 10, removeStartPoint: false, removeEndPoint: false });

    from base

    • { start, end } रूप के लाइन ऑब्जेक्ट से सीधा एक-एज वायर बनाता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      सीधा वायर

      const wire = await bitbybit.occt.shapes.wire.fromBaseLine({ line: { start: [0, 0, 0], end: [10, 0, 0] } });

    • { start, end } रूप के हर लाइन ऑब्जेक्ट के लिए एक सीधा एक-एज वायर बनाता है।

      Parameters

      Returns Promise<TopoDSWirePointer[]>

      प्रत्येक लाइन के लिए एक वायर, उसी क्रम में

      const wires = await bitbybit.occt.shapes.wire.fromBaseLines({ lines: [{ start: [0, 0, 0], end: [10, 0, 0] }, { start: [10, 0, 0], end: [10, 10, 0] }] });

    • खंड, पॉइंट के युग्म [start, end], से सीधा एक-एज वायर बनाता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      सीधा वायर

      const wire = await bitbybit.occt.shapes.wire.fromBaseSegment({ segment: [[0, 0, 0], [10, 0, 0]] });

    • हर खंड, हर एक पॉइंट का युग्म [start, end], के लिए एक सीधा एक-एज वायर बनाता है।

      Parameters

      Returns Promise<TopoDSWirePointer[]>

      प्रत्येक सेगमेंट के लिए एक वायर, उसी क्रम में

      const wires = await bitbybit.occt.shapes.wire.fromBaseSegments({ segments: [[[0, 0, 0], [10, 0, 0]], [[10, 0, 0], [10, 10, 0]]] });

    • पॉइंट की सूची को क्रम में सीधे एजेस से जोड़कर एक वायर बनाता है।

      दो से कम पॉइंट पर त्रुटि आती है। जब अंतिम पॉइंट पहले को दोहराता है, तो दोहराव हटा दिया जाता है और वायर वापस पहले पॉइंट तक बंद कर दिया जाता है; अन्यथा वायर खुला रहता है। किसी पॉइंट को दोहराए बिना बंद बाहरी रेखा के लिए createPolygonWire का उपयोग करें।

      Parameters

      Returns Promise<TopoDSWirePointer>

      पॉइंट से होकर जाने वाला वायर

      const path = await bitbybit.occt.shapes.wire.fromPoints({ points: [[0, 0, 0], [10, 0, 0], [10, 10, 0]] });
      const outline = await bitbybit.occt.shapes.wire.fromPoints({ points: [[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 0, 0]] });

    • पॉलीलाइन ऑब्जेक्ट से वायर बनाता है, प्रति खंड एक सीधा एज; बंद चिह्नित पॉलीलाइन को उसके अंतिम पॉइंट से वापस पहले तक का एज भी मिलता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      वायर

      const outline = await bitbybit.occt.shapes.wire.fromBasePolyline({ polyline: { points: [[0, 0, 0], [10, 0, 0], [10, 0, 10]], isClosed: true } });

    • तीन पॉइंट के रूप में दिए गए त्रिभुज से बंद तीन-एज वायर बनाता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      बंद वायर

      const outline = await bitbybit.occt.shapes.wire.fromBaseTriangle({ triangle: [[0, 0, 0], [10, 0, 0], [0, 0, 10]] });

    • मेश के हर त्रिभुज के लिए एक बंद तीन-एज वायर बनाता है।

      जिस त्रिभुज का वायर नहीं बनाया जा सकता उसे बाकी को रोकने के बजाय चेतावनी के साथ छोड़ दिया जाता है।

      Parameters

      • inputs: MeshBaseDto

        मेश, त्रिभुजों की सूची के रूप में

      Returns Promise<TopoDSWirePointer[]>

      प्रत्येक ऐसे त्रिभुज के लिए एक वायर जिसे बनाया जा सका

      const outlines = await bitbybit.occt.shapes.wire.fromBaseMesh({ mesh: triangles });

    get

    • शेप में से एक वायर उसकी स्थिति से चुनता है, 0 से गिनते हुए, उस क्रम में जिसमें कर्नेल शेप पर चलता है।

      शेप वायर या वायर से बनी कोई चीज़ होना चाहिए; अंतिम वायर से आगे का इंडेक्स त्रुटि फेंकता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      उस इंडेक्स पर वायर

      const outer = await bitbybit.occt.shapes.wire.getWire({ shape: face, index: 0 });

    • शेप के हर वायर को उस क्रम में सूचीबद्ध करता है जिसमें कर्नेल उस पर चलता है।

      Parameters

      Returns Promise<TopoDSWirePointer[]>

      शेप में मिले वायर

      const wires = await bitbybit.occt.shapes.wire.getWires({ shape: face });

    • वायर का द्रव्यमान केंद्र, उसके वक्रों का संतुलन बिंदु, खोजता है; वृत्त के लिए वह उसका केंद्र है, वायर से ही बाहर।

      Parameters

      Returns Promise<Point3>

      द्रव्यमान केंद्र का पॉइंट

      const center = await bitbybit.occt.shapes.wire.getWireCenterOfMass({ shape: wire });

    • सूची के हर वायर का द्रव्यमान केंद्र खोजता है।

      Parameters

      Returns Promise<Point3[]>

      प्रत्येक वायर के लिए एक पॉइंट, उसी क्रम में

      const centers = await bitbybit.occt.shapes.wire.getWiresCentersOfMass({ shapes: wires });

    • वायर की दिशा पलटता है, ताकि उसकी शुरुआत उसका अंत बन जाए।

      एजेस अपना क्रम और दिशा फ़्लैग रखते हैं; वायर पूरे तौर पर उल्टा चिह्नित होता है, जो अधिकांश ऑपरेशन पढ़ते हैं। reversedWireFromReversedEdges इसके बजाय वायर को एज दर एज फिर से बनाता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      विपरीत दिशा में जाने वाला एक नया वायर

      const back = await bitbybit.occt.shapes.wire.reversedWire({ shape: wire });

    • हर एज को उलटकर और उन्हें विपरीत क्रम में फिर से जोड़कर वायर की दिशा पलटता है।

      परिणाम ऐसा वायर है जो पूरी तरह दूसरी दिशा में चलता है, जो कुछ ऑपरेशनों को वहाँ चाहिए जहाँ सादा reversedWire फ़्लैग पर्याप्त नहीं।

      Parameters

      Returns Promise<TopoDSWirePointer>

      विपरीत दिशा में जाने वाला एक नया वायर

      const back = await bitbybit.occt.shapes.wire.reversedWireFromReversedEdges({ shape: wire });

    • बताता है कि वायर बंद है या नहीं, जो तब है जब उसके शुरुआती और अंतिम पॉइंट एक छोटी टॉलरेंस के भीतर एक ही जगह हों।

      Parameters

      Returns Promise<boolean>

      true जब सिरे मिलते हों

      const wireIsClosed = await bitbybit.occt.shapes.wire.isWireClosed({ shape: wire });

    • वायर की लंबाई उसके वक्रों के साथ, मॉडल इकाइयों में मापता है।

      Parameters

      Returns Promise<number>

      लंबाई

      const len = await bitbybit.occt.shapes.wire.getWireLength({ shape: wire });

    • सूची के हर वायर की लंबाई उसके वक्रों के साथ, मॉडल इकाइयों में मापता है।

      Parameters

      Returns Promise<number[]>

      प्रत्येक वायर के लिए एक लंबाई, उसी क्रम में

      const lengths = await bitbybit.occt.shapes.wire.getWiresLengths({ shapes: wires });

    multiple

    • प्रति पॉइंट सूची एक बंद बहुभुज वायर बनाता है, जैसे createPolygonWire करता है।

      returnCompound true होने पर वायर सूची के बजाय एक कंपाउंड शेप में पैक किए जाते हैं।

      Parameters

      • inputs: PolygonsDto

        बहुभुज और क्या उन्हें एक कंपाउंड में पैक करना है

      Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>

      वायर क्रम में, या उन्हें रखने वाला एक कंपाउंड

      const outlines = await bitbybit.occt.shapes.wire.createPolygons({
          polygons: [{ points: [[0, 0, 0], [5, 0, 0], [5, 0, 5]] }, { points: [[10, 0, 0], [15, 0, 0], [15, 0, 5]] }],
          returnCompound: false,
      });

    • प्रति लाइन परिभाषा एक सीधा एक-एज वायर बनाता है।

      returnCompound true होने पर वायर सूची के बजाय एक कंपाउंड शेप में पैक किए जाते हैं।

      Parameters

      • inputs: Bit.Inputs.OCCT.LinesDto

        लाइनें और क्या उन्हें एक कंपाउंड में पैक करना है

      Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>

      वायर क्रम में, या उन्हें रखने वाला एक कंपाउंड

      const lines = await bitbybit.occt.shapes.wire.createLines({
          lines: [{ start: [0, 0, 0], end: [10, 0, 0] }, { start: [0, 0, 5], end: [10, 0, 5] }],
          returnCompound: false,
      });

    • प्रति पॉइंट सूची एक खुला पॉलीलाइन वायर बनाता है, जैसे createPolylineWire करता है।

      returnCompound true होने पर वायर सूची के बजाय एक कंपाउंड शेप में पैक किए जाते हैं।

      Parameters

      • inputs: Bit.Inputs.OCCT.PolylinesDto

        पॉलीलाइनें और क्या उन्हें एक कंपाउंड में पैक करना है

      Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>

      वायर क्रम में, या उन्हें रखने वाला एक कंपाउंड

      const paths = await bitbybit.occt.shapes.wire.createPolylines({
          polylines: [{ points: [[0, 0, 0], [5, 0, 0], [5, 0, 5]] }, { points: [[10, 0, 0], [15, 0, 0]] }],
          returnCompound: false,
      });

    • प्रति परिभाषा एक Bezier वायर बनाता है, जैसे createBezier करता है।

      returnCompound true होने पर वायर सूची के बजाय एक कंपाउंड शेप में पैक किए जाते हैं।

      Parameters

      • inputs: BezierWiresDto

        Bezier परिभाषाएँ और क्या उन्हें एक कंपाउंड में पैक करना है

      Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>

      वायर क्रम में, या उन्हें रखने वाला एक कंपाउंड

      const curves = await bitbybit.occt.shapes.wire.createBezierWires({
          bezierWires: [{ points: [[0, 0, 0], [5, 0, 10], [10, 0, 0]], closed: false }, { points: [[0, 0, 5], [5, 0, 15], [10, 0, 5]], closed: false }],
          returnCompound: false,
      });

    • प्रति परिभाषा एक इंटरपोलेटेड B-spline वायर बनाता है, जैसे interpolatePoints करता है।

      returnCompound true होने पर वायर सूची के बजाय एक कंपाउंड शेप में पैक किए जाते हैं।

      Parameters

      • inputs: InterpolateWiresDto

        इंटरपोलेशन परिभाषाएँ और क्या उन्हें एक कंपाउंड में पैक करना है

      Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>

      वायर क्रम में, या उन्हें रखने वाला एक कंपाउंड

      const curves = await bitbybit.occt.shapes.wire.interpolateWires({
          interpolations: [{ points: [[0, 0, 0], [5, 0, 5], [10, 0, 0]], periodic: false, tolerance: 1e-7 }, { points: [[0, 0, 5], [5, 0, 10], [10, 0, 5]], periodic: false, tolerance: 1e-7 }],
          returnCompound: false,
      });

    • प्रति परिभाषा एक सन्निकटन करने वाला B-spline वायर बनाता है, जैसे createBSpline करता है।

      returnCompound true होने पर वायर सूची के बजाय एक कंपाउंड शेप में पैक किए जाते हैं।

      Parameters

      • inputs: BSplinesDto

        B-spline परिभाषाएँ और क्या उन्हें एक कंपाउंड में पैक करना है

      Returns Promise<TopoDSCompoundPointer | TopoDSWirePointer[]>

      वायर क्रम में, या उन्हें रखने वाला एक कंपाउंड

      const curves = await bitbybit.occt.shapes.wire.createBSplines({
          bSplines: [{ points: [[0, 0, 0], [5, 0, 5], [10, 0, 0]], closed: false }, { points: [[0, 0, 5], [5, 0, 10], [10, 0, 5]], closed: false }],
          returnCompound: false,
      });

    place

    • ग्राउंड प्लेन पर खींचे गए सपाट वायर को फेस की सतह पर मैप करता है, मानो ड्रॉइंग उसके चारों ओर लपेटी गई हो।

      वायर का Z निर्देशांक U के रूप में और X निर्देशांक V के रूप में पढ़ा जाता है, फेस के वास्तविक UV मानों में, जिन्हें shapes.face.getUMinBound और उसके साथी बताते हैं; उन सीमाओं के भीतर समाने वाली ड्रॉइंग फेस पर उतरती है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      फेस की सतह पर रखा वायर

      const onSurface = await bitbybit.occt.shapes.wire.placeWireOnFace({ wire: flatWire, face: cylinderFace });

    • ग्राउंड प्लेन पर खींचे गए कई सपाट वायर को फेस की सतह पर मैप करता है, जैसे placeWireOnFace एक के लिए करता है।

      Parameters

      Returns Promise<TopoDSWirePointer[]>

      फेस की सतह पर रखे वायर, उसी क्रम में

      const onSurface = await bitbybit.occt.shapes.wire.placeWiresOnFace({ wires: flatWires, face: cylinderFace });

    • वायर को एक दिशा में शेप पर प्रक्षेपित करता है, जैसे उसकी छाया सतह पर डालना।

      परिणाम उन वक्रों का कंपाउंड है जहाँ प्रक्षेपण शेप के फेसेस से मिलता है, जो उसके निकट और दूर दोनों ओर हो सकते हैं। इससे shapes.face.createFaceFromWireOnFace के ज़रिए फेस काटें या इसे पथ के रूप में उपयोग करें।

      Parameters

      Returns Promise<TopoDSCompoundPointer>

      प्रोजेक्ट किए गए कर्व का एक कंपाउंड

      const shadow = await bitbybit.occt.shapes.wire.project({ wire: circle, shape: sphere, direction: [0, -1, 0] });

    • कई वायर को एक दिशा में शेप पर प्रक्षेपित करता है, जैसे project एक के लिए करता है।

      Parameters

      Returns Promise<TopoDSCompoundPointer[]>

      प्रत्येक वायर के लिए प्रोजेक्ट किए गए कर्व का एक कंपाउंड, उसी क्रम में

      const shadows = await bitbybit.occt.shapes.wire.projectWires({ wires: [circle, square], shape: sphere, direction: [0, -1, 0] });

    primitives

    • पूरा वृत्त एक बंद एक-एज वायर के रूप में बनाता है, उस प्लेन में स्थित जिसका नॉर्मल direction है; डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।

      Parameters

      • inputs: Bit.Inputs.OCCT.CircleDto

        त्रिज्या, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      वृत्त वायर

      const circle = await bitbybit.occt.shapes.wire.createCircleWire({ radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });

    • ग्राउंड प्लेन पर एक आयत को बंद षट्भुज वायर की ग्रिड से भरता है, मूल बिंदु पर केंद्रित।

      षट्भुज इस तरह स्केल किए जाते हैं कि nrHexagonsInWidth width के आर-पार और nrHexagonsInHeight height के आर-पार समाएँ। स्केल, फिलेट और समावेशन पैटर्न षट्भुज दर षट्भुज पढ़े जाते हैं और दोहराते हैं; extend फ़्लैग बाहरी पंक्तियों को किनारों के पार खींचते हैं ताकि आयत ढक जाए।

      Parameters

      • inputs: HexagonsInGridDto

        आयत का आकार, षट्भुजों की संख्याएँ, विस्तार फ़्लैग और वैकल्पिक पैटर्न

      Returns Promise<TopoDSWirePointer[]>

      प्रत्येक षट्भुज के लिए एक वायर, पंक्ति दर पंक्ति

      const cells = await bitbybit.occt.shapes.wire.hexagonsInGrid({
          width: 20,
          height: 10,
          nrHexagonsInWidth: 8,
          nrHexagonsInHeight: 4,
          flatTop: false,
          scalePatternWidth: [0.9],
          scalePatternHeight: [0.9],
      });

    • center पर केंद्रित बंद वर्ग वायर बनाता है।

      direction उसके प्लेन का नॉर्मल है: डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।

      Parameters

      • inputs: Bit.Inputs.OCCT.SquareDto

        भुजा की लंबाई, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      वर्ग वायर

      const square = await bitbybit.occt.shapes.wire.createSquareWire({ size: 10, center: [0, 0, 0], direction: [0, 1, 0] });

    • numRays नोकों वाला बंद तारे के आकार का वायर बनाता है।

      नोकें outerRadius तक पहुँचती हैं और उनके बीच के खाँचे innerRadius तक; offsetOuterEdges किरणों की नोकों को उस दूरी से प्लेन से बाहर उठाता है, जिससे 3D तारा बनता है, और half किरणों का पहला आधा खुले वायर के रूप में रखता है। यह ज़मीन पर सपाट रहता है जब तक direction कुछ और न कहे।

      Parameters

      • inputs: Bit.Inputs.OCCT.StarDto

        दो त्रिज्याएँ, किरणों की संख्या, केंद्र, प्लेन का नॉर्मल और विकल्प

      Returns Promise<TopoDSWirePointer>

      तारा वायर

      const star = await bitbybit.occt.shapes.wire.createStarWire({ outerRadius: 5, innerRadius: 2, numRays: 5, center: [0, 0, 0], direction: [0, 1, 0], offsetOuterEdges: 0, half: false });

    • शैलीकृत क्रिसमस ट्री के आकार का बंद वायर बनाता है: शाखाओं की nrSkirts परतें, तने की रेखा से outerDist से innerDist तक सिकुड़ती हुई, trunkHeight और trunkWidth के तने पर।

      यहाँ के अन्य समतल शेप्स के विपरीत यह XY प्लेन में सीधा खड़ा होता है, नोक Y के साथ; direction तने-से-नोक की दिशा है, rotation उसे उस अक्ष के चारों ओर घुमाता है, डिग्री में।

      Parameters

      • inputs: ChristmasTreeDto

        पेड़ के अनुपात, तने का आकार, विकल्प, मूल बिंदु और तने से शीर्ष की दिशा

      Returns Promise<TopoDSWirePointer>

      पेड़ का वायर

      const tree = await bitbybit.occt.shapes.wire.createChristmasTreeWire({
          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],
      });

    • nrCorners कोनों वाला बंद नियमित बहुभुज वायर बनाता है, सभी radius के वृत्त पर।

      direction प्लेन का नॉर्मल है; डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।

      Parameters

      • inputs: NGonWireDto

        कोनों की संख्या, त्रिज्या, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      बहुभुज वायर

      const hexagon = await bitbybit.occt.shapes.wire.createNGonWire({ nrCorners: 6, radius: 5, center: [0, 0, 0], direction: [0, 1, 0] });

    • बंद समांतर चतुर्भुज वायर बनाता है: width और height का आयत जिसकी भुजाएँ angle डिग्री से झुकी हैं।

      aroundCenter true होने पर शेप center पर केंद्रित होता है; अन्यथा वह वहाँ से शुरू होकर धनात्मक दिशाओं में फैलता है। direction प्लेन का नॉर्मल है; डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।

      Parameters

      • inputs: ParallelogramDto

        चौड़ाई, ऊँचाई, झुकाव का कोण, क्या उसे केंद्रित करना है, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      समांतर चतुर्भुज वायर

      const shape = await bitbybit.occt.shapes.wire.createParallelogramWire({ width: 10, height: 5, angle: 30, aroundCenter: true, center: [0, 0, 0], direction: [0, 1, 0] });

    • दो चिकने आधों का बंद दिल के आकार का वायर बनाता है जो लगभग sizeApprox के वर्ग में समाता है।

      rotation उसे उसके प्लेन में घुमाता है, डिग्री में। direction प्लेन का नॉर्मल है; डिफ़ॉल्ट [0, 1, 0] उसे ज़मीन पर सपाट बिछाता है।

      Parameters

      • inputs: Heart2DDto

        अनुमानित आकार, रोटेशन, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      हृदय वायर

      const heart = await bitbybit.occt.shapes.wire.createHeartWire({ sizeApprox: 10, rotation: 0, center: [0, 0, 0], direction: [0, 1, 0] });

    • center पर केंद्रित बंद आयत वायर बनाता है।

      ग्राउंड प्लेन पर width X के साथ और length Z के साथ चलता है; direction प्लेन का नॉर्मल है, और डिफ़ॉल्ट [0, 1, 0] वायर को ज़मीन पर सपाट रखता है।

      Parameters

      • inputs: Bit.Inputs.OCCT.RectangleDto

        चौड़ाई, लंबाई, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      आयत वायर

      const rectangle = await bitbybit.occt.shapes.wire.createRectangleWire({ width: 20, length: 10, center: [0, 0, 0], direction: [0, 1, 0] });

    • बंद L-आकार का वायर बनाता है: एक कोने पर जुड़ी दो आयताकार भुजाएँ।

      पहली भुजा में widthFirst और lengthFirst हैं, दूसरी में widthSecond और lengthSecond; align कोने को भुजाओं के बाहर, भीतर या बीच में रखता है, और rotation शेप को उसके प्लेन में घुमाता है, डिग्री में। यह ज़मीन पर सपाट रहता है जब तक direction कुछ और न कहे।

      Parameters

      • inputs: LPolygonDto

        दोनों भुजाओं के आकार, अलाइनमेंट, रोटेशन, केंद्र और प्लेन का नॉर्मल

      Returns Promise<TopoDSWirePointer>

      L-आकार का वायर

      const outline = await bitbybit.occt.shapes.wire.createLPolygonWire({
          widthFirst: 2,
          lengthFirst: 10,
          widthSecond: 2,
          lengthSecond: 6,
          align: Bit.Inputs.OCCT.directionEnum.outside,
          rotation: 0,
          center: [0, 0, 0],
          direction: [0, 1, 0],
      });

    • पूरा दीर्घवृत्त एक बंद एक-एज वायर के रूप में बनाता है, उस प्लेन में स्थित जिसका नॉर्मल direction है।

      radiusMajor radiusMinor से छोटा नहीं होना चाहिए, अन्यथा कर्नेल दीर्घवृत्त को अस्वीकार करता है; डिफ़ॉल्ट दिशा [0, 1, 0] उसे ज़मीन पर सपाट बिछाती है।

      Parameters

      • inputs: Bit.Inputs.OCCT.EllipseDto

        केंद्र, प्लेन का नॉर्मल और दो त्रिज्याएँ

      Returns Promise<TopoDSWirePointer>

      दीर्घवृत्त वायर

      const ellipse = await bitbybit.occt.shapes.wire.createEllipseWire({ center: [0, 0, 0], direction: [0, 1, 0], radiusMinor: 3, radiusMajor: 6 });

    • हेलिक्स वायर बनाता है, स्थिर radius की कुंडली जो height तक पहुँचने तक प्रति चक्कर pitch मॉडल इकाइयाँ चढ़ती है।

      यह center के बगल से शुरू होकर direction के साथ चढ़ती है; clockwise वाइंडिंग उलटता है। हेलिक्स का tolerance के भीतर चिकने वक्र से सन्निकटन किया जाता है। 0 या उससे कम की त्रिज्या, पिच या ऊँचाई null वायर देती है।

      Parameters

      • inputs: HelixWireDto

        त्रिज्या, पिच, ऊँचाई, आधार का केंद्र, अक्ष की दिशा, वाइंडिंग और टॉलरेंस

      Returns Promise<TopoDSWirePointer>

      हेलिक्स वायर

      const spring = await bitbybit.occt.shapes.wire.createHelixWire({ radius: 2, pitch: 1, height: 10, center: [0, 0, 0], direction: [0, 1, 0], clockwise: false, tolerance: 1e-4 });

    • createHelixWire जैसा हेलिक्स वायर बनाता है, पर ऊँचाई के बजाय numTurns से आकार तय होता है: कुंडली प्रति चक्कर pitch मॉडल इकाइयाँ चढ़ती है, numTurns बार।

      Parameters

      • inputs: HelixWireByTurnsDto

        त्रिज्या, पिच, चक्करों की संख्या, आधार का केंद्र, अक्ष की दिशा, वाइंडिंग और टॉलरेंस

      Returns Promise<TopoDSWirePointer>

      हेलिक्स वायर

      const spring = await bitbybit.occt.shapes.wire.createHelixWireByTurns({ radius: 2, pitch: 1, numTurns: 5, center: [0, 0, 0], direction: [0, 1, 0], clockwise: false, tolerance: 1e-4 });

    • शंक्वाकार हेलिक्स वायर बनाता है जिसकी त्रिज्या आधार पर startRadius से शीर्ष पर endRadius तक समान रूप से बदलती है, height तक पहुँचने तक प्रति चक्कर pitch मॉडल इकाइयाँ चढ़ते हुए।

      यह center के बगल से शुरू होकर direction के साथ चढ़ती है; clockwise वाइंडिंग उलटता है। वक्र का tolerance के भीतर सन्निकटन किया जाता है।

      Parameters

      • inputs: TaperedHelixWireDto

        आरंभ और अंत त्रिज्याएँ, पिच, ऊँचाई, आधार का केंद्र, अक्ष की दिशा, वाइंडिंग और टॉलरेंस

      Returns Promise<TopoDSWirePointer>

      पतला होता हेलिक्स वायर

      const cone = await bitbybit.occt.shapes.wire.createTaperedHelixWire({ startRadius: 3, endRadius: 0.5, pitch: 1, height: 8, center: [0, 0, 0], direction: [0, 1, 0], clockwise: false, tolerance: 1e-4 });

    • उस प्लेन में सपाट सर्पिल वायर बनाता है जिसका नॉर्मल direction है: numTurns चक्कर जिनकी त्रिज्या startRadius से endRadius तक समान रूप से बढ़ती है।

      डिफ़ॉल्ट दिशा [0, 1, 0] उसे ज़मीन पर सपाट बिछाती है; clockwise वाइंडिंग उलटता है, और वक्र का tolerance के भीतर सन्निकटन किया जाता है।

      Parameters

      • inputs: FlatSpiralWireDto

        आरंभ और अंत त्रिज्याएँ, चक्करों की संख्या, केंद्र, प्लेन का नॉर्मल, वाइंडिंग और टॉलरेंस

      Returns Promise<TopoDSWirePointer>

      सर्पिल वायर

      const spiral = await bitbybit.occt.shapes.wire.createFlatSpiralWire({ startRadius: 0.5, endRadius: 5, numTurns: 4, center: [0, 0, 0], direction: [0, 1, 0], clockwise: false, tolerance: 1e-4 });

    • ग्राउंड प्लेन पर एकल-रेखा Hershey simplex फ़ॉन्ट में टेक्स्ट को स्ट्रोक वायर के रूप में लिखता है, प्रति पेन स्ट्रोक एक खुला पॉलीलाइन वायर।

      height मॉडल इकाइयों में बड़े अक्षर की ऊँचाई है, lineSpacing और letterSpacing उसके गुणज हैं, align अलग लंबाई की पंक्तियों को संरेखित करता है, और centerOnOrigin ब्लॉक को मूल बिंदु पर ले जाता है।

      Parameters

      • inputs: TextWiresDto

        टेक्स्ट, उसका आकार और स्पेसिंग, अलाइनमेंट और प्लेसमेंट विकल्प

      Returns Promise<TopoDSWirePointer[]>

      प्रत्येक स्ट्रोक के लिए एक वायर, लेखन क्रम में

      const strokes = await bitbybit.occt.shapes.wire.textWires({
          text: "Hello",
          height: 5,
          lineSpacing: 1.5,
          letterSpacing: 0,
          align: Bit.Inputs.Base.horizontalAlignEnum.left,
          centerOnOrigin: true,
      });

    • textWires की तरह टेक्स्ट को स्ट्रोक वायर के रूप में लिखता है और उन्हें कंपाउंड में पैक करता है, साथ में ब्लॉक का आकार।

      परिणाम में compound पूरे टेक्स्ट के साथ, characters लेखन क्रम में प्रति अक्षर एक कंपाउंड के साथ, width और height X के साथ और Z के साथ ब्लॉक के विस्तार के रूप में, और center ब्लॉक के मध्य के रूप में होते हैं।

      Parameters

      • inputs: TextWiresDto

        टेक्स्ट, उसका आकार और स्पेसिंग, अलाइनमेंट और प्लेसमेंट विकल्प

      Returns Promise<TextWiresDataDto<TopoDSCompoundPointer>>

      टेक्स्ट कंपाउंड, अक्षरों के कंपाउंड और मापा गया आकार

      const text = await bitbybit.occt.shapes.wire.textWiresWithData({
          text: "Hi",
          height: 5,
          lineSpacing: 1.5,
          letterSpacing: 0,
          align: Bit.Inputs.Base.horizontalAlignEnum.left,
          centerOnOrigin: false,
      });
      console.log(text.width, text.height, text.characters.length);

    rebuild

    • वायर के हर एज को दी गई डिग्री के B-spline के रूप में, एक टॉलरेंस के भीतर, फिर से बनाता है और परिणामों को वापस एक वायर में जोड़ता है।

      डिग्री घटाना वक्रों को सरल करता है, बढ़ाना बाद के ऑपरेशनों को अधिक स्वतंत्रता देता है; दोनों ही स्थितियों में हर नया वक्र पुराने के tolerance के भीतर रहता है।

      Parameters

      • inputs: RebuildCurveDegreeDto<TopoDSWirePointer>

        वायर, वह डिग्री जिस पर पुनर्निर्माण करना है और टॉलरेंस

      Returns Promise<TopoDSWirePointer>

      पुनर्निर्मित एजेस वाला एक नया वायर

      const simpler = await bitbybit.occt.shapes.wire.rebuildWireDegree({ shape: wire, degree: 3, tolerance: 1e-3 });

    seam

    • बंद आवर्ती वायर की सीम, वह पॉइंट जहाँ वह शुरू और खत्म होता है, को उसके वक्र पर दिए गए पैरामीटर तक ले जाता है।

      ज्यामिति नहीं बदलती; केवल यह कि वायर कहाँ से शुरू माना जाता है। वृत्त जैसे एक-एज वायर के लिए है: हर आवर्ती एज हिलाया जाता है, जो एजेस आवर्ती नहीं हैं वे जैसे हैं वैसे रहते हैं।

      Parameters

      Returns Promise<TopoDSWirePointer>

      सीम से शुरू होने वाला एक नया वायर

      const rotated = await bitbybit.occt.shapes.wire.moveWireSeamByParameter({ shape: circle, parameter: 1.57 });

    • बंद आवर्ती वायर की सीम, वह पॉइंट जहाँ वह शुरू और खत्म होता है, को उसकी वर्तमान शुरुआत से वक्र के साथ एक दूरी तक ले जाता है।

      ज्यामिति नहीं बदलती; केवल यह कि वायर कहाँ से शुरू माना जाता है। वृत्त जैसे एक-एज वायर के लिए है: हर आवर्ती एज हिलाया जाता है, जो एजेस आवर्ती नहीं हैं वे जैसे हैं वैसे रहते हैं।

      Parameters

      Returns Promise<TopoDSWirePointer>

      सीम से शुरू होने वाला एक नया वायर

      const rotated = await bitbybit.occt.shapes.wire.moveWireSeamByLength({ shape: circle, length: 2.5 });

    via points

    • कोने के पॉइंट की सूची से होकर सीधे एजेस का बंद वायर बनाता है, अंतिम पॉइंट से वापस पहले तक का एज जोड़ते हुए।

      पॉइंट का एक प्लेन में होना ज़रूरी नहीं; हालाँकि समतल फेस को समतल बाहरी रेखा चाहिए।

      Parameters

      • inputs: PolygonDto

        कोने के पॉइंट, क्रम में

      Returns Promise<TopoDSWirePointer>

      बंद वायर

      const square = await bitbybit.occt.shapes.wire.createPolygonWire({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10], [0, 0, 10]] });

    • दो पॉइंट के बीच सीधा एक-एज वायर बनाता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      सीधा वायर

      const line = await bitbybit.occt.shapes.wire.createLineWire({ start: [0, 0, 0], end: [10, 0, 0] });

    • दो पॉइंट के बीच सीधा एक-एज वायर बनाता है और उसे उनमें से हर एक के पार लंबा करता है।

      extensionStart और extensionEnd मॉडल इकाइयों में वे दूरियाँ हैं जो लाइन के साथ शुरुआत और अंत के पार जोड़ी जाती हैं; दोनों पॉइंट अलग होने चाहिए, अन्यथा त्रुटि फेंकी जाती है।

      Parameters

      • inputs: LineWithExtensionsDto

        आरंभ और अंत पॉइंट और दो विस्तार लंबाइयाँ

      Returns Promise<TopoDSWirePointer>

      बढ़ाया गया सीधा वायर

      const longer = await bitbybit.occt.shapes.wire.createLineWireWithExtensions({ start: [0, 0, 0], end: [10, 0, 0], extensionStart: 2, extensionEnd: 5 });

    • पॉइंट की सूची से होकर, क्रम में, सीधे एजेस का खुला वायर बनाता है।

      वायर बंद नहीं होता; createPolygonWire पहले पॉइंट तक वापस एज जोड़ता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      खुला वायर

      const path = await bitbybit.occt.shapes.wire.createPolylineWire({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10]] });

    • कंट्रोल पॉइंट से संचालित चिकना Bezier वायर बनाता है: वह पहले पॉइंट से शुरू होता है, अंतिम पर खत्म होता है और बीच वालों की ओर बिना उनसे गुज़रे खिंचता है।

      closed पहला पॉइंट फिर से जोड़ता है ताकि सिरे मिलें; periodic इसके बजाय ऐसा बंद वक्र बनाता है जो सीम के आर-पार चिकना है। degree सीमित करता है कि हर हिस्से को कितने पड़ोसी आकार देते हैं।

      Parameters

      • inputs: BezierDto

        नियंत्रण पॉइंट और बंद करने और डिग्री के विकल्प

      Returns Promise<TopoDSWirePointer>

      Bezier वायर

      const curve = await bitbybit.occt.shapes.wire.createBezier({ points: [[0, 0, 0], [5, 0, 10], [10, 0, -10], [15, 0, 0]], closed: false, periodic: false });

    • createBezier जैसा Bezier वायर बनाता है, प्रति कंट्रोल पॉइंट एक भार के साथ जो बताता है कि वह वक्र को कितनी ज़ोर से खींचता है।

      1 से ऊपर का भार वक्र को अपने पॉइंट की ओर खींचता है, 1 से नीचे उसे छोड़ देता है। भार पॉइंट से मेल खाने चाहिए: वही गिनती, या closed true और periodic false होने पर एक अधिक, क्योंकि पहला पॉइंट दोहराया जाता है।

      Parameters

      • inputs: BezierWeightsDto

        नियंत्रण पॉइंट, उनके भार और बंद करने और डिग्री के विकल्प

      Returns Promise<TopoDSWirePointer>

      भारित Bezier वायर

      const curve = await bitbybit.occt.shapes.wire.createBezierWeights({
          points: [[0, 0, 0], [5, 0, 10], [10, 0, 0]],
          weights: [1, 3, 1],
          closed: false,
          periodic: false,
      });

    • चिकना B-spline वायर बनाता है जो हर पॉइंट से क्रम में गुज़रता है।

      periodic वक्र को बंद करता है ताकि वह सीम के आर-पार चिकना रहे, जो सुंदर आकार के लूप देता है। parametrization पॉइंट के बीच की दूरी नियंत्रित करता है: centripetal पॉइंट असमान होने पर नोकों और ओवरशूट का प्रतिरोध करता है। startTangent और endTangent, या प्रति पॉइंट एक tangents प्रविष्टि, वहाँ वक्र की दिशा तय करते हैं।

      Parameters

      • inputs: InterpolationDto

        पॉइंट, क्या कर्व को बंद करना है, टॉलरेंस, पैरामीट्राइज़ेशन और वैकल्पिक स्पर्शरेखाएँ

      Returns Promise<TopoDSWirePointer>

      पॉइंट से होकर जाने वाला B-spline वायर

      const loop = await bitbybit.occt.shapes.wire.interpolatePoints({
          points: [[0, 0, 0], [10, 0, 5], [10, 0, 15], [0, 0, 10]],
          periodic: true,
          tolerance: 1e-7,
          parametrization: Bit.Inputs.OCCT.bSplineParametrizationEnum.centripetal,
      });

    • पॉइंट से होकर बंद, चिकना B-spline वायर बनाता है जिसकी आकृति जब भी पॉइंट दर्पण-सममित हों तब दर्पण-सममित होती है, बिना किसी अजीब दिखने वाले शुरुआती या अंतिम पॉइंट के।

      सादा आवर्ती interpolatePoints वर्ग या त्रिभुज जैसे सममित इनपुट के लिए अपनी सीम पर तिरछा दिख सकता है; यह रूप नहीं दिखता। अगर पॉइंट इंटरपोलेट नहीं किए जा सकते तो यह त्रुटि के साथ विफल होता है।

      Parameters

      Returns Promise<TopoDSWirePointer>

      बंद सममित B-spline वायर

      const rounded = await bitbybit.occt.shapes.wire.interpolatePointsSymmetric({ points: [[0, 0, 0], [10, 0, 0], [10, 0, 10], [0, 0, 10]], tolerance: 1e-7 });

    • चिकना B-spline वायर बनाता है जो पॉइंट की सूची का सन्निकटन करता है: वह उनका बारीकी से अनुसरण करता है पर हर एक से ठीक गुज़रना ज़रूरी नहीं।

      closed पहला पॉइंट फिर से जोड़ता है ताकि सिरे मिलें। फ़िट 3 और 8 के बीच की डिग्री और 0.001 मॉडल इकाइयों की टॉलरेंस उपयोग करता है; जब वक्र को पॉइंट से होकर गुज़रना ही चाहिए तब interpolatePoints का उपयोग करें।

      Parameters

      • inputs: BSplineDto

        पॉइंट और क्या कर्व को बंद करना है

      Returns Promise<TopoDSWirePointer>

      B-spline वायर

      const curve = await bitbybit.occt.shapes.wire.createBSpline({ points: [[0, 0, 0], [5, 0, 5], [10, 0, 0], [15, 0, 5]], closed: false });

    via wires

    • दो वायर के बीच उछलती ज़िग-ज़ैग लाइन खींचता है: दोनों को समान संख्या के पॉइंट में बाँटा जाता है और एक पॉलीलाइन उन पर बारी-बारी से जाती है।

      nrZigZags उछालों की संख्या तय करता है; inverse दूसरे वायर से शुरू करता है; divideByEqualDistance पॉइंट को पैरामीटर के बजाय लंबाई से फैलाता है; zigZagsPerEdge true होने पर हर एज को अपना ज़िग-ज़ैग मिलता है, इसलिए एज की गिनतियाँ मेल खानी चाहिए।

      Parameters

      Returns Promise<TopoDSWirePointer>

      ज़िग-ज़ैग वायर

      const zigzag = await bitbybit.occt.shapes.wire.createZigZagBetweenTwoWires({ wire1: lower, wire2: upper, nrZigZags: 20, inverse: false, divideByEqualDistance: true, zigZagsPerEdge: false });

    • कई वायर या एजेस के शुरुआती पॉइंट को एक नए वायर में और उनके अंतिम पॉइंट को दूसरे में जोड़ता है।

      wireType उन्हें पॉलीलाइन या चिकने इंटरपोलेटेड वक्र बनाता है, closed अंतिम पॉइंट को वापस पहले से जोड़ता है, और tolerance इंटरपोलेशन के लिए उपयोग होता है। दो से कम शेप्स त्रुटि फेंकते हैं।

      Parameters

      Returns Promise<TopoDSWirePointer[]>

      दो वायर: एक आरंभ पॉइंट से होकर, एक अंत पॉइंट से होकर

      const [starts, ends] = await bitbybit.occt.shapes.wire.createWiresBetweenStartEndPointsOfWiresAndEdges({
          shapes: [wireA, wireB, wireC],
          wireType: Bit.Inputs.OCCT.wireFromPointsTypeEnum.interpolated,
          closed: false,
          tolerance: 1e-7,
      });

    • कई वायर या एजेस को समान संख्या के पॉइंट में बाँटता है और हर स्थिति के पॉइंट को एक नए वायर में जोड़ता है, सीढ़ी के डंडों की तरह।

      nrOfDivisions चरण उससे एक अधिक डंडा देते हैं; divideByEqualDistance पॉइंट को पैरामीटर के बजाय लंबाई से फैलाता है; wireType डंडों को पॉलीलाइन या चिकने वक्र बनाता है, closed हर एक को लूप में जोड़ता है।

      Parameters

      Returns Promise<TopoDSWirePointer[]>

      प्रत्येक विभाजन पॉइंट के लिए एक वायर, शेप्स के साथ क्रम में

      const rungs = await bitbybit.occt.shapes.wire.createWiresBetweenSubdividedPointsOfWiresAndEdges({
          shapes: [rail1, rail2],
          nrOfDivisions: 10,
          divideByEqualDistance: true,
          wireType: Bit.Inputs.OCCT.wireFromPointsTypeEnum.polyline,
          closed: false,
          tolerance: 1e-7,
      });

    • एक प्लेन में स्थित दो वृत्तों के चारों ओर बंद बाहरी रेखा खींचता है, उन्हें स्पर्शरेखाओं से जोड़ते हुए: बेल्ट या कैप्सूल की आकृति।

      keepLines बाहरी स्पर्शरेखाएँ (बेल्ट) या क्रॉस होती भीतरी वाली चुनता है; circleRemainders चुनता है कि हर वृत्त का कौन-सा चाप बाहरी रेखा में रहता है। हर वृत्त वायर में एक ही एज होना चाहिए।

      Parameters

      • inputs: WireFromTwoCirclesTanDto<TopoDSWirePointer>

        दोनों वृत्त वायर, कौन-सी स्पर्शरेखा लाइनें और आर्क रखने हैं, और टॉलरेंस

      Returns Promise<TopoDSWirePointer>

      बंद बाहरी रेखा वाला वायर

      const belt = await bitbybit.occt.shapes.wire.createWireFromTwoCirclesTan({
          circle1,
          circle2,
          keepLines: Bit.Inputs.OCCT.twoSidesStrictEnum.outside,
          circleRemainders: Bit.Inputs.OCCT.fourSidesStrictEnum.outside,
          tolerance: 1e-7,
      });

    Settings

    Member Visibility

    On This Page

    Constructors
    beam profiles
    build
    debug
    edit
    extract
    extract from wires
    from base
    get
    multiple
    place
    primitives
    rebuild
    seam
    via points
    via wires