Bitbybit Docs
    Preparing search index...

    Class ManifoldOperations

    Manifold सॉलिड्स को बूलियन से आगे बदलना: उन्हें उत्तल हल में लपेटना, उन्हें स्लाइस और प्रोजेक्ट करके क्रॉस-सेक्शन बनाना, उनके मेश को परिष्कृत और स्मूद करना, उन्हें सरल बनाना, उन्हें कंपोज़ और डीकंपोज़ करना, और वर्टेक्स गुण चैनलों में नॉर्मल और वक्रता की गणना करना। गुण चैनल मेश पर संग्रहीत प्रति वर्टेक्स एक संख्या है, जैसे नॉर्मल के तीन चैनल। हर मेथड एक नया सॉलिड लौटाता है।

    Index

    Constructors

    constructor

    adjustments

    calculateNormals calculateCurvature refineToTolerance refineToLength refine smoothOut smoothByNormals simplify setProperties

    basic

    setTolerance reserveIds asOriginal

    composition

    compose decompose

    cross sections

    slice project

    hulls

    hull hullPoints

    Constructors

    adjustments

    • मेश से हर वर्टेक्स के लिए नॉर्मल निकालता है और उसे normalIdx से शुरू होने वाले तीन प्रॉपर्टी चैनलों में संग्रहीत करता है।

      डिग्री में minSharpAngle से तीखे एजेस हर ओर अलग नॉर्मल रखते हैं और स्पष्ट रहते हैं; 0 पर हर त्रिभुज अपना नॉर्मल रखता है। कई त्रिभुजों के समतल फेसेस समतल रहते हैं।

      Parameters

      Returns Promise<ManifoldPointer>

      संग्रहीत नॉर्मल वाला सॉलिड

      const withNormals = await bitbybit.manifold.manifold.operations.calculateNormals({ manifold: shape, normalIdx: 0, minSharpAngle: 60 });

    • निकालता है कि हर वर्टेक्स पर सतह कितनी ज़ोर से मुड़ती है और उसे प्रॉपर्टी चैनलों में संग्रहीत करता है: गाउसीय वक्रता gaussianIdx पर, माध्य वक्रता meanIdx पर।

      वक्रता मुड़ाव त्रिज्या का व्युत्क्रम है, जहाँ सतह उत्तल है वहाँ धनात्मक और जहाँ अवतल है वहाँ ऋणात्मक; 0 से नीचे का इंडेक्स उस चैनल को छोड़ता है।

      Parameters

      Returns Promise<ManifoldPointer>

      संग्रहीत वक्रता वाला सॉलिड

      const withCurvature = await bitbybit.manifold.manifold.operations.calculateCurvature({ manifold: shape, gaussianIdx: 0, meanIdx: 1 });

    • चिकने किए सॉलिड में तब तक त्रिभुज जोड़ता है जब तक उसके मेश का हर पॉइंट चिकनी सतह के tolerance के भीतर न हो, ताकि कसकर मुड़े क्षेत्रों को समतल की तुलना में अधिक त्रिभुज मिलें।

      केवल smoothOut या smoothByNormals से चिकना किया सॉलिड बदलता है; कोई और कॉपी के रूप में वापस आता है।

      Parameters

      Returns Promise<ManifoldPointer>

      परिष्कृत सॉलिड

      const finer = await bitbybit.manifold.manifold.operations.refineToTolerance({ manifold: smoothed, tolerance: 0.01 });

    • हर एज को लगभग दी गई लंबाई के टुकड़ों में बाँटकर सॉलिड में त्रिभुज जोड़ता है, त्रिभुजों को समान रखने के लिए भीतरी वर्टेक्स जोड़ते हुए।

      smoothOut या smoothByNormals से चिकने किए सॉलिड पर नए वर्टेक्स चिकनी सतह पर चले जाते हैं; अन्यथा सतह जैसी है वैसी रहती है।

      Parameters

      Returns Promise<ManifoldPointer>

      परिष्कृत सॉलिड

      const finer = await bitbybit.manifold.manifold.operations.refineToLength({ manifold: smoothed, length: 0.5 });

    • हर एज को number टुकड़ों में बाँटकर सॉलिड में त्रिभुज जोड़ता है; 2 के साथ हर त्रिभुज चार बन जाता है।

      smoothOut या smoothByNormals से चिकने किए सॉलिड पर नए वर्टेक्स चिकनी सतह पर चले जाते हैं; अन्यथा नए त्रिभुज समतल रहते हैं।

      Parameters

      • inputs: ManifoldRefineDto<ManifoldPointer>

        सॉलिड और प्रत्येक एज को कितने टुकड़ों में विभाजित करना है

      Returns Promise<ManifoldPointer>

      परिष्कृत सॉलिड

      const finer = await bitbybit.manifold.manifold.operations.refine({ manifold: smoothed, number: 2 });

    • सॉलिड को उसके त्रिभुजों से स्पर्शरेखाएँ निकालकर चिकना करने के लिए चिह्नित करता है, ताकि बाद का refine या refineToLength नए त्रिभुजों को चिकनी सतह में मोड़े।

      डिग्री में minSharpAngle से तीखे एजेस तीखे रहते हैं; 0 से ऊपर का minSmoothness उन्हें थोड़ा गोल करता है, और 1 सब कुछ चिकना करता है। ज्यामिति खुद परिष्कृत होने तक नहीं बदलती।

      Parameters

      Returns Promise<ManifoldPointer>

      स्मूदिंग स्पर्शरेखाओं वाला सॉलिड

      const smoothed = await bitbybit.manifold.manifold.operations.smoothOut({ manifold: cube, minSharpAngle: 60, minSmoothness: 0 });
      const rounded = await bitbybit.manifold.manifold.operations.refineToLength({ manifold: smoothed, length: 0.5 });

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

      normalIdx तीन नॉर्मल चैनलों में पहला है, जैसे calculateNormals उन्हें संग्रहीत करता है; जहाँ वर्टेक्स पर नॉर्मल असहमत हों वहाँ एज तीखा रहता है।

      Parameters

      Returns Promise<ManifoldPointer>

      स्मूदिंग स्पर्शरेखाओं वाला सॉलिड

      const smoothed = await bitbybit.manifold.manifold.operations.smoothByNormals({ manifold: withNormals, normalIdx: 0 });

    • हर सतह को जहाँ वह थी उसके tolerance के भीतर रखते हुए सॉलिड के मेश से वर्टेक्स हटाता है, त्रिभुजों की गिनती घटाने के लिए।

      परिणाम मूल वर्टेक्स का उपसमुच्चय रखता है; सॉलिड का अपना टॉलरेंस मान अपरिवर्तित रहता है।

      Parameters

      • inputs: ManifoldSimplifyDto<ManifoldPointer>

        सॉलिड और सतहें कितनी दूर तक खिसक सकती हैं, मॉडल इकाइयों में

      Returns Promise<ManifoldPointer>

      सरलीकृत सॉलिड

      const lighter = await bitbybit.manifold.manifold.operations.simplify({ manifold: shape, tolerance: 0.05 });

    • सॉलिड की वर्टेक्स प्रॉपर्टी को ऐसे फ़ंक्शन से फिर से लिखता है जो हर वर्टेक्स की पोज़िशन और पुरानी प्रॉपर्टी पाता है और नई भरता है।

      numProp तय करता है कि बाद में हर वर्टेक्स की कितनी प्रॉपर्टी हैं, ताकि चैनल जोड़े या हटाए जा सकें; पुरानी गिनती के पार पढ़ना या नई के पार लिखना undefined है।

      Parameters

      • inputs: ManifoldSetPropertiesDto<ManifoldPointer>

        सॉलिड, नए गुणों की संख्या और वह फ़ंक्शन जो गुणों को भरता है

      Returns Promise<ManifoldPointer>

      नए गुणों वाला सॉलिड

      const colored = await bitbybit.manifold.manifold.operations.setProperties({
          manifold: shape,
          numProp: 3,
          propFunc: (newProp, position) => { newProp[0] = position[0]; newProp[1] = position[1]; newProp[2] = position[2]; },
      });

    basic

    • सॉलिड को नई टॉलरेंस देता है, वह गोलाई त्रुटि जो उसे वहन करने की अनुमति है, और टॉलरेंस बढ़ने पर उसके मेश को सरल करता है।

      टॉलरेंस से पतले त्रिभुज विकृत माने जाकर हटा दिए जाते हैं।

      Parameters

      Returns Promise<ManifoldPointer>

      नई टॉलरेंस वाला सॉलिड

      const coarser = await bitbybit.manifold.manifold.operations.setTolerance({ manifold: shape, tolerance: 0.01 });

    • count अद्वितीय मेश id की शृंखला आरक्षित करता है और पहली लौटाता है, त्रिभुजों के ऐसे सेट चिह्नित करने के लिए जो बाद के ऑपरेशनों के बाद फिर से खोजे जा सकें।

      उनसे सॉलिड बनाने से पहले उन्हें मेश की runOriginalID को सौंपें, उदाहरण के लिए कई मैटेरियल को अलग रखने के लिए।

      Parameters

      • inputs: CountDto

        कितनी id आरक्षित करनी हैं

      Returns Promise<number>

      आरक्षित id में से पहली; बाकी क्रम में उसके बाद आती हैं

      const firstId = await bitbybit.manifold.manifold.operations.reserveIds({ count: 2 });

    • सॉलिड की ऐसी कॉपी बनाता है जो नए मूल के रूप में गिनी जाती है, ताकि कॉपी अपनी वर्टेक्स प्रॉपर्टी, जैसे अलग UV मैपिंग, वहन कर सके और जिससे वह बनी उससे अलग पहचानी जा सके।

      रास्ते में समतलीय फेसेस मिला दिए जाते हैं और उनके बीच के एजेस ढहा दिए जाते हैं; जब वे एजेस रहने चाहिए तब इसके बजाय मेश मार्ग रखें।

      Parameters

      Returns Promise<ManifoldPointer>

      मूल के रूप में चिह्नित प्रतिलिपि

      const original = await bitbybit.manifold.manifold.operations.asOriginal({ manifold: shape });

    composition

    • कई सॉलिड को एक में पैक करता है, decompose का उल्टा।

      ओवरलैप होने वाले सॉलिड बूलियन यूनियन की तरह फ़्यूज़ हो जाते हैं; अलग रखे गए सॉलिड एक ही परिणाम के अलग-अलग हिस्से बने रहते हैं।

      Parameters

      Returns Promise<ManifoldPointer>

      उन सभी को रखने वाला एक सॉलिड

      const packed = await bitbybit.manifold.manifold.operations.compose({ manifolds: [cube, sphere] });

    • सॉलिड को उसके अलग, असंबद्ध टुकड़ों में बाँटता है, compose का उल्टा।

      जो सॉलिड पूरा एक टुकड़ा है वह एक कॉपी की सूची के रूप में वापस आता है।

      Parameters

      Returns Promise<ManifoldPointer[]>

      अलग-अलग टुकड़े

      const pieces = await bitbybit.manifold.manifold.operations.decompose({ manifold: packed });

    cross sections

    • सॉलिड को दी गई Z ऊँचाई पर XY प्लेन के समानांतर प्लेन से काटता है और समतल सेक्शन को क्रॉस-सेक्शन के रूप में लौटाता है।

      सॉलिड के बाउंडिंग बॉक्स के तल पर की ऊँचाई उसके निचले फेसेस देती है; शीर्ष पर की ऊँचाई खाली क्रॉस-सेक्शन देती है।

      Parameters

      Returns Promise<CrossSectionPointer>

      सेक्शन, एक क्रॉस-सेक्शन के रूप में

      const section = await bitbybit.manifold.manifold.operations.slice({ manifold: sphere, height: 2 });

    • सॉलिड को XY प्लेन पर चपटा करता है और उसकी बाहरी रेखा क्रॉस-सेक्शन के रूप में लौटाता है, ठीक ऊपर की रोशनी में उसकी छाया की तरह।

      Parameters

      Returns Promise<CrossSectionPointer>

      बाहरी रेखा, एक क्रॉस-सेक्शन के रूप में

      const shadow = await bitbybit.manifold.manifold.operations.project({ manifold: shape });

    hulls

    • सॉलिड को उसके उत्तल हल में लपेटता है, बिना गड्ढों का सबसे छोटा शेप जो उसे समेटता है, जैसे उस पर कसकर खिंची श्रिंक-रैप।

      Parameters

      Returns Promise<ManifoldPointer>

      उत्तल हल

      const wrapped = await bitbybit.manifold.manifold.operations.hull({ manifold: shape });

    • पॉइंट, सॉलिड या दोनों के मिश्रण को एक उत्तल हल में लपेटता है, बिना गड्ढों का सबसे छोटा शेप जो उन सभी को समेटता है।

      Parameters

      Returns Promise<ManifoldPointer>

      उत्तल हल

      const wrapped = await bitbybit.manifold.manifold.operations.hullPoints({ points: [[0, 0, 0], [10, 0, 0], [0, 10, 0], [0, 0, 10]] });

    Settings

    Member Visibility

    On This Page

    Constructors
    adjustments
    basic
    composition
    cross sections
    hulls