ग्राफिक्स के लिए, मैं नहीं बल्कि पूर्णांक पसंद करेंगे। कई सिस्टम यूआई पेंटिंग के लिए पूर्णांक का उपयोग करते हैं (पिक्सेल सभी के बाद इन्टस हैं), लेकिन उदाहरण के लिए macOS सब कुछ के लिए फ्लोट का उपयोग करता है। macOS केवल अंक जानता है और एक बिंदु एक पिक्सेल में अनुवाद कर सकता है, लेकिन मॉनिटर रिज़ॉल्यूशन के आधार पर, यह कुछ और में अनुवाद कर सकता है। रेटिना स्क्रीन पर आधा बिंदु (0.5 / 0.5) पिक्सेल होता है। फिर भी, मैंने कभी नहीं देखा कि macOS UI अन्य UI की तुलना में काफी धीमा है। सभी 3 डी एपीआई (ओपनजीएल या डायरेक्ट 3 डी) के बाद भी फ्लोट और आधुनिक ग्राफिक्स लाइब्रेरी के साथ काम करता है जो अक्सर GPU त्वरण का लाभ उठाते हैं।
अब आपने कहा कि गति आपकी मुख्य चिंता है, ठीक है, चलो गति के लिए चलते हैं। किसी भी परिष्कृत एल्गोरिदम को चलाने से पहले, पहले एक साधारण परीक्षण करें। अपने बहुभुज के चारों ओर एक अक्ष संरेखित बाउंडिंग बॉक्स बनाएं । यह बहुत आसान, तेज है और पहले से ही आपको बहुत सारी गणनाओं को सुरक्षित कर सकता है। वह कैसे काम करता है? बहुभुज के सभी बिंदुओं पर Iterate करें और X और Y के न्यूनतम / अधिकतम मान ज्ञात करें।
जैसे आपके पास अंक हैं (9/1), (4/3), (2/7), (8/2), (3/6)। इसका मतलब है कि Xmin 2 है, Xmax 9 है, Ymin 1 है और Ymax 7 है। आयत के बाहर दो किनारों (2/1) के साथ एक बिंदु और (9/7) बहुभुज के भीतर नहीं हो सकता है।
// p is your point, p.x is the x coord, p.y is the y coord
if (p.x < Xmin || p.x > Xmax || p.y < Ymin || p.y > Ymax) {
// Definitely not within the polygon!
}
यह किसी भी बिंदु के लिए चलने वाला पहला परीक्षण है। जैसा कि आप देख सकते हैं, यह परीक्षण अल्ट्रा फास्ट है, लेकिन यह बहुत मोटे भी है। बिंदुओं को संभालने के लिए जो कि सीमा आयत के भीतर हैं, हमें एक अधिक परिष्कृत एल्गोरिथ्म की आवश्यकता है। वहाँ कुछ तरीके हैं कि यह कैसे गणना की जा सकती है। कौन सी विधि काम करती है यह इस बात पर भी निर्भर करता है कि क्या बहुभुज में छेद हो सकते हैं या हमेशा ठोस होंगे। यहाँ ठोस लोगों के उदाहरण हैं (एक उत्तल, एक अवतल):
और यहाँ एक छेद के साथ है:
हरे रंग के बीच में एक छेद है!
सबसे आसान एल्गोरिथ्म, जो उपरोक्त सभी तीन मामलों को संभाल सकता है और अभी भी बहुत तेज है, जिसे रे कास्टिंग कहा जाता है । एल्गोरिथ्म का विचार बहुत सरल है: बहुभुज के बाहर कहीं से भी एक आभासी किरण को अपनी बात पर आकर्षित करें और गिनें कि यह बहुभुज के कितनी बार हिट होता है। यदि हिट की संख्या सम है, तो यह बहुभुज के बाहर है, यदि यह विषम है, तो यह अंदर है।
घुमावदार संख्या एल्गोरिथ्म एक विकल्प हो सकता है, यह बहुत ही एक बहुभुज लाइन के निकट होने के अंक के लिए अधिक सटीक है लेकिन यह भी बहुत धीमी है। सीमित फ़्लोटिंग पॉइंट सटीक और गोलाई के मुद्दों के कारण रे कास्टिंग एक बहुभुज की ओर के करीब भी विफल हो सकती है, लेकिन वास्तव में यह एक समस्या है, जैसे कि अगर कोई बिंदु एक पक्ष के पास है, तो यह अक्सर नेत्रहीन भी संभव नहीं है देखने वाला यह पहचान सकता है कि यह पहले से ही अंदर है या अभी भी बाहर है।
आपके पास अभी भी ऊपर का बाउंडिंग बॉक्स है, याद है? बस बाउंडिंग बॉक्स के बाहर एक बिंदु चुनें और इसे अपनी किरण के लिए शुरुआती बिंदु के रूप में उपयोग करें। उदाहरण के लिए बिंदु (Xmin - e/p.y)बहुभुज के बाहर है।
लेकिन क्या है e? खैर, e(वास्तव में एप्सिलॉन) बाउंडिंग बॉक्स को कुछ पैडिंग देता है । जैसा कि मैंने कहा, यदि हम एक बहुभुज रेखा के बहुत करीब से शुरू करते हैं, तो रे ट्रेसिंग विफल हो जाती है। चूंकि बाउंडिंग बॉक्स बहुभुज के बराबर हो सकता है (यदि बहुभुज एक अक्ष संरेखित आयत है, तो बाउंडिंग बॉक्स बहुभुज के बराबर है!), हमें इसे सुरक्षित बनाने के लिए कुछ पैडिंग की आवश्यकता है, बस इतना ही। आपको कितना बड़ा चुनना चाहिए e? बहुत बड़ा नहीं। यह समन्वय प्रणाली के पैमाने पर निर्भर करता है जिसका उपयोग आप ड्राइंग के लिए करते हैं। यदि आपकी पिक्सेल चरण की चौड़ाई 1.0 है, तो बस 1.0 चुनें (फिर भी 0.1 ने भी काम किया होगा)
अब जब हमारे पास इसकी शुरुआत और अंत के निर्देशांकों के साथ किरण है, तो समस्या यह है कि " बहुभुज के भीतर बिंदु है " से पाली " रे बहुभुज पक्ष को कितनी बार काटती है "। इसलिए हम पहले की तरह बहुभुज बिंदुओं के साथ काम नहीं कर सकते, अब हमें वास्तविक पक्षों की आवश्यकता है। एक पक्ष को हमेशा दो बिंदुओं द्वारा परिभाषित किया जाता है।
side 1: (X1/Y1)-(X2/Y2)
side 2: (X2/Y2)-(X3/Y3)
side 3: (X3/Y3)-(X4/Y4)
:
आपको सभी पक्षों के खिलाफ किरण का परीक्षण करने की आवश्यकता है। एक वेक्टर होने के लिए किरण और हर तरफ वेक्टर होने पर विचार करें। किरण को हर तरफ से एक बार या बिल्कुल भी नहीं मारना है। यह एक ही पक्ष को दो बार नहीं मार सकता है। 2 डी अंतरिक्ष में दो लाइनें हमेशा एक बार एक-दूसरे को काटेंगी, जब तक कि वे समानांतर नहीं होती हैं, जिस स्थिति में वे कभी भी अंतर नहीं करते हैं। हालाँकि, वैक्टर की लंबाई सीमित होती है, दो वैक्टर समानांतर नहीं हो सकते हैं और फिर भी कभी भी प्रतिच्छेद नहीं करते हैं क्योंकि वे एक-दूसरे से मिलने के लिए बहुत कम हैं।
// Test the ray against all sides
int intersections = 0;
for (side = 0; side < numberOfSides; side++) {
// Test if current side intersects with ray.
// If yes, intersections++;
}
if ((intersections & 1) == 1) {
// Inside of polygon
} else {
// Outside of polygon
}
अब तक तो ठीक है, लेकिन अगर दो वैक्टर चौराहे हैं तो आप कैसे परीक्षण करेंगे? यहाँ कुछ सी कोड (परीक्षण नहीं किया गया है), जो कि चाल करना चाहिए:
#define NO 0
#define YES 1
#define COLLINEAR 2
int areIntersecting(
float v1x1, float v1y1, float v1x2, float v1y2,
float v2x1, float v2y1, float v2x2, float v2y2
) {
float d1, d2;
float a1, a2, b1, b2, c1, c2;
// Convert vector 1 to a line (line 1) of infinite length.
// We want the line in linear equation standard form: A*x + B*y + C = 0
// See: http://en.wikipedia.org/wiki/Linear_equation
a1 = v1y2 - v1y1;
b1 = v1x1 - v1x2;
c1 = (v1x2 * v1y1) - (v1x1 * v1y2);
// Every point (x,y), that solves the equation above, is on the line,
// every point that does not solve it, is not. The equation will have a
// positive result if it is on one side of the line and a negative one
// if is on the other side of it. We insert (x1,y1) and (x2,y2) of vector
// 2 into the equation above.
d1 = (a1 * v2x1) + (b1 * v2y1) + c1;
d2 = (a1 * v2x2) + (b1 * v2y2) + c1;
// If d1 and d2 both have the same sign, they are both on the same side
// of our line 1 and in that case no intersection is possible. Careful,
// 0 is a special case, that's why we don't test ">=" and "<=",
// but "<" and ">".
if (d1 > 0 && d2 > 0) return NO;
if (d1 < 0 && d2 < 0) return NO;
// The fact that vector 2 intersected the infinite line 1 above doesn't
// mean it also intersects the vector 1. Vector 1 is only a subset of that
// infinite line 1, so it may have intersected that line before the vector
// started or after it ended. To know for sure, we have to repeat the
// the same test the other way round. We start by calculating the
// infinite line 2 in linear equation standard form.
a2 = v2y2 - v2y1;
b2 = v2x1 - v2x2;
c2 = (v2x2 * v2y1) - (v2x1 * v2y2);
// Calculate d1 and d2 again, this time using points of vector 1.
d1 = (a2 * v1x1) + (b2 * v1y1) + c2;
d2 = (a2 * v1x2) + (b2 * v1y2) + c2;
// Again, if both have the same sign (and neither one is 0),
// no intersection is possible.
if (d1 > 0 && d2 > 0) return NO;
if (d1 < 0 && d2 < 0) return NO;
// If we get here, only two possibilities are left. Either the two
// vectors intersect in exactly one point or they are collinear, which
// means they intersect in any number of points from zero to infinite.
if ((a1 * b2) - (a2 * b1) == 0.0f) return COLLINEAR;
// If they are not collinear, they must intersect in exactly one point.
return YES;
}
इनपुट मान वेक्टर 1 ( और ) और वेक्टर 2 ( और ) के दो समापन बिंदु हैं । तो आपके पास 2 वैक्टर, 4 अंक, 8 निर्देशांक हैं। और स्पष्ट हैं। चौराहों को बढ़ाता है, कुछ नहीं करता है।v1x1/v1y1v1x2/v1y2v2x1/v2y1v2x2/v2y2YESNOYESNO
COLLINEAR के बारे में क्या? इसका अर्थ है कि दोनों वैक्टर एक ही अनंत रेखा पर स्थित हैं, स्थिति और लंबाई के आधार पर, वे बिल्कुल भी प्रतिच्छेद नहीं करते हैं या वे एक अंतहीन संख्या में बिताते हैं। मुझे पूरी तरह से यकीन नहीं है कि इस मामले को कैसे संभालना है, मैं इसे चौराहे के रूप में नहीं गिनूंगा। खैर, यह मामला चलन में नहीं बल्कि वैसे भी है क्योंकि फ्लोटिंग पॉइंट राउंडिंग त्रुटियां हैं; बेहतर कोड शायद == 0.0fइसके लिए परीक्षण नहीं करेगा, बल्कि कुछ के लिए < epsilon, जहां एप्सिलॉन एक छोटी संख्या है।
यदि आपको बड़ी संख्या में बिंदुओं का परीक्षण करने की आवश्यकता है, तो आप निश्चित रूप से बहुभुज पक्षों के रैखिक समीकरण मानक रूपों को स्मृति में रखकर पूरी चीज को थोड़ा तेज कर सकते हैं, इसलिए आपको हर बार इनकी पुनर्गणना नहीं करनी होगी। यह आपको मेमोरी में तीन फ्लोटिंग पॉइंट वैल्यू को स्टोर करने के बदले में प्रत्येक परीक्षण पर दो फ्लोटिंग पॉइंट गुणा और तीन फ़्लोटिंग पॉइंट सबट्रैक्शन बचाएगा। यह एक विशिष्ट मेमोरी बनाम कम्प्यूटेशन टाइम ट्रेड ऑफ है।
अंतिम लेकिन कम से कम नहीं: यदि आप समस्या को हल करने के लिए 3 डी हार्डवेयर का उपयोग कर सकते हैं, तो एक दिलचस्प विकल्प है। बस GPU आप के लिए सभी काम करते हैं। एक पेंटिंग सतह बनाएं जो ऑफ स्क्रीन हो। इसे पूरी तरह से काले रंग से भरें। अब OpenGL या Direct3D को अपने बहुभुज (या यहां तक कि अपने सभी बहुभुजों को पेंट करें) यदि आप परीक्षण करना चाहते हैं कि बिंदु उनमें से किसी के भीतर है, लेकिन आप जिसकी परवाह नहीं करते हैं) और बहुभुज को अलग से भरें रंग, जैसे सफेद। यह देखने के लिए कि क्या कोई बिंदु बहुभुज के भीतर है, इस बिंदु का रंग ड्राइंग सतह से प्राप्त करें। यह सिर्फ एक O (1) मेमोरी लाने वाला है।
निश्चित रूप से यह विधि केवल प्रयोग करने योग्य है यदि आपकी ड्राइंग सतह को विशाल नहीं होना है। यदि यह GPU मेमोरी में फिट नहीं हो सकता है, तो यह विधि CPU पर करने की तुलना में धीमी है। यदि यह विशाल होना होगा और आपका GPU आधुनिक शेड्स का समर्थन करता है, तो आप अभी भी GPU को shader के रूप में ऊपर दिखाए गए किरण कास्टिंग को लागू करके उपयोग कर सकते हैं, जो कि बिल्कुल संभव है। बहुभुज या परीक्षण के लिए बड़ी संख्या में अंक के लिए, यह भुगतान करेगा, विचार करें कि कुछ GPU समानांतर में 64 से 256 बिंदुओं का परीक्षण करने में सक्षम होंगे। ध्यान दें कि सीपीयू से जीपीयू और बैक में डेटा ट्रांसफर करना हमेशा महंगा होता है, इसलिए सिंपल पॉलीगोन के एक जोड़े के खिलाफ कुछ बिंदुओं का परीक्षण करने के लिए, जहां या तो पॉइंट्स या पॉलीगोन डायनेमिक होते हैं और अक्सर बदलते रहेंगे, एक जीपीयू दृष्टिकोण शायद ही कभी भुगतान करेगा। बंद।
