Bitbybit Docs
    Preparing search index...

    Class Line

    दो पॉइंट के बीच सीधी लाइनें, { start, end } रूप के सादे ऑब्जेक्ट के रूप में रखी गई, और उसी चीज़ का सेगमेंट रूप [start, end]। यहाँ के मेथड लाइनें बनाते हैं, उन्हें मापते और ट्रांसफॉर्म करते हैं, दोनों रूपों के बीच बदलते हैं, उनके साथ पॉइंट रखते हैं और पता लगाते हैं कि दो लाइनें कहाँ मिलती हैं। लंबाइयाँ मॉडल इकाइयों में हैं।

    Index

    Constructors

    constructor

    convert

    lineToSegment linesToSegments segmentToLine segmentsToLines

    create

    create createSegment linesBetweenPoints linesBetweenStartAndEndPoints

    get

    getStartPoint getEndPoint length getPointOnLine

    intersection

    lineLineIntersection

    operations

    reverse

    transforms

    transformLine transformsForLines

    Constructors

    convert

    • लाइन ऑब्जेक्ट को उसके खंड रूप, युग्म [start, end], में बदलता है।

      उदाहरण: { start: [0,0,0], end: [10,5,0] } -> [[0,0,0], [10,5,0]]

      Parameters

      Returns Segment3

      सेगमेंट

    • हर लाइन ऑब्जेक्ट को उसके खंड रूप, युग्म [start, end], में बदलता है।

      उदाहरण: तीन लाइनें -> तीन खंड, उसी क्रम में

      Parameters

      Returns Segment3[]

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

    • खंड, युग्म [start, end], को लाइन ऑब्जेक्ट में बदलता है।

      उदाहरण: [[0,0,0], [10,5,0]] -> { start: [0,0,0], end: [10,5,0] }

      Parameters

      Returns Line3

      लाइन

    • हर खंड, एक युग्म [start, end], को लाइन ऑब्जेक्ट में बदलता है।

      उदाहरण: तीन खंड -> तीन लाइनें, उसी क्रम में

      Parameters

      Returns Line3[]

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

    create

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

      उदाहरण: शुरुआत [0,0,0], अंत [10,5,0] -> { start: [0,0,0], end: [10,5,0] }

      Parameters

      • inputs: LinePointsDto

        आरंभ और अंत पॉइंट

      Returns Line3

      लाइन ऑब्जेक्ट

      const line = bitbybit.line.create({ start: [0, 0, 0], end: [10, 5, 0] });

    • एक शुरुआती और एक अंतिम पॉइंट से खंड, लाइन का पॉइंट-युग्म रूप, बनाता है।

      उदाहरण: शुरुआत [0,0,0], अंत [10,5,0] -> [[0,0,0], [10,5,0]]

      Parameters

      • inputs: LinePointsDto

        आरंभ और अंत पॉइंट

      Returns Segment3

      सेगमेंट, [start, end] के रूप में

      const segment = bitbybit.line.createSegment({ start: [0, 0, 0], end: [10, 5, 0] });

    • हर पॉइंट को अगले से एक लाइन से जोड़ता है, ताकि पॉइंट की सूची लाइनों की शृंखला बन जाए।

      उदाहरण: [[0,0,0], [5,0,0], [5,5,0]] -> दो लाइनें, [0,0,0] से [5,0,0] और [5,0,0] से [5,5,0]

      Parameters

      Returns Line3[]

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

      const chain = bitbybit.line.linesBetweenPoints({ points: [[0, 0, 0], [5, 0, 0], [5, 5, 0]] });

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

      जिस जोड़ी के दोनों पॉइंट एक ही जगह हों वह कोई लाइन नहीं बनाती और छोड़ दी जाती है। उदाहरण: शुरुआत [[0,0,0], [5,0,0]] और अंत [[0,5,0], [5,5,0]] -> दो लाइनें

      Parameters

      • inputs: LineStartEndPointsDto

        आरंभ पॉइंट और अंत पॉइंट, मेल खाते क्रम में

      Returns Line3[]

      प्रत्येक जोड़े के लिए एक लाइन, 0 लंबाई वाले जोड़ों को छोड़कर

      const rungs = bitbybit.line.linesBetweenStartAndEndPoints({
          startPoints: [[0, 0, 0], [5, 0, 0]],
          endPoints: [[0, 5, 0], [5, 5, 0]],
      });

    get

    • लाइन का शुरुआती पॉइंट पढ़ता है।

      उदाहरण: { start: [0,0,0], end: [10,5,0] } -> [0,0,0]

      Parameters

      Returns Point3

      आरंभ पॉइंट

    • लाइन का अंतिम पॉइंट पढ़ता है।

      उदाहरण: { start: [0,0,0], end: [10,5,0] } -> [10,5,0]

      Parameters

      Returns Point3

      अंत पॉइंट

    • लाइन की शुरुआत से उसके अंत तक की सीधी दूरी मापता है।

      उदाहरण: { start: [0,0,0], end: [3,4,0] } -> 5

      Parameters

      Returns number

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

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

      0 से 1 के बाहर का अंश सिरों के पार जारी रहता है। उदाहरण: { start: [0,0,0], end: [10,0,0] } 0.5 पर -> [5,0,0]

      Parameters

      • inputs: PointOnLineDto

        लाइन और उस पर का अंश

      Returns Point3

      लाइन पर स्थित पॉइंट

      const middle = bitbybit.line.getPointOnLine({ line: { start: [0, 0, 0], end: [10, 0, 0] }, param: 0.5 });

    intersection

    • वह पॉइंट खोजता है जहाँ दो लाइनें एक-दूसरे को काटती हैं।

      checkSegmentsOnly चालू होने पर, कटाव दोनों खंडों के भीतर होना चाहिए; बंद होने पर, लाइनें अनंत तक फैलती हैं। समानांतर लाइनें, बिना मिले एक-दूसरे के पास से गुज़रने वाली लाइनें, और एक-दूसरे तक न पहुँचने वाले खंड undefined देते हैं। टॉलरेंस बताता है कि कितना पास मिलना माना जाता है। उदाहरण: [0,0,0] से [10,0,0] और [5,-5,0] से [5,5,0] -> [5,0,0]

      Parameters

      • inputs: LineLineIntersectionDto

        दोनों लाइनें, क्या सेगमेंट के भीतर ही रहना है, और टॉलरेंस

      Returns Point3

      प्रतिच्छेदन पॉइंट, या undefined जब कोई न हो

      const crossing = bitbybit.line.lineLineIntersection({
          line1: { start: [0, 0, 0], end: [10, 0, 0] },
          line2: { start: [5, -5, 0], end: [5, 5, 0] },
          checkSegmentsOnly: true,
          tolerance: 1e-6,
      });

    operations

    • लाइन की शुरुआत और अंत की अदला-बदली करता है, ताकि वह दूसरी दिशा में चले।

      उदाहरण: { start: [0,0,0], end: [10,5,0] } -> { start: [10,5,0], end: [0,0,0] }

      Parameters

      Returns Line3

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

    transforms

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

      उदाहरण: { start: [0,0,0], end: [10,0,0] } [5,5,0] से हिलाया गया -> { start: [5,5,0], end: [15,5,0] }

      Parameters

      • inputs: TransformLineDto

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

      Returns Line3

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

      const moved = bitbybit.line.transformLine({
          line: { start: [0, 0, 0], end: [10, 0, 0] },
          transformation: bitbybit.transforms.translationXYZ({ translation: [5, 5, 0] }),
      });

    • हर लाइन पर एक अलग ट्रांसफॉर्मेशन लागू करता है: पहला ट्रांसफॉर्मेशन पहली लाइन पर, और इसी तरह आगे।

      उदाहरण: तीन लाइनें तीन ट्रांसलेशन के साथ -> हर लाइन अपने ट्रांसलेशन से हिलाई गई

      Parameters

      • inputs: TransformsLinesDto

        लाइनें और प्रत्येक लाइन के लिए एक ट्रांसफॉर्मेशन

      Returns Line3[]

      ट्रांसफॉर्म की गई लाइनें, उसी क्रम में

      const placed = bitbybit.line.transformsForLines({
          lines: [{ start: [0, 0, 0], end: [1, 0, 0] }, { start: [0, 0, 0], end: [0, 1, 0] }],
          transformation: bitbybit.transforms.translationsXYZ({ translations: [[0, 1, 0], [0, 2, 0]] }),
      });

    Settings

    Member Visibility

    On This Page

    Constructors
    convert
    create
    get
    intersection
    operations
    transforms