👏🏿 🥟 🍔 ... सी ++ में एक पैरामीट्रिक लॉग होम की मॉडलिंग करना 🚴🏼 🧖🏾 😭

कौन परवाह करता है कि इस तरह के एक पैरामीट्रिक लॉग केबिन को C ++ कोड की कुछ लाइनों में कैसे मॉडल किया जाए - कृपया, बिल्ली के नीचे।

अब कई वर्षों से, हम अपनी परियोजनाओं में sgCore ठोस मॉडलिंग लाइब्रेरी के मुफ्त संस्करण का उपयोग कर रहे हैं ( यहाँ सुविधाओं का संक्षिप्त अवलोकन)। हाल ही में, लेखकों ने आईओएस के लिए एक संस्करण जारी किया, और चूंकि यह प्लेटफ़ॉर्म सक्रिय रूप से विकसित हो रहा है, मुझे लगता है कि इस लाइब्रेरी में एक छोटा परिचयात्मक उदाहरण कई लोगों के लिए बहुत रुचि का होगा। मैं एक छोटे से उदाहरण के साथ दिखाना चाहता हूं कि कैसे इसका इस्तेमाल कुछ ही चरणों में जटिल मॉडल बनाने के लिए किया जाता है।

इस लेख के डेमो प्रोजेक्ट्स के लिए सोर्स कोड यहाँ दिए गए हैं।
आईओएस
मैक
जीतना

पैरामीट्रिक लॉग हाउस का एक मॉडल बनाएं। जटिल नहीं करने के लिए, हम केवल तीन मापदंडों - लॉग अनुभाग के त्रिज्या, घर की चौड़ाई और घर की लंबाई का परिचय देते हैं। यह स्पष्ट है कि वास्तविक समस्याओं में मापदंडों की संख्या बहुत अधिक होगी, लेकिन इस उदाहरण में, नए मापदंडों की शुरूआत कुछ भी नया नहीं लाएगी। इस प्रकार, हमें घर के एक मॉडल का निर्माण करने की आवश्यकता है जिसे केवल एक फ़ंक्शन को कॉल करके फिर से बनाया जाएगा

void Build(sgFloat log_size, sgFloat houseSizeX, sgFloat houseSizeY);

सबसे पहले, हम लाइब्रेरी कोर को इनिशियलाइज़ करते हैं। यह sgCore फ़ंक्शंस के पहले उपयोग से पहले मुख्य धागे में एक बार किया जाना चाहिए:

 sgInitKernel();

हमारा पहला कदम लॉग के एक खंड का निर्माण करना है। लॉग के लिए न केवल एक-दूसरे पर झूठ बोलने के लिए, बल्कि अधिक या कम स्थिर संरचना बनाने के लिए, हम अनुभाग को गोल नहीं बल्कि दो आर्क्स से मिलकर बनाएंगे:

एक समान खंड का एक लॉग दो तरह से प्राप्त किया जा सकता है - या तो स्वयं एक फ्लैट खंड बनाकर और समतल समोच्च के एक्सट्रूड संचालन का उपयोग करके, या एक ही त्रिज्या के दो सिलेंडर बनाएं, सिलेंडर में से एक को स्थानांतरित करें और बूलियन घटाव ऑपरेशन लागू करें। चूंकि एक्सट्रूज़न ऑपरेशन बूलियन घटाव की तुलना में तेज़ है, इसलिए हम पहली विधि का उपयोग करते हैं।
दो आर्क्स का एक सेक्शन बनाएँ। एक दूसरे के लिए लॉग के एक ठग फिट के लिए, इन आर्क एक ही त्रिज्या का होना चाहिए:

दो आर्क बनाने के लिए, हमें एक ही त्रिज्या के दो हलकों के प्रतिच्छेदन बिंदुओं की गणना करने की आवश्यकता है। यह त्रिज्या हमारे मॉडल के मापदंडों में से एक है - इसलिए, लॉग के समोच्च के निर्माण के कार्य में एक इनपुट पैरामीटर होगा - लॉग की त्रिज्या

 void BuildLogSection(sgFloat log_size);

तीन बिंदुओं पर पहला खंड चाप बनाएँ:

मान लें कि इन दोनों हलकों के चौराहे को परिभाषित करने वाला कोण 45 डिग्री के बराबर है। फिर पहले चाप को परिभाषित करने वाले बिंदुओं में निम्नलिखित निर्देशांक होंगे:

 SG_POINT arc1BeginP = {log_size*cosCalc, -log_size*sinCalc, 0}; SG_POINT arc1EndP = {-log_size*cosCalc, -log_size*sinCalc, 0}; SG_POINT arc1MidP = {0, log_size, 0};

जहां log_size लॉग की त्रिज्या है, और sinCalc और cosCalc कोण की साइन और कोज़ाइन हैं, जो कि, जैसा कि हम सहमत थे, 45 डिग्री है। विभिन्न कोणों को सेट करके, आप दो आर्क्स वाले वर्गों के लिए विभिन्न विकल्पों की एक बड़ी संख्या प्राप्त कर सकते हैं।

इन तीन बिंदुओं पर एक आर्क संरचना बनाएं:

 SG_ARC arc1; arc1.FromThreePoints(arc1BeginP, arc1EndP, arc1MidP, false);

पहले तीन तर्कों को अंकों की गणना की जाती है, अंतिम तर्क तीन बिंदुओं द्वारा दिए गए चाप को पलटना या नहीं करना है। यदि यह पैरामीटर गलत है, तो आर्क का मध्य बिंदु हमारे द्वारा बनाए जा रहे आर्क पर झूठ होगा, यदि सही है, तो एक आर्क बनाएं जो पहले सर्कल में बनाए गए आर्क को पूर्ण सर्कल में पूरक करता है।

हम दूसरे तरीके से दूसरा आर्क बनाएंगे - दो छोर बिंदुओं पर, आर्क के प्लेन और त्रिज्या के सामान्य। दूसरे चाप के अंतिम बिंदु पहले के अंत बिंदुओं के साथ मेल खाते हैं, चाप के विमान के लिए सामान्य है Z अक्ष, अर्थात, वेक्टर (0,0,1) है, और त्रिज्या पहले चाप के समान है, जो log_size है। हम दूसरी चाप की संरचना का निर्माण करते हैं:

 SG_ARC arc2; arc2.FromBeginEndNormalRadius(arc1BeginP, arc1EndP, zAxe, log_size, false);

अगला, हमें स्वयं ज्यामितीय कर्नेल की वस्तुओं का निर्माण करने की आवश्यकता है - sgCObject के वारिस। आर्क्स के लिए, ये वर्ग sgCArc के ऑब्जेक्ट होंगे। चूंकि भविष्य में हम इन आर्क के साथ एक समोच्च का निर्माण करेंगे, फिर तुरंत हमारे आर्क को एक सरणी में सहेजें:

 sgCObject* acrsObjs[2]; acrsObjs[0] = sgCArc::Create(arc1); acrsObjs[1] = sgCArc::Create(arc2);

और स्वयं ही मार्ग बनाएँ, जिसका उपयोग हम भविष्य में लॉग बनाने के लिए करेंगे:

 m_log_section = sgCContour::CreateContour(acrsObjs, 2);

अनुभाग निर्मित होने के बाद, हम एक लॉग बना सकते हैं। चूंकि हमें विभिन्न लंबाई के लॉग बनाने की आवश्यकता है, हम एक फ़ंक्शन बनाएंगे जो हमारे अनुभाग को एक मनमानी लंबाई तक एक्सट्रूज़ करता है।

 sgC3DObject* BuildLog(sgFloat logH);

चूँकि हमने XOY विमान में एक समोच्च समोच्च बनाया है, हम Z अक्ष के साथ लॉग सेक्शन समोच्च (खंड विमान के लिए लंबवत) को हटा देंगे:

 SG_VECTOR extrVect = {0,0, logH}; sgCObject* logObj = sgKinematic::Extrude(*m_log_section, NULL, 0, extrVect, true);

एक्सट्रूज़न फ़ंक्शन का पहला तर्क बाहरी समोच्च है जिसे हम बाहर निकालते हैं, दूसरा तर्क एक्सट्रूडेड ऑब्जेक्ट में छिद्रों की एक सरणी है - बाहरी समोच्च के अंदर झूठ बोलने वाले समोच्च भी, और तीसरा तर्क छेदों की संख्या है। चूंकि लॉग में लॉग की पूरी लंबाई के साथ छेद नहीं होते हैं, जहां से घर बनाया गया है, ये दो तर्क शून्य हैं। चौथा तर्क - एक्सट्रूज़न वेक्टर - यह जेड अक्ष के साथ निर्देशित है और इसमें लॉग निर्माण फ़ंक्शन का लंबाई - लॉगह - तर्क है। अंतिम तर्क किसी ठोस या बनाई गई साइड एक्सट्रूज़न सतह को बनाने के लिए बनाई गई वस्तु को लॉक करना है। दूसरे शब्दों में - क्या हमें "बॉटम्स" बनाने की जरूरत है या नहीं। हम पर यह सच है।

आइए मनमानी लंबाई का पहला लॉग बनाएं और इसे अपने दृश्य में जोड़ें:

 sgGetScene()->AttachObject(BuildLog(houseSizeX));

कार्यक्रम शुरू करने के बाद, हम एक खाली दृश्य देखेंगे। लॉग कहाँ है ???
वास्तव में, लॉग बनाया गया था और इसे खींचा जाएगा यदि आप ड्राइंग के लिए ऑब्जेक्ट के त्रिकोण की एक सरणी का उपयोग नहीं करते हैं, लेकिन इसका बाइनरी मॉडल। अब तक, हमारे लॉग में कोई त्रिकोण नहीं है - इसलिए, हमने कुछ भी नहीं देखा।
त्रिभुज के रूप में प्रकट होने वाली त्रि-आयामी वस्तु के लिए, वस्तु को त्रिभुज होना चाहिए। यह स्वचालित रूप से सभी निर्मित तीन-आयामी वस्तुओं के लिए, या प्रत्येक ऑब्जेक्ट के लिए मैन्युअल रूप से किया जा सकता है। स्वचालित त्रिकोणासन के लिए, आपको ध्वज को सक्षम करना होगा:

 sgC3DObject::AutoTriangulate(true, SG_DELAUNAY_TRIANGULATION);

दूसरा तर्क त्रिकोणासन का प्रकार है। त्रिकोणीयकरण के प्रकारों को sgCore के लिए प्रलेखन में अधिक विस्तार से वर्णित किया गया है।
लेकिन एक सूक्ष्मता है। बहुत जटिल वस्तुओं को त्रिभुज करना कुछ समय ले सकता है। और वस्तुओं के साथ उपयोग और काम करने के लिए, त्रिकोणासन ही आवश्यक नहीं है - केवल अंतिम परिणाम की कल्पना करना आवश्यक है। इसलिए, यदि आप जटिल वस्तुओं को मध्यवर्ती के रूप में बनाते हैं, तो आपको स्वचालित त्रिकोणीकरण को बंद करना चाहिए और अंतिम परिणामों को त्रिकोणित करना चाहिए, जो उपयोगकर्ता देखेंगे। चूँकि अंतिम परिणाम प्राप्त होने तक हमारे पास कई जटिल ऑपरेशन होंगे, इसलिए हम स्वत: त्रिकोणासन को बंद कर देंगे और केवल उन वस्तुओं को मैन्युअल रूप से त्रिभुजित करेंगे, जिनकी वास्तव में कल्पना करने की आवश्यकता है।
इसलिए, हम अपने लॉग के निर्माण को थोड़ा बदल देते हैं:

 sgC3DObject* log1 = BuildLog(houseSizeX); log1->Triangulate(SG_DELAUNAY_TRIANGULATION);

यहाँ हमें क्या मिलता है:

अगला चरण प्रत्येक निर्मित लॉग के लिए खांचे का निर्माण होगा। ग्रूव्स उन जगहों पर एक लॉग में भर्ती होते हैं जहां एक और लॉग लॉग में फिट होगा। हम अपने लॉग में खांचे का निर्माण करेंगे जहां लॉग उस पर झूठ होंगे, जिस पर यह लॉग झूठ है, लॉग हाउस के निर्माण में अपनाए गए मार्जिन को देखते हुए।
ऐसा करने के लिए, हम नए मापदंडों को शुरू करके लॉग कंस्ट्रक्शन फ़ंक्शन का विस्तार करते हैं:

 sgC3DObject* BuildLog(sgFloat logH, bool withGroove, sgFloat logH, bool withGroove, sgFloat groove_size, sgFloat grooveShift);

withGroove - ध्वज चाहे वह नाली बनाने के लिए हो
groove_size - नाली त्रिज्या (लॉग के त्रिज्या के बराबर)
ग्रूवशिफ्ट - लॉग के किनारे से इंडेंट जिस पर ग्रूव बनाया जाएगा।
दो खांचे होंगे - लॉग के दोनों छोर से।
खांचे का निर्माण करने के लिए, हम बूलियन घटाव का उपयोग करेंगे। गति के लिए, घटाई गई वस्तु एक सिलेंडर होगी। बेशक, आप एक और लॉग का उपयोग कर सकते हैं, लेकिन चूंकि लॉग इस तरह से प्रतिच्छेद करते हैं कि उन्हें एक दूसरे के सापेक्ष सिलेंडर माना जा सकता है (एक्सट्रूडेड समोच्च के दूसरे चाप द्वारा गठित अवकाश नाली के निर्माण में शामिल नहीं है), हम सिलेंडर को घटाएंगे।
चलो मनमानी लंबाई के लॉग के त्रिज्या के बराबर त्रिज्या के दो सिलेंडर बनाते हैं (इस अस्थायी वस्तु की लंबाई कोई फर्क नहीं पड़ता, न तो काम की गति, न ही परिणाम इसे प्रभावित करता है)। इस कदम पर सबसे महत्वपूर्ण बात यह है कि इन अस्थायी वस्तुओं को अंतरिक्ष में सही ढंग से रखा जाए। चूंकि हमारा लॉग बेस XOY विमान पर खड़ा है और Z अक्ष के साथ निर्देशित है, इसलिए हमें इन अस्थायी वस्तुओं को उपयुक्त तरीके से रखना चाहिए। आदिम वस्तुओं के रूप में सिलिन्डरों को XOY तल पर एक आधार के साथ भी बनाया जाता है, जिसकी उत्पत्ति केंद्र पर होती है और Z अक्ष के साथ निर्देशित होती है। इस प्रकार, हमें सबसे पहले Y अक्ष के चारों ओर अपनी अस्थायी वस्तुओं को घुमाना है, फिर शिफ्ट करना है ताकि नाली की गहराई को ध्यान में रखा जाए। हमारे मामले में यह लॉग की आधी मोटाई होगी - यानी, बस log_size पैरामीटर) और लॉग के किनारों से मार्जिन। इस प्रकार, इन अस्थायी वस्तुओं का निर्माण इस तरह दिखेगा:

 if (withGroove) { sgFloat cylH = 10*groove_size; sgC3DObject* cyl1 = sgCreateCylinder(groove_size, cylH, 24); cyl1->InitTempMatrix()->Rotate(zeroP, yAxe, 90.0*M_PI/180.0); SG_VECTOR transVect = {-cylH/2, -groove_size, grooveShift}; cyl1->GetTempMatrix()->Translate(transVect); cyl1->ApplyTempMatrix(); cyl1->DestroyTempMatrix(); sgC3DObject* cyl2 = sgCreateCylinder(groove_size, cylH, 24); cyl2->InitTempMatrix()->Rotate(zeroP, yAxe, 90.0*M_PI/180.0); transVect.z = logH-grooveShift; cyl2->GetTempMatrix()->Translate(transVect); cyl2->ApplyTempMatrix(); cyl2->DestroyTempMatrix(); }

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

बहुत बढ़िया। वस्तुओं को आवश्यकतानुसार रखा जाता है। हम कोड से इन ऑब्जेक्ट्स के त्रिकोणासन को हटाते हैं और उन्हें दृश्य में नहीं जोड़ेंगे।
अगला, आपको खांचे में लॉग प्राप्त करने के लिए बूलियन घटाव का उपयोग करने की आवश्यकता है।
सबसे पहले, पहली अस्थायी वस्तु को घटाएं। चूंकि बूलियन घटाव के परिणामस्वरूप एक समूह बनाया जाता है, इसलिए इसे वहां विघटित किया जाना चाहिए, समूह ऑब्जेक्ट को हटाएं और पहले (और ध्वस्त समूह से एकमात्र ऑब्जेक्ट) लॉग को सूचक को पुन: असाइन करें। इस मामले में, हम उस अस्थायी सिलेंडर को हटाना नहीं भूलेंगे, क्योंकि अब हमें इसकी आवश्यकता नहीं है, साथ ही साथ पुराने लॉग ऑब्जेक्ट:

 sgCGroup* boolRes1 = sgBoolean::Sub((const sgC3DObject&)(*logObj), *cyl1); int ChCnt = boolRes1->GetChildrenList()->GetCount(); sgCObject** allChilds = (sgCObject**)malloc(ChCnt*sizeof(sgCObject*)); boolRes1->BreakGroup(allChilds); sgCObject::DeleteObject(boolRes1); sgCObject::DeleteObject(logObj); logObj = allChilds[0]; sgCObject::DeleteObject(cyl1);

हम दूसरे सत्यापन सिलेंडर के साथ भी ऐसा ही करेंगे:

 boolRes1 = sgBoolean::Sub((const sgC3DObject&)(*logObj), *cyl2); ChCnt = boolRes1->GetChildrenList()->GetCount(); allChilds = (sgCObject**)malloc(ChCnt*sizeof(sgCObject*)); boolRes1->BreakGroup(allChilds); sgCObject::DeleteObject(boolRes1); sgCObject::DeleteObject(logObj); logObj = allChilds[0]; sgCObject::DeleteObject(cyl2);

इन दो परिचालनों के बाद हमें निम्नलिखित परिणाम मिलते हैं:

अगला कदम दीवारों का निर्माण करना है। वास्तव में, यह कदम कुछ नया नहीं लाता है - हमें केवल लॉग की सही मात्रा बनाने और उन्हें उपयुक्त स्थानों पर रखने की आवश्यकता है। हम केवल यह कहेंगे कि समान लॉग बनाने के लिए हम ऑब्जेक्ट क्लोनिंग फ़ंक्शन (क्लोन ()) का उपयोग करेंगे, और खरोंच से नहीं बनाएंगे। आइए, यहां वर्णन करें कि किस लॉग को कहां रखा जाए, और बस दीवारों के निर्माण के लिए चरण दिखाएं:

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

जैसा कि आप देख सकते हैं, पैरामीट्रिक मॉडल होने, और केवल कुछ संख्याओं को बदलने से आप आसानी से अनंत संख्या में मॉडल प्राप्त कर सकते हैं।
अगला कदम मॉडल में एक विंडो जोड़ना है।
एक विंडो बनाने के लिए, हम दो ऑपरेशन का उपयोग करते हैं: एक्सट्रूज़न और बूलियन घटाव। बेशक, असली घरों में आम तौर पर आयताकार खिड़कियां होती हैं, लेकिन हम कुछ असामान्य आकार की एक खिड़की बनाना चाहते हैं, इसलिए हम न केवल एक अस्थायी बॉक्स का उपयोग करेंगे (जैसा कि एक आयताकार खिड़की के मामले में कोई भी करेगा), लेकिन कुछ गोल रूपरेखा निचोड़ें।
इसलिए पहले ऐसा रास्ता बनाएं। इसमें एक आर्क और तीन खंड शामिल होंगे। एक समोच्च बनाने और इसे बाहर निकालने के कार्य पूरी तरह से उन लोगों के समान हैं जो हम लॉग बनाने के लिए उपयोग करते थे, इसलिए हम इस पर ध्यान केंद्रित नहीं करेंगे। खिड़की के समोच्च को बाहर निकालने और इसे सही जगह पर रखने के बाद, हमें निम्नलिखित मिलते हैं:

हम अपनी खिड़की को बहुत पहले दीवार के लॉग से घटाएंगे। इसलिए, हम उनके निर्माण के कार्य में उनके त्रिभुज को अक्षम करते हैं और फिर खिड़की के घटाव को लागू करने के परिणामों को त्रिकोणित करते हैं। एक दीवार से एक खिड़की को घटाना करने के लिए, दीवार के प्रत्येक लॉग से खिड़की की वस्तु को घटाना आवश्यक है। आप इसे और अधिक बेहतर तरीके से कर सकते हैं, क्योंकि हम जानते हैं कि वास्तव में कौन सा लॉग स्थित है और जहां विंडो स्थित है और बुलियन ऑपरेशन को केवल उन लॉग्स पर लागू करें जो वास्तव में विंडो के साथ प्रतिच्छेद करते हैं। लेकिन हमें बूलियन घटाव के परिणाम पर रखा जाएगा। यदि यह शून्य है, तो ऑब्जेक्ट्स प्रतिच्छेद नहीं करते हैं। यह भी ध्यान में रखना आवश्यक है कि इस मामले में बूलियन संचालन के परिणाम में कई ऑब्जेक्ट शामिल हो सकते हैं (विंडो लॉग को दो में विभाजित करती है)। सभी बूलियन ऑपरेशन के बाद अस्थायी ऑब्जेक्ट और पुराने लॉग को हटाना न भूलें:

 size_t oldCnt = m_walls[0].size(); for (int i=0;i<oldCnt;i++) { sgCGroup* boolRes = sgBoolean::Sub(*m_walls[0][i], *winObj); if (boolRes) { int ChCnt = boolRes->GetChildrenList()->GetCount(); sgCObject** allChilds = (sgCObject**)malloc(ChCnt*sizeof(sgCObject*)); boolRes->BreakGroup(allChilds); sgCObject::DeleteObject(boolRes); sgGetScene()->DetachObject(m_walls[0][i]); sgDeleteObject(m_walls[0][i]); for (int j=0;j<ChCnt;j++) { ((sgC3DObject*)allChilds[j])->Triangulate(SG_VERTEX_TRIANGULATION); sgGetScene()->AttachObject(allChilds[j]); } m_walls[0][i] = (sgC3DObject*)allChilds[0]; for (int j=1;j<ChCnt;j++) m_walls[0].push_back((sgC3DObject*)allChilds[j]); free(allChilds); } else m_walls[0][i]->Triangulate(SG_VERTEX_TRIANGULATION); } sgDeleteObject(winObj);

जिसके बाद हमें खिड़की वाले घर का एक मॉडल मिलता है:

अंतिम चरण बना रहा - एक छत ढलान को जोड़ना। हम इसे दो चरणों में करेंगे - पहले हम छत की सतह में प्रवेश करने वाले लॉग को काटते हैं, फिर ढलान की बहुत सतह बनाते हैं।

शुरू करने के लिए, हम सभी पहले से बनाए गए पेड़ों की सभी त्रिकोणीय चुनौतियों को दूर करते हैं। छत का निर्माण करते समय, छत की सतह से सभी लॉग का ट्रंकेशन उपयोग किया जाएगा - अर्थात, बूलियन घटाव। हम इन घटाओं के सभी परिणामों को त्रिभुज करते हैं।
इसलिए, एक्सट्रूज़न ऑपरेशन का उपयोग करते हुए, एक अस्थायी ऑब्जेक्ट बनाएं जो छत की सतह के नीचे हमारे लॉग को छोटा कर देगा:

और हम इस अस्थायी ऑब्जेक्ट को उसी तरह से सभी लॉग से घटाते हैं जैसे हमने पहली दीवार के लॉग से विंडो को घटाया है:

यह केवल रैंप की सतह बनाने के लिए बनी हुई है। ऐसा करने के लिए, हम एक्सट्रूज़न ऑपरेशन का भी उपयोग करते हैं। जिसके बाद हमें एक लॉग हाउस का तैयार मॉडल मिलता है:

और मापदंडों को अलग करके, इस मॉडल की विविधताओं की एक अनंत संख्या:

... सी ++ में एक पैरामीट्रिक लॉग होम की मॉडलिंग करना

More articles: