ZenCad 3D स्क्रिप्ट सिमुलेशन सिस्टम

जो काम मैं आपके ध्यान में लाना चाहता हूं, वह एक बार फिर से स्क्रिप्टेड 3 डी मॉडलिंग सिस्टम लिखने का प्रयास है। जैसा मैं उसे देखना चाहूंगा, वैसा लिखो।

ZenCad प्रणाली के लिए नुस्खा काफी सरल है। OpenScad के 3D मॉडलिंग की स्क्रिप्टिंग की अवधारणा, OpenCascade की ज्यामितीय कोर, गोंद के रूप में python3, कम्प्यूटेशन के आक्रामक कैशिंग के लिए आलसी अभिकलन लाइब्रेरी evalcache। अन्य उपकरणों के एक जोड़े से मसाले जोड़ें, पाइक सॉस के साथ सीज़न गुई, और सरगर्मी करें, लेकिन हिला नहीं।

स्क्रिप्ट सीएडी सिस्टम

सीएडी, या हमारे सीएडी के अनुसार, एक कंप्यूटर एडेड डिजाइन प्रणाली है। इंटरैक्टिव 3 डी संपादकों के विपरीत, स्क्रिप्टेड सीएडी सिस्टम "स्वचालित" शब्द की व्याख्या उस अर्थ में करता है जिसमें इसके निर्माता आमतौर पर इसे समझते हैं। वह, कंप्यूटिंग टूल्स के सेट के रूप में नहीं, बल्कि एक क्रिस्टल क्लियर एल्गोरिदम के रूप में, जिसके निर्माण के समय केवल मानवीय हस्तक्षेप की आवश्यकता होती है।

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

इस समय सबसे प्रसिद्ध और शुद्ध स्क्रिप्टिंग CAD OpenScad है।

शुरुआत में OpenScad था

ऐसे लोगों की एक निश्चित मंडली है, जो सुविधाजनक कम्पास, सॉलिडवर्क्स, फ्रीकैड, सांसारिक और सरल ओपनसैड पसंद करते हैं। उसकी सफलता का रहस्य क्या है, इस सवाल का उत्तर देना आसान नहीं है, लेकिन आप निश्चित रूप से कह सकते हैं कि यह हल्का, उपयोग करने के लिए पर्याप्त लचीला है, इसमें न्यूनतम सेटिंग्स हैं। इस पर लिखे गए मॉडलों के कुछ हिस्सों का पुन: उपयोग करना आसान है।

हालाँकि, ओपनस्कैड में कुछ कष्टप्रद दोष हैं:

• खुलने का समय केवल जाल नेटवर्क के साथ काम करता है।
• ओपेकैड में काफी कम स्केलेबिलिटी की सीमा होती है, यह बड़े मॉडलों पर जोर से पिछड़ना शुरू कर देता है।
• ओपेनकाड अन्य प्रणालियों के साथ एकीकृत करने के लिए काफी मुश्किल है, यही वजह है कि अपनी भाषा का उपयोग कर रहा है।

दुर्भाग्य से, स्क्रिप्टिंग दृष्टिकोण की सभी शक्ति के लिए, OpenScad के साथ सरल मॉडल लिखने के उपयोगितावादी चमक के दायरे से परे जाना काफी समस्याग्रस्त है।

भाषा और सर्व-सर्व

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

अजगर का उपयोग ओपनस्कैड की तुलना में मॉडल कोड को अधिक पारदर्शी बनाकर ओपेनकाड कोड को सरल बनाता है।

#!/usr/bin/env python #coding: utf-8 from zencad import * lazy.diag = True c1 = 100 c2 = 130 c3 = c2/2 + 20 base = box(c1,c1,c1,center=True) f1 = ngon(r = 35, n = 3) f2 = ngon(r = 35, n = 5) f3 = circle(35) s1 = linear_extrude(f1, c2, center=True) s2 = linear_extrude(f2, c2, center=True).rotateY(deg(90)) s3 = linear_extrude(f3, c2, center=True).rotateX(deg(90)) #          3 . m1 = base - s1 - s2 - s3 m2 = base ^ s1 ^ s2 ^ s3 m3 = s1 + s2 + s3 ystep = 240 xstep = 240 fontpath = os.path.join(zencad.moduledir, "examples/fonts/testfont.ttf") #    .      . t1 = textshape("difference", fontpath, 40) t1c = t1.center() t1=t1.translate(-t1c.x, -t1c.y, 0).rotateZ(deg(45)) t2 = textshape("intersect", fontpath, 40) t2c = t2.center() t2=t2.translate(-t2c.x, -t2c.y, 0).rotateZ(deg(45)) t3 = textshape("union", fontpath, 40) t3c = t3.center() t3=t3.translate(-t3c.x, -t3c.y, 0).rotateZ(deg(45)) #  ,  . disp(base.forw(ystep)) disp(s1) disp(s2.left(xstep)) disp(s3.right(xstep)) disp(m1.back(ystep)) disp(m2.left(xstep).back(ystep)) disp(m3.right(xstep).back(ystep)) disp(t1.back(ystep).up(c3), Color(1,1,0)) disp(t2.left(xstep).back(ystep).up(c3), Color(1,1,0)) disp(t3.right(xstep).back(ystep).up(c3), Color(1,1,0)) disp(s1.left(xstep).back(ystep), Color(0.5,0,0,0.95)) disp(s2.left(xstep).back(ystep), Color(0.5,0,0,0.95)) disp(s3.left(xstep).back(ystep), Color(0.5,0,0,0.95)) disp(s1.back(ystep), Color(0.5,0,0,0.95)) disp(s2.back(ystep), Color(0.5,0,0,0.95)) disp(s3.back(ystep), Color(0.5,0,0,0.95)) show() 

यह बहुत सुविधाजनक है, उदाहरण के लिए, जनरेटर के सिंटैक्स का उपयोग करके एक बिंदु क्लाउड को फ़िल्टर करना।

 #!/usr/bin/env python3 from zencad import * #  . ng = ngon(r = 10, n = 6) #      . vertices = ng.vertices() filtered_vertices = [v for v in vertices if vx < 0] #      . m = ng.fillet(4, filtered_vertices) disp(m) show() 

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

 from zencad import * import numpy xcoords = numpy.linspace(-10,10,50) ycoords = numpy.linspace(-10,15,50) lines = [ interpolate([point(x, y, 0.01*(x**2 + y**3)) for x in xcoords]) for y in ycoords ] wires = [] for l in lines: trans = translate(0,0,-30) sf = l.endpoints() w=sew([l, segment(sf[0], trans(sf[0])), trans(l), segment(sf[1], trans(sf[1]))]) wires.append(w) for l in lines: disp(l.left(30)) disp(loft(wires) - halfspace().down(10)) show() 

OpenCascade की ठोस नींव

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

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

 #!/usr/bin/env python3 #coding: utf-8 from zencad import * import zencad.surface as surface import zencad.curve2 as curve2 lazy.diag=True height = 70 width = 50 thickness = 30 # BASE pnt1 = point(-width/2,0,0); pnt2 = point(-width/2,-thickness/4,0); pnt3 = point(0,-thickness/2,0); pnt4 = point(width/2,-thickness/4,0); pnt5 = point(width/2,0,0); edge1 = segment(pnt1, pnt2) edge2 = circle_arc(pnt2, pnt3, pnt4) edge3 = segment(pnt4, pnt5) wire = sew([edge1, edge2, edge3]) profile = sew([wire, wire.mirrorX()]) body = profile.fill().extrude(height) body = fillet(body, thickness/12) hl(body.forw(140)) # NECK neck_radius = thickness/4.; neck_height = height/10; neck = cylinder(r=neck_radius, h=neck_height).up(height) body = body + neck hl(body.forw(100)) # THICK body = thicksolid(body, -thickness / 50, [point(0,0,height+height/10)]) hl(body.forw(60)) # THREAD ( 2       .) cylsurf1 = surface.cylinder(neck_radius * 0.99) cylsurf2 = surface.cylinder(neck_radius * 1.05) major = 2 * math.pi; minor = neck_height / 10; angle = math.atan2(neck_height / 4, 2 * math.pi) ellipse1 = curve2.ellipse(major, minor).rotate(angle) arc1 = cylsurf1.map(curve2.trimmed_curve2(ellipse1, 0, math.pi)) segment1 = cylsurf1.map(curve2.segment(ellipse1.value(0), ellipse1.value(math.pi))) ellipse2 = curve2.ellipse(major, minor/4).rotate(angle) arc2 = cylsurf2.map(curve2.trimmed_curve2(ellipse2, 0, math.pi)) segment2 = cylsurf2.map(curve2.segment(ellipse2.value(0), ellipse2.value(math.pi))) m1 = sew([arc1, segment1]) m2 = sew([arc2, segment2]) thread = loft([m1, m2]).up(height + neck_height / 2) hl(m1.up(height + neck_height / 2).right(80)) hl(m2.up(height + neck_height / 2).right(60)) hl(thread.right(40)) # FINAL m = thread + body display(m) show() 

परंपरा की निरंतरता। सब कुछ के स्रोत के रूप में मूल

ज़ेंकाड सिंटैक्स समाधान, अपने बड़े भाई और ओपनस्कैड शिक्षक के उदाहरण के बाद, पुस्तकालय में संस्थाओं की संख्या को कम करता है। OpenScad की तरह, ZenCad मूल रूप से बिंदु (x, y, z) पर एक आदिम बनाने में असमर्थ है, इस तथ्य के बावजूद कि OpenCascade इसे अनुमति देता है। जेनकाड पहले मूल में एक आदिम बनाता है, और फिर परिवर्तनों का उपयोग करके उस स्थिति को निर्धारित करता है जिसे इसकी आवश्यकता है। ZenCad में रूपांतरण दोनों अलग-अलग वस्तुओं और निकायों के तरीकों के रूप में मौजूद हैं।

 #  . cube(40, center=True).rotateX(deg(45)).rotateZ(deg(45)).right(20) #  . (right(20) * rotateZ(deg(45)) * rotateX(deg(45)))(cube(40, center=True)) #  . trans = right(20) * rotateZ(deg(45)) * rotateX(deg(45)) cube(40, center=True).transform(trans) 

परिवर्तनों का एक सेट मानक है और इसमें अनुवाद, रोटेशन, प्रतिबिंब और ज़ूमिंग शामिल हैं।

आलस

गणना समय को कम करने के लिए, ZenCad में गणित को हल्का किया जाता है, और सभी गणना आक्रामक रूप से कैश की जाती हैं। [डेल] ब्लॉकचैन [/ डेल] evalcache लाइब्रेरी, जिसके बारे में मैंने कुछ समय पहले हबराब्र के पन्नों पर बात की थी, लिनेन एल्गोरिदम के प्रबंधन का ख्याल रखती है: आलसी कंप्यूटिंग पेड़ों की डिस्क कैशिंग । ज़ेंकड एक सामान्य कैश में गणना परिणामों को बचाता है, जिसकी स्थिति को विज़ुअलाइज़र इंटरफ़ेस के माध्यम से मॉनिटर किया जा सकता है। चिह्नित अतिरेक के साथ उपयोग किया गया sha512 हैश एल्गोरिथ्म आलसी वस्तुओं के लिए हैश कीज़ के टकराने की संभावना को समाप्त करता है (हैश स्पेस 10 ^ 74 ब्रह्मांड में परमाणुओं की संख्या है)।

इस मॉडल को बनाते समय, यह चार मेगाबाइट की ज्यामिति उत्पन्न करता है और पहले पास के दौरान इसकी गणना लंबे समय तक की जा सकती है:

थ्रेडेड सतहों के साथ काम करना कम्प्यूटेशनल रूप से महंगा है:

प्रतिबिंब टोपोलॉजी की समस्या। बिंदु विधि के पास

ओपनस्कैड का कोई चॉम्फरिंग या राउंडिंग ऑपरेशन नहीं है। OpenCascade उन्हें प्रदान करता है। ये बहुत महत्वपूर्ण ऑपरेशन हैं, और ज़ेनकैड के लिए उन्हें सेवा में नहीं लेना शर्म की बात होगी। ऐसे अन्य ऑपरेशन हैं जिन्हें एक टोपोलॉजिकल ऑब्जेक्ट को निर्दिष्ट करने की आवश्यकता होती है, उदाहरण के लिए, ओपनकैस्केड बोतल उदाहरण में एक पतली दीवार वाले मॉडल को लेने का संचालन। एक ग्राफिकल सीएडी प्रणाली में, हम माउस के साथ एक टोपोलॉजिकल ऑब्जेक्ट (किनारा, चेहरा, वर्टेक्स) को इंगित करते हैं। स्क्रिप्ट लिखते समय, हमारे पास ऐसा कोई अवसर नहीं होता है। मूल OpenCascade प्रतिबिंब के साथ समस्या हल करता है और ग्राफिक CAD के साथ काम करने के लिए इसका उपयोग करता है। हालांकि ZenCad मॉडल प्रतिबिंब का समर्थन करता है, इसे एक प्राथमिक उपकरण के रूप में उपयोग करने से कई महत्वपूर्ण कमियां हैं। सबसे पहले, इन उपकरणों का उपयोग करने के लिए आवश्यक ज्ञान का स्तर तेजी से बढ़ता है, क्योंकि आपको कम से कम आंतरिक सामयिक अवधारणा को समझना चाहिए। दूसरे, जैसे ही स्क्रिप्ट में दिखाई देता है, आलसी एल्गोरिदम का सद्भाव तुरंत टूट जाता है, और मॉडल कोड भी काफी जटिल है। काफी लंबा प्रतिबिंब और प्रयोग की प्रक्रिया में, मैं निकट-बिंदु विधि पर बस गया। संक्षेप में, जब स्थैतिक रूप से आश्रित संचालन करते हैं, तो कार्यक्रम वस्तु को दरकिनार कर देता है और शरीर में प्रवेश करने वालों के बीच से दिए गए बिंदु के सबसे करीब की वस्तु को पाता है। यह आइटम चयनित माना जाता है। ऐसा समाधान अधिक कम्प्यूटेशनल रूप से महंगा है, लेकिन कैशिंग के कारण यह अच्छा प्रदर्शन करता है। इस दृष्टिकोण का उपयोग सभी कार्यों के लिए किया जाता है जो टोपोलॉजी तत्वों पर निर्भर करते हैं।

जैसा कि पहले ही ऊपर उल्लेख किया गया है, सामान्य अर्थों द्वारा मॉडल को प्रतिबिंबित करने की संभावना भी संरक्षित है, जैसा कि ऊपर दिए गए उदाहरण में दिखाया गया है (उदाहरण: एक बिंदु को फ़िल्टर करना)।

मार्कर क्यू और मार्कर डब्ल्यू

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

स्रोत अपडेट ट्रैक करें

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

एनीमेशन

ज़ेंकड की खूबियाँ वहाँ ख़त्म नहीं होतीं।

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

इस समय एनीमेशन अभी भी एक अर्ध-प्रायोगिक संस्करण में है (विशेषकर कैमरा नियंत्रण के संदर्भ में) इसलिए मैं इस पर विस्तार से ध्यान नहीं दूंगा।

निर्यात - आयात

वर्तमान में, निर्यात और आयात brep प्रारूप में समर्थित हैं, जो फ्रीकैड के साथ एकीकरण और stl प्रारूप में निर्यात की अनुमति देता है, जो 3 डी प्रिंटिंग के लिए मॉडल बनाने की अनुमति देता है। स्क्रीनशॉट पीढ़ी भी समर्थित है। स्वचालित सहित। विशेष रूप से, ऑनलाइन मैनुअल में स्क्रीनशॉट जेनकेड द्वारा स्वचालित रूप से उत्पन्न होते हैं।

वर्तमान स्थिति

फिलहाल, ज़ेनकैड अभी भी पूरा होने से बहुत दूर है, और फिर भी यह उस हिस्से में पूरी तरह से चालू है जिसमें यह तैयार है।

पुस्तकालय python3.5, python3.6, python3.7 के संस्करणों के साथ डेबियन संगत कुल्हाड़ियों के लिए पिपली में उपलब्ध है

(आपको Pytt5 में प्लगइन्स की कुछ समस्याओं के कारण qt5-default को स्थापित करने की आवश्यकता हो सकती है)

 python3 -m pip install zencad apt install qt5-default 

कमांड लाइन से गुई चलाना:

 python3 -m zencad 

अजगर लिपि से गुई चलाना:

 #!/usr/bin/env python3 import zencad m = zencad.cube(20) zencad.disp(m) zencad.show() 

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

हालांकि, अब ज़ेंकाड आपको काफी जटिल 3 डी मॉडल तैयार करने, 3 डी प्रिंटिंग के लिए मॉडल बनाने और यहां तक ​​कि तंत्र की गतिज कल्पना की अनुमति देता है।

प्रोजेक्ट लिंक

github: https://github.com/mirmik/zencad , https://github.com/mirmik/servoce

pypi: https://pypi.org/project/zencad/ , https://pypi.org/project/pysoo//

गाइड

आपका ध्यान के लिए धन्यवाद।