Bitbybit Docs
    Preparing search index...

    Class Polyline

    पॉलीलाइनें: पॉइंट की सूची से होकर सीधे सेगमेंट की श्रृंखलाएँ, { points, isClosed } रूप के सादे ऑब्जेक्ट के रूप में रखी गई। बंद पॉलीलाइन अपने अंतिम पॉइंट को वापस पहले से जोड़ती है। यहाँ के मेथड पॉलीलाइन को मापते हैं, उसे सेगमेंट या लाइनों में बदलते हैं, पता लगाते हैं कि पॉलीलाइनें कहाँ मिलती हैं, ढीले सेगमेंट को श्रृंखलाओं में क्रमबद्ध करते हैं और उसके कोनों के लिए फिलेट का आकार तय करते हैं। लंबाइयाँ मॉडल इकाइयों में हैं।

    Index

    Constructors

    constructor

    convert

    reverse polylineToLines polylineToSegments

    create

    create

    fillet

    maxFilletsHalfLine safestFilletRadius

    get

    length countPoints getPoints

    intersection

    twoPolylineIntersection

    intersections

    polylineSelfIntersection

    sort

    sortSegmentsIntoPolylines

    transforms

    transformPolyline

    Constructors

    convert

    • पॉइंट का क्रम उलटता है, ताकि पॉलीलाइन दूसरी दिशा में चले।

      दी गई पॉलीलाइन की अपनी पॉइंट सूची उसी जगह उलटी जाती है और एक नए पॉलीलाइन ऑब्जेक्ट के भीतर वापस दी जाती है। उदाहरण: [[0,0,0], [1,0,0], [2,0,0]] -> [[2,0,0], [1,0,0], [0,0,0]]

      Parameters

      Returns Bit.Inputs.Polyline.PolylinePropertiesDto

      उलटे क्रम में पॉइंट वाली एक पॉलीलाइन

      const back = bitbybit.polyline.reverse({ polyline: { points: [[0, 0, 0], [1, 0, 0], [2, 0, 0]] } });

    • पॉलीलाइन को लाइन ऑब्जेक्ट में बाँटता है, प्रति खंड एक, हर एक शुरुआती और अंतिम पॉइंट के साथ।

      बंद पॉलीलाइन को उसके अंतिम पॉइंट से वापस पहले तक का खंड भी मिलता है, जब तक दोनों एक ही जगह न हों। उदाहरण: तीन पॉइंट -> दो लाइनें, या बंद होने पर तीन

      Parameters

      Returns Line3[]

      प्रत्येक सेगमेंट के लिए एक लाइन, क्रम में

      const lines = bitbybit.polyline.polylineToLines({ polyline: { points: [[0, 0, 0], [1, 0, 0], [1, 1, 0]], isClosed: true } });

    • पॉलीलाइन को खंडों में बाँटता है, हर एक पॉइंट का युग्म।

      बंद पॉलीलाइन को उसके अंतिम पॉइंट से वापस पहले तक का खंड भी मिलता है, जब तक दोनों एक ही जगह न हों। दो से कम पॉइंट कोई खंड नहीं देते। उदाहरण: चार पॉइंट, बंद -> लूप के चारों ओर चार खंड

      Parameters

      Returns Segment3[]

      प्रत्येक सेगमेंट के लिए एक पॉइंट जोड़ा, क्रम में

      const segments = bitbybit.polyline.polylineToSegments({ polyline: { points: [[0, 0, 0], [1, 0, 0], [1, 1, 0]], isClosed: false } });

    create

    • पॉइंट से पॉलीलाइन ऑब्जेक्ट बनाता है, खुला या बंद।

      उदाहरण: तीन पॉइंट isClosed true के साथ -> एक त्रिभुज

      Parameters

      • inputs: PolylineCreateDto

        पॉइंट और क्या अंतिम पॉइंट वापस पहले से जुड़ता है

      Returns Bit.Inputs.Polyline.PolylinePropertiesDto

      पॉलीलाइन ऑब्जेक्ट

      const triangle = bitbybit.polyline.create({ points: [[0, 0, 0], [1, 0, 0], [1, 1, 0]], isClosed: true });

    fillet

    • पॉलीलाइन के हर कोने के लिए सबसे बड़ा फिलेट खोजता है, हर एक अपने खंडों के निकट आधे तक सीमित ताकि फिलेट कभी ओवरलैप न हों।

      बंद पॉलीलाइन में उसके सिरों के दो कोने शामिल होते हैं। तीन से कम पॉइंट खाली सूची देते हैं।

      Parameters

      Returns number[]

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

      const radii = bitbybit.polyline.maxFilletsHalfLine({
          polyline: { points: [[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]], isClosed: true },
          tolerance: 1e-7,
      });

    • एक ऐसी फिलेट त्रिज्या खोजता है जो पॉलीलाइन के हर कोने में फ़िट हो: आधे-खंड नियम के तहत प्रति-कोना अधिकतमों में सबसे छोटी।

      तीन से कम पॉइंट, या कोई भी कोना जो फिलेट की अनुमति नहीं देता, 0 देते हैं।

      Parameters

      Returns number

      वह त्रिज्या जो हर कोने में फ़िट होती है, मॉडल इकाइयों में

      const radius = bitbybit.polyline.safestFilletRadius({
          polyline: { points: [[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]], isClosed: true },
          tolerance: 1e-7,
      });

    get

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

      बंद पॉलीलाइन का बंद करने वाला खंड नहीं गिना जाता। उदाहरण: [[0,0,0], [3,0,0], [3,4,0]] -> 7

      Parameters

      Returns number

      लंबाई, मॉडल इकाइयों में

      const len = bitbybit.polyline.length({ polyline: { points: [[0, 0, 0], [3, 0, 0], [3, 4, 0]] } });

    • पॉलीलाइन के पॉइंट गिनता है।

      उदाहरण: तीन पॉइंट -> 3

      Parameters

      Returns number

      पॉइंट की संख्या

    • पॉलीलाइन से पॉइंट की सूची पढ़ता है।

      उदाहरण: { points: [[0,0,0], [1,0,0]] } -> [[0,0,0], [1,0,0]]

      Parameters

      Returns Point3[]

      उसके पॉइंट, क्रम में

    intersection

    • वे पॉइंट खोजता है जहाँ दो पॉलीलाइनें एक-दूसरे को काटती हैं, एक के हर खंड को दूसरी के हर खंड के विरुद्ध जाँचते हुए।

      टॉलरेंस से अधिक पास के कटाव एक बार रिपोर्ट किए जाते हैं। उदाहरण: X बनाती दो पॉलीलाइनें -> बीच का पॉइंट

      Parameters

      Returns Point3[]

      प्रतिच्छेदन पॉइंट; कोई न होने पर खाली

      const crossings = bitbybit.polyline.twoPolylineIntersection({
          polyline1: { points: [[0, 0, 0], [2, 2, 0]] },
          polyline2: { points: [[0, 2, 0], [2, 0, 0]] },
          tolerance: 1e-6,
      });

    intersections

    • वे पॉइंट खोजता है जहाँ पॉलीलाइन खुद को काटती है।

      पड़ोसी खंडों को एक-दूसरे के विरुद्ध नहीं जाँचा जाता, और टॉलरेंस से अधिक पास के कटाव एक बार रिपोर्ट किए जाते हैं। उदाहरण: एक आठ की आकृति -> उसका एक कटाव पॉइंट

      Parameters

      Returns Point3[]

      प्रतिच्छेदन पॉइंट; कोई न होने पर खाली

      const crossings = bitbybit.polyline.polylineSelfIntersection({
          polyline: { points: [[0, 0, 0], [2, 2, 0], [2, 0, 0], [0, 2, 0]] },
          tolerance: 1e-6,
      });

    sort

    • टॉलरेंस के भीतर मिलने वाले सिरों का मिलान करके ढीले खंडों को पॉलीलाइनों में जोड़ता है।

      सिरे से सिरे जुड़ने वाले खंड हर शृंखला के लिए एक पॉलीलाइन बनते हैं; कुछ भी न छूने वाले खंड एक-खंड पॉलीलाइनें बनते हैं। उदाहरण: दो शृंखलाएँ बनाते दस बिखरे खंड -> दो पॉलीलाइनें

      Parameters

      • inputs: SegmentsToleranceDto

        सेगमेंट और वह टॉलरेंस जिसके भीतर दो सिरे स्पर्श करते माने जाएँ

      Returns Polyline3[]

      सेगमेंट से बनने वाली पॉलीलाइनें

      const chains = bitbybit.polyline.sortSegmentsIntoPolylines({
          segments: [[[0, 0, 0], [1, 0, 0]], [[1, 0, 0], [1, 1, 0]], [[5, 5, 0], [6, 5, 0]]],
          tolerance: 1e-5,
      });

    transforms

    • पॉलीलाइन के हर पॉइंट पर एक ट्रांसफॉर्मेशन मैट्रिक्स, या क्रम में उनकी सूची, लागू करता है।

      उदाहरण: [5,0,0] का ट्रांसलेशन -> हर पॉइंट X पर 5 हिलाया गया

      Parameters

      • inputs: TransformPolylineDto

        पॉलीलाइन और ट्रांसफॉर्मेशन

      Returns Bit.Inputs.Polyline.PolylinePropertiesDto

      ट्रांसफॉर्म किए गए पॉइंट वाली एक नई पॉलीलाइन

      const moved = bitbybit.polyline.transformPolyline({
          polyline: { points: [[0, 0, 0], [1, 0, 0]] },
          transformation: bitbybit.transforms.translationXYZ({ translation: [5, 0, 0] }),
      });

    Settings

    Member Visibility

    On This Page

    Constructors
    convert
    create
    fillet
    get
    intersection
    intersections
    sort
    transforms