☹️ 👶🏾 🚯 पॉलीहेड्रोन के द्रव्यमान के आयतन और केंद्र की खोज के लिए एल्गोरिदम 🥦 🥐 🎵

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

इसलिए, उदाहरण के लिए, आपको एक खिलौने के लिए मॉब उत्पन्न करने की आवश्यकता है और कहीं न कहीं इस प्रक्रिया में खरपतवार उन लोगों के लिए है जो अपने पैरों पर खड़े नहीं हैं। ऐसा करने के लिए, आपको भीड़ के केंद्र का पता लगाने की आवश्यकता है (और यह लगभग इसकी मात्रा खोजने के समान है) और सुनिश्चित करें कि यह भीड़ के पैरों के ऊपर कहीं है।

एक भीड़ एक पॉलीहेड्रॉन है, सादगी के लिए हम मानते हैं कि एक पॉलीहेड्रॉन में केवल त्रिकोण होते हैं (एल्गोरिथ्म में गॉसियन क्षेत्र सूत्र होता है, इसलिए आप इसे किसी भी पॉलीहेड्रॉन के लिए विस्तारित कर सकते हैं, लेकिन क्यों ...)। इसके अलावा, पॉलीहेड्रन में स्वयं-चौराहे नहीं होने चाहिए और बंद मात्रा को सीमित करना चाहिए, क्योंकि सभ्य पॉलीहेड्रोन।

(अच्छा, ऐसा ही)

KDPV पर एक छोटी यूपीडी बताती है कि सही भीड़ ठीक नहीं है, लेकिन बाईं ओर ठीक है:
सही तस्वीर ठीक नहीं है क्योंकि भीड़ आगे गिर जाएगी, क्योंकि जनसमूह का केंद्र समर्थन क्षेत्र से आगे बढ़ा है। सतह पर खड़े बहुभुज के समर्थन क्षेत्र को न्यूनतम बहुभुज के रूप में परिभाषित किया गया है जिसके अंदर सतह पर सभी बिंदु स्थित हैं। बाएं मामले में, समर्थन का क्षेत्र द्रव्यमान और अधिक के केंद्र में स्थानांतरित कर दिया जाता है (क्योंकि डायनासोर के पंजे बड़े होते हैं), और सही तस्वीर में क्षेत्र खुद छोटा और पूंछ के करीब है।
जन के केंद्र के संदर्भ क्षेत्र का अनुपात कुछ इस तरह होगा:

मैं वॉल्यूम खोज कोड (पायथन, इनपुट - अंकों की एक सूची और एक संक्रमण मैट्रिक्स) के साथ तुरंत शुरू करूँगा:

कुछ कोड

def RecSetDirsTriangles(para, Connects, TR): """ ,           """ #1.   , ,     for i in range(0,len(Connects)): if i != para[0] and i != para[1] and Connects[i][para[0]] and Connects[i][para[1]]: #  ! fl = 1 for T in TR: if i in T and para[1] in T and para[0] in T: fl = 0 #    break if fl: # ! TR += [(para[1],para[0],i)] Recc((para[0], i) , Connects, TR) Recc((i, para[1]) , Connects, TR) def FindV(dots, Connects): """ .   - dots     [x, y, z], Connects -  , Connects[i][j]=1      i, j,  =0 """ #1.      TR = [] for i in range(1,len(Connects)):#        - if Connects[i][0]: for j in range(i+1, len(Connects)): if Connects[0][j] and Connects[i][j]: TR += [(0,i,j)] break RecSetDirsTriangles((0,i),Connects, TR) break print(" : ", len(TR)) #2.        V = 0 for T in TR: ''' : x1y2 x2y3 x3y1 x2y1 x3y2 x1y3''' S = 0.5 * (dots[T[0]][0]*dots[T[1]][1] + dots[T[1]][0]*dots[T[2]][1] + dots[T[2]][0]*dots[T[0]][1] - dots[T[1]][0]*dots[T[0]][1] - dots[T[2]][0]*dots[T[1]][1] - dots[T[0]][0]*dots[T[2]][1]) #S   +  -    ,    V += S*(dots[T[0]][2] + dots[T[1]][2] + dots[T[2]][2])/3 #    ... return math.fabs(V)

एल्गोरिथ्म का सार उन आंकड़ों के संस्करणों पर विचार करना है जो पॉलीहेड्रोन के चेहरे बनाते हैं जो एक्स प्लेन पर "गिर" करते हैं। ऐसा करने के लिए, आपको त्रिकोण के प्रक्षेपण क्षेत्र और उस संकेत को जानना होगा जिसके साथ आकृति की मात्रा (छंटनी वाले प्रिज्म) को जोड़ना है। वास्तव में, यदि पहले से त्रिकोण का आदेश दिया जाता है, तो वॉल्यूम और संकेत दोनों एक एकल गणना में कम हो जाते हैं।

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

यह प्राप्त करने के लिए बहुत सरल है - एक त्रिकोण (अंक 1, a2, a3) लें, अपने पड़ोसियों की तलाश करें और रिवर्स ऑर्डर में दो मिलान वाले कोने सूचीबद्ध करें (उदाहरण के लिए, जैसे: a2, a1, b1)।
यह कुछ इस तरह से निकलता है:

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

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

यदि पॉलीहेड्रॉन एक्स प्लेन को इंटरसेप्ट करता है, तो वॉल्यूम की गणना करते समय, सभी संकेत एक-दूसरे को रद्द कर देंगे और परिणाम सही रहेगा (आपको बस मॉड्यूल के बिना प्रिज्म हाइट्स लेने की आवश्यकता है)।

(किसी तरह "ऊपरी" काटे गए प्रिज्म जैसा दिखता है)

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

(ये दो tetrahedra, लाल और लाल चिह्नित, एक त्रिकोणीय प्रिज्म (लाल tetrahedron के नीचे) के साथ वांछित छंटनी प्रिज्म बनाते हैं। हमें सभी तीन आंकड़ों के द्रव्यमान और मात्राओं के केंद्र खोजने की आवश्यकता है। पदनाम लगभग मोटे तौर पर कोड में पदनामों के अनुरूप हैं)।

कोड है कि यह और वह मायने रखता है:

थोड़ा और कोड

 def RecSetDirsTriangles(para, Connects, TR): #1.   , ,     for i in range(0,len(Connects)): if i != para[0] and i != para[1] and Connects[i][para[0]] and Connects[i][para[1]]: #  ! fl = 1 for T in TR: if i in T and para[1] in T and para[0] in T: fl = 0 break if fl: # ! TR += [(para[1],para[0],i)] Recc((para[0], i) , Connects, TR) Recc((i, para[1]) , Connects, TR) def TetrV(mas):#dot1, dot2, dot3, dot4): """   """ M = np.zeros((3,3),float) for i in range(1,4): for j in range(0,3): M[i-1][j] = mas[i][j] - mas[0][j] #print(M) return math.fabs(np.linalg.det(M)/6) def FindVandCM(dots, Connects): """     """ #1.      TR = [] for i in range(1,len(Connects)): #        - if Connects[i][0]: for j in range(i+1, len(Connects)): if Connects[0][j] and Connects[i][j]: TR += [(0,i,j)] break RecSetDirsTriangles((0,i),Connects, TR) break print(" : ", len(TR)) #2.   ,          V = 0 CM = [0, 0, 0] for T in TR: ''' : x1y2 x2y3 x3y1 x2y1 x3y2 x1y3''' S = 0.5 * (dots[T[0]][0]*dots[T[1]][1] + dots[T[1]][0]*dots[T[2]][1] + dots[T[2]][0]*dots[T[0]][1] - dots[T[1]][0]*dots[T[0]][1] - dots[T[2]][0]*dots[T[1]][1] - dots[T[0]][0]*dots[T[2]][1]) #S   +  -    ,    V += S*(dots[T[0]][2] + dots[T[1]][2] + dots[T[2]][2])/3 #    ... #c        c1 = ((dots[T[0]][0] + dots[T[1]][0] + dots[T[2]][0])/3, (dots[T[0]][1]+ dots[T[1]][1]+ dots[T[2]][1])/3) #    hm = min([dots[T[0]][2] , dots[T[1]][2] , dots[T[2]][2]]) hM = max([dots[T[0]][2] , dots[T[1]][2] , dots[T[2]][2]]) indM = [dots[T[0]][2] , dots[T[1]][2] , dots[T[2]][2]].index(hM) indm = [dots[T[0]][2] , dots[T[1]][2] , dots[T[2]][2]].index(hm) V3 = S * hm if indM == indm: # ! CM[0] += V3*c1[0] CM[1] += V3*c1[1] CM[2] += V3*hm/2 continue L = [0,1,2] L.remove(indM) L.remove(indm) indmidle = L[0] dots1 = [dots[T[0]], dots[T[1]], dots[T[2]], (dots[T[indM]][0], dots[T[indM]][1] , hm)] #  V1 = TetrV(dots1) if S < 0: V1 = -V1 V2 = S * ( dots[T[indmidle]][2] - hm)/3 #V3 = S * hm CM[0] += V1*((dots[T[0]][0] + dots[T[1]][0] + dots[T[2]][0] + dots[T[indM]][0])/4) + V2*((dots[T[0]][0] + dots[T[1]][0] + dots[T[2]][0] + dots[T[indmidle]][0])/4) + V3*c1[0] CM[1] += V1*((dots[T[0]][1] + dots[T[1]][1] + dots[T[2]][1] + dots[T[indM]][1])/4) + V2*((dots[T[0]][1] + dots[T[1]][1] + dots[T[2]][1] + dots[T[indmidle]][1])/4) + V3*c1[1] CM[2] += V1*((dots[T[0]][2] + dots[T[1]][2] + dots[T[2]][2] + hm)/4) + V2*((dots[T[0]][2] + dots[T[1]][2] + dots[T[2]][2] + hm)/4) + V3*hm/2 CM[0] = CM[0]/V CM[1] = CM[1]/V CM[2] = CM[2]/V return (math.fabs(V), CM)

एल्गोरिथ्म का एक टुकड़ा जहां त्रिभुजों की दिशाओं पर विचार किया जाता है और बाहरी और आंतरिक मात्रा को समझने के लिए उपयोग किया जाता है, यह एक बहुत मजबूत कदम है, इसका उपयोग बहुतायत से किया जा सकता है क्योंकि आप पॉलीहेड्रा के साथ काम करते हैं। उदाहरण के लिए, यदि आपको "बाहर" मानदंडों की दिशा की गणना करने की आवश्यकता है - यह एक चेहरे के लिए दिशा "वामावर्त" जानने के लिए पर्याप्त है - और वॉइला!

(फिल्म लगता है!)

पॉलीहेड्रोन के द्रव्यमान के आयतन और केंद्र की खोज के लिए एल्गोरिदम

More articles: