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

      • inputs: SegmentsDto

        সেগমেন্টগুলি

      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

      • inputs: PointsLinesDto

        বিন্দুগুলি, ক্রমানুসারে

      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 চালু থাকলে ছেদটি দুটি সেগমেন্টের ভিতরেই থাকতে হবে; বন্ধ থাকলে রেখাগুলি অসীমভাবে বিস্তৃত হয়। সমান্তরাল রেখা, না মিলে পরস্পরকে পাশ কাটানো রেখা, এবং পরস্পরের কাছে না পৌঁছানো সেগমেন্ট অসংজ্ঞায়িত দেয়। টলারেন্স বলে কতটা কাছাকাছি মেলা হিসেবে গণ্য হয়। উদাহরণ: [0,0,0] থেকে [10,0,0] এবং [5,-5,0] থেকে [5,5,0] -> [5,0,0]

      Parameters

      • inputs: LineLineIntersectionDto

        দুটি রেখা, সেগমেন্টের মধ্যে থাকা হবে কিনা, এবং টলারেন্স

      Returns Point3

      ছেদ বিন্দুটি, অথবা কোনোটি না থাকলে অসংজ্ঞায়িত

      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