मैं यह जानना चाहता हूं कि एक बिंदु एक आयत के अंदर है या नहीं। आयत किसी भी तरह से उन्मुख हो सकती है, और अक्ष संरेखित करने की आवश्यकता नहीं है।
एक विधि जो मैं सोच सकता था कि आयत को घुमाने के लिए आयत और बिंदु निर्देशांक को बारी बारी से करना था और फिर बस बिंदु के निर्देशांक का परीक्षण करके कि क्या वे आयत के भीतर निहित हैं या नहीं।
उपरोक्त विधि के लिए रोटेशन की आवश्यकता होती है और इसलिए फ्लोटिंग पॉइंट ऑपरेशन होते हैं। क्या ऐसा करने का कोई और कुशल तरीका है?
जवाबों:
आयत का प्रतिनिधित्व कैसे किया जाता है? तीन अंक? चार अंक? बिंदु, पक्ष और कोण? दो बिंदु और एक पक्ष? कुछ और? बिना यह जाने कि, आपके प्रश्न का उत्तर देने के किसी भी प्रयास का केवल विशुद्ध अकादमिक मूल्य होगा।
किसी भी मामले में, किसी भी उत्तल बहुभुज के लिए (आयत सहित) परीक्षण बहुत सरल है: बहुभुज के प्रत्येक किनारे की जांच करें, यह मानते हुए कि प्रत्येक किनारे वामावर्त दिशा में उन्मुख है, और परीक्षण करें कि क्या बिंदु किनारे के बाईं ओर स्थित है (बाईं ओर) -हैंड हाफ-प्लेन)। यदि सभी किनारे परीक्षण पास करते हैं - बिंदु अंदर है। यदि कम से कम एक विफल हो जाता है - बिंदु बाहर है।
यह परीक्षण करने के लिए कि बिंदु (xp, yp)किनारे के बाईं ओर स्थित है या नहीं (x1, y1) - (x2, y2), आपको बस गणना करने की आवश्यकता है
D = (x2 - x1) * (yp - y1) - (xp - x1) * (y2 - y1)
यदि D > 0, बिंदु बाईं ओर है। यदि D < 0, बिंदु दाईं ओर है। यदि D = 0, बिंदु रेखा पर है।
इस उत्तर के पिछले संस्करण में बाएं हाथ के परीक्षण का एक अलग रूप से भिन्न संस्करण वर्णित है (नीचे देखें)। लेकिन यह आसानी से दिखाया जा सकता है कि यह समान मूल्य की गणना करता है।
... यह जांचने के लिए कि बिंदु (xp, yp)किनारे के बाईं ओर स्थित है या नहीं (x1, y1) - (x2, y2), आपको किनारे वाली रेखा के लिए लाइन समीकरण बनाने की आवश्यकता है। समीकरण इस प्रकार है
A * x + B * y + C = 0
कहाँ पे
A = -(y2 - y1)
B = x2 - x1
C = -(A * x1 + B * y1)
अब आपको केवल गणना करने की आवश्यकता है
D = A * xp + B * yp + C
यदि D > 0, बिंदु बाईं ओर है। यदि D < 0, बिंदु दाईं ओर है। यदि D = 0, बिंदु रेखा पर है।
हालांकि, यह परीक्षण, फिर से, किसी भी उत्तल बहुभुज के लिए काम करता है, जिसका अर्थ है कि यह एक आयत के लिए बहुत सामान्य हो सकता है। एक आयत एक सरल परीक्षण की अनुमति दे सकती है ... उदाहरण के लिए, एक आयत में (या किसी अन्य समांतर चतुर्भुज में) के मान Aऔर Bसमान परिमाण लेकिन विरोध (यानी समानांतर) किनारों के लिए अलग-अलग संकेत होते हैं, जिसका उपयोग परीक्षण को सरल बनाने के लिए किया जा सकता है। ।
A'और B'द्वारा दिया जा सकता है A'=Bऔर B'=-A। 3. A xp + B ypदोनों किनारों के लिए गणना करने का कोई मतलब नहीं है, इसलिए उन्हें एक ही परीक्षण में मिलाएं। फिर एक आयत में होने के लिए आपका परीक्षण बन जाता है (v_min < A xp + B yp < v_max) && ( w_min < B xp - A yp < w_max )।
v_min, आदि?
v_minA x + B yआयत के इंटीरियर में सभी मूल्यों के लिए न्यूनतम मूल्य है (जो कोनों पर मूल्यांकन किए जाने पर न्यूनतम मूल्य है)। v_maxइसी अधिकतम है। w_?मान ही रहे हैं, लेकिन के लिए Bx - A y।
आयत को तीन बिंदुओं A, B, C द्वारा AB और BC लंबवत के साथ दर्शाया गया है, आपको केवल AB और BC पर क्वेरी बिंदु M के अनुमानों की जाँच करनी चाहिए:
0 <= dot(AB,AM) <= dot(AB,AB) &&
0 <= dot(BC,BM) <= dot(BC,BC)
ABनिर्देशांक (Bx-Ax, By-Ay) के साथ वेक्टर AB है, और dot(U,V)वैक्टर U और V: का डॉट उत्पाद है Ux*Vx+Uy*Vy।
अद्यतन करें । आइए इसको स्पष्ट करने के लिए एक उदाहरण लेते हैं: A (5,0) B (0,2) C (1,5) और D (6,3)। बिंदु निर्देशांक से, हम AB = (- 5,2), BC = (1,3), dot (AB, AB) = 29, dot (BC, BC) = 10 प्राप्त करते हैं।
क्वेरी बिंदु M (4,2) के लिए, हमारे पास AM = (- 1,2), BM = (4,0), डॉट (AB, AM) = 9, डॉट (BC, BM) = 4 है। M आयत के अंदर है।
क्वेरी बिंदु P (6,1) के लिए, हमारे पास AP = (1,1), BP = (6, -1), dot (AB, AP) = - 3, dot (BC, BP) = 3 है। P आयत के अंदर नहीं है, क्योंकि इसका प्रक्षेपण AB पर खंड AB के अंदर नहीं है।
मैंने एरिक बैनविले के उत्तर से उधार लिया है:
0 <= dot(AB,AM) <= dot(AB,AB) && 0 <= dot(BC,BM) <= dot(BC,BC)
जावास्क्रिप्ट में कौन सा इस तरह दिखता है:
function pointInRectangle(m, r) {
var AB = vector(r.A, r.B);
var AM = vector(r.A, m);
var BC = vector(r.B, r.C);
var BM = vector(r.B, m);
var dotABAM = dot(AB, AM);
var dotABAB = dot(AB, AB);
var dotBCBM = dot(BC, BM);
var dotBCBC = dot(BC, BC);
return 0 <= dotABAM && dotABAM <= dotABAB && 0 <= dotBCBM && dotBCBM <= dotBCBC;
}
function vector(p1, p2) {
return {
x: (p2.x - p1.x),
y: (p2.y - p1.y)
};
}
function dot(u, v) {
return u.x * v.x + u.y * v.y;
}
उदाहरण के लिए:
var r = {
A: {x: 50, y: 0},
B: {x: 0, y: 20},
C: {x: 10, y: 50},
D: {x: 60, y: 30}
};
var m = {x: 40, y: 20};
फिर:
pointInRectangle(m, r); // returns true.
यहाँ एक विजुअल टेस्ट के रूप में आउटपुट खींचने के लिए एक कोडपेन है :) http://codepen.io/mattburns/pen/jrrprN
mouseoverअपनी परियोजना में एक घटना का उपयोग करता हूं, इसलिए जब भी माउस उस बिंदु पर होता है जो कि आयत के अंदर होना चाहिए, तो यह माउस के चारों ओर एक काले वृत्त डॉट को प्रदर्शित करेगा, और आयत के बाहर इसे कुछ भी नहीं दिखाना चाहिए। मुझे इसे काम करने के लिए सहायता की आवश्यकता है लेकिन मैं बहुत भ्रमित हूं।
mouseovermousemoveबस टाइपो होना चाहिए ।
# Pseudo code
# Corners in ax,ay,bx,by,dx,dy
# Point in x, y
bax = bx - ax
bay = by - ay
dax = dx - ax
day = dy - ay
if ((x - ax) * bax + (y - ay) * bay < 0.0) return false
if ((x - bx) * bax + (y - by) * bay > 0.0) return false
if ((x - ax) * dax + (y - ay) * day < 0.0) return false
if ((x - dx) * dax + (y - dy) * day > 0.0) return false
return true
a, bऔर d। जबकि तीन बिंदु सिद्धांत में एक मनमानी आयत का प्रतिनिधित्व करने का एक वैध तरीका है, व्यवहार में सामान्य मामले में अंतराल निर्देशांक में सटीक रूप से करना असंभव है । सामान्य स्थिति में एक समांतर चतुर्भुज के साथ समाप्त हो जाएगा, जो आयत के बहुत करीब है, लेकिन फिर भी एक आयत नहीं है।
मुझे लगता है कि यह एक पुराना धागा है, लेकिन किसी को भी, जो एक विशुद्ध गणितीय दृष्टिकोण से इसे देखने में दिलचस्पी रखते हैं, गणित के ढेर एक्सचेंज पर एक उत्कृष्ट धागा है, यहां:
/math/190111/how-to-check-if-a-point-is-inside-a-rectangle
संपादित करें: इस धागे से प्रेरित होकर, मैंने आपकी बात को जल्दी से निर्धारित करने के लिए एक सरल वेक्टर विधि को एक साथ रखा है।
मान लीजिए कि आपके पास p1 = (X1, y1), P2 = (x2, y2), p3 = (x3, y3) और p4 = (x4, y4) के बिंदुओं के साथ घड़ी की दिशा में एक आयत है। यदि कोई बिंदु p = (x, y) आयत के अंदर स्थित है, तो डॉट उत्पाद (p - p1)। (P2 - p1) 0 और | P2 - p1। ^ 2, और (p - p1) के बीच स्थित होगा। (p4 - p1) 0 और | p4 - p1 | ^ 2 के बीच स्थित होगा। यह आयत की लंबाई और चौड़ाई के साथ वेक्टर p - p1 का प्रक्षेपण लेने के बराबर है, मूल के रूप में p1 के साथ।
यदि मैं एक समतुल्य कोड दिखाता हूं तो यह और अधिक महत्वपूर्ण हो सकता है:
p21 = (x2 - x1, y2 - y1)
p41 = (x4 - x1, y4 - y1)
p21magnitude_squared = p21[0]^2 + p21[1]^2
p41magnitude_squared = p41[0]^2 + p41[1]^2
for x, y in list_of_points_to_test:
p = (x - x1, y - y1)
if 0 <= p[0] * p21[0] + p[1] * p21[1] <= p21magnitude_squared:
if 0 <= p[0] * p41[0] + p[1] * p41[1]) <= p41magnitude_squared:
return "Inside"
else:
return "Outside"
else:
return "Outside"
और बस। यह समांतर चतुर्भुज के लिए भी काम करेगा।
bool pointInRectangle(Point A, Point B, Point C, Point D, Point m ) {
Point AB = vect2d(A, B); float C1 = -1 * (AB.y*A.x + AB.x*A.y); float D1 = (AB.y*m.x + AB.x*m.y) + C1;
Point AD = vect2d(A, D); float C2 = -1 * (AD.y*A.x + AD.x*A.y); float D2 = (AD.y*m.x + AD.x*m.y) + C2;
Point BC = vect2d(B, C); float C3 = -1 * (BC.y*B.x + BC.x*B.y); float D3 = (BC.y*m.x + BC.x*m.y) + C3;
Point CD = vect2d(C, D); float C4 = -1 * (CD.y*C.x + CD.x*C.y); float D4 = (CD.y*m.x + CD.x*m.y) + C4;
return 0 >= D1 && 0 >= D4 && 0 <= D2 && 0 >= D3;}
Point vect2d(Point p1, Point p2) {
Point temp;
temp.x = (p2.x - p1.x);
temp.y = -1 * (p2.y - p1.y);
return temp;}
मैंने अभी C ++ का उपयोग करके AnT का उत्तर लागू किया है। मैंने इस कोड का उपयोग यह जांचने के लिए किया है कि पिक्सेल का समन्वय (X, Y) आकार के अंदर है या नहीं।
यदि आप समस्या को हल नहीं कर सकते हैं तो आयत को आसान समस्याओं में विभाजित करने का प्रयास करें। आयत को 2 त्रिभुजों में विभाजित करें एक जाँच करें कि यदि बिंदु उनमें से किसी के अंदर है जैसे वे यहाँ व्याख्या करते हैं
अनिवार्य रूप से, आप एक बिंदु से प्रत्येक दो जोड़े लाइनों पर किनारों के माध्यम से चक्र करते हैं। फिर क्रॉस उत्पाद का उपयोग करके दो लाइनों के बीच बिंदु है या नहीं यह जांचने के लिए क्रॉस उत्पाद का उपयोग करना। यदि यह सभी 3 बिंदुओं के लिए सत्यापित है, तो बिंदु त्रिकोण के अंदर है। इस विधि के बारे में अच्छी बात यह है कि यह किसी भी फ्लोट-पॉइंट त्रुटियों को पैदा नहीं करता है जो कि यदि आप कोणों की जांच करते हैं तो यह होता है।
हर l i के लिए एक समीकरण बनाओ । के समीकरण प्रकार:
f i (P) = 0
P एक बिंदु है। अंक के लिए, एल से संबंधित मैं , समीकरण सच है।
इसलिए, हमें इसकी जाँच करनी होगी:
f AB (P) f AB (C)> = 0
f BC (P) f BC (D)> = 0
f CD (P) f CD (A)> = 0
f DA (P) f DA (B)> = 0
असमानताएं सख्त नहीं हैं, अगर कोई बिंदु सीमा पर है, तो यह आयत का भी है। यदि आपको सीमा पर बिंदुओं की आवश्यकता नहीं है, तो आप सख्त लोगों के लिए असमानताओं को बदल सकते हैं। लेकिन जब आप फ्लोटिंग पॉइंट ऑपरेशंस में काम करते हैं, तो विकल्प अप्रासंगिक है।
केवल एक चीज बची है जो दो बिंदुओं से गुजरने वाली रेखा के लिए एक समीकरण प्राप्त करना है। यह एक प्रसिद्ध रेखीय समीकरण है। आइए इसे एक पंक्ति AB और बिंदु P के लिए लिखें:
f AB (P) ≡ (x A -x B ) (y P -y B ) - (y A -y B ) (x P -x B )
चेक को सरल बनाया जा सकता है - चलो आयत घड़ी के साथ चलते हैं - ए, बी, सी, डी, ए। फिर सभी सही पक्ष लाइनों के दाईं ओर होंगे। इसलिए, हमें उस पक्ष के साथ तुलना करने की आवश्यकता नहीं है जहां एक और वर्टिस है। और हमें छोटी असमानताओं के सेट की जाँच करने की आवश्यकता है:
एफ एबी (पी)> = 0
एफ बीसी (पी)> = 0
f CD (P)> = 0
एफ डीए (पी)> = 0
लेकिन यह निर्देशांक के सामान्य, गणितज्ञ (स्कूल के गणित से) के लिए सही है, जहां एक्स दाईं ओर और वाई शीर्ष पर है। और भूगणित निर्देशांक के लिए, जैसा कि GPS में उपयोग किया जाता है, जहां X शीर्ष पर है, और Y दाईं ओर है, हमें असमानताओं को चालू करना होगा:
एफ एबी (पी) <= 0
एफ बीसी (पी) <= 0
f CD (P) <= 0
f DA (P) <= 0
यदि आप कुल्हाड़ियों की दिशाओं के साथ निश्चित नहीं हैं, तो इस सरलीकृत जांच से सावधान रहें - ज्ञात प्लेसमेंट के साथ एक बिंदु की जांच करें, यदि आपने सही असमानताओं को चुना है।
सबसे आसान तरीका मुझे लगा कि आयत की धुरी पर बिंदु को प्रोजेक्ट करना है। मुझे समझाने दो:
यदि आप आयत के केंद्र से ऊपर या नीचे के किनारे और बाएँ या दाएँ किनारे से वेक्टर प्राप्त कर सकते हैं। और आपके पास आयत के केंद्र से आपके बिंदु तक एक वेक्टर भी है, आप उस बिंदु को अपनी चौड़ाई और ऊंचाई वाले वैक्टर पर प्रोजेक्ट कर सकते हैं।
पी = बिंदु वेक्टर, एच = ऊंचाई वेक्टर, डब्ल्यू = चौड़ाई वेक्टर
वैक्टर को उनके परिमाण द्वारा विभाजित करके यूनिट वेक्टर डब्ल्यू ', एच' प्राप्त करें
proj_P, H = P - (P.H ') H' proj_P, W = P - (P.W ')'
जब तक im गलत नहीं है, जो मुझे नहीं लगता कि मैं हूं ... (अगर मैं गलत हूं तो मुझे सुधारें) लेकिन अगर ऊंचाई पर आपकी बात के प्रक्षेपण का परिमाण कम है तो ऊंचाई वेक्टर का परिमाण (जो है) आयत की ऊँचाई का आधा) और चौड़ाई वेक्टर पर आपके बिंदु के प्रक्षेपण की परिमाण है, तो आपके पास अपनी आयत के अंदर एक बिंदु है।
यदि आपके पास एक सार्वभौमिक समन्वय प्रणाली है, तो आपको वेक्टर घटाव का उपयोग करके ऊंचाई / चौड़ाई / बिंदु वैक्टर का पता लगाना पड़ सकता है। वेक्टर अनुमान अद्भुत हैं! उसे याद रखो।
निरंतरता में उत्तर देता है। हमें इसे बनाने के लिए /math/190111/how-to-check-if-a-point-is-inside-a-rectangle/190373#190373 समाधान का उपयोग करने की आवश्यकता है
नीचे काम नहीं करता है
0 <= dot (AB, AM) <= dot (AB, AB) && 0 <= dot (BC, BM) <= dot (BC, BC)
नीचे काम करता है
0 <= डॉट (एबी, एएम) <= डॉट (एबी, एबी) और& 0 <= डॉट (एएम, एसी) <= डॉट (एसी, एसी)
आप उसी के लिए जावास्क्रिप्ट कंसोल // जावास्क्रिप्ट समाधान में नीचे चिपकाकर जांच करें
var screenWidth = 320;
var screenHeight = 568;
var appHeaderWidth = 320;
var AppHeaderHeight = 65;
var regionWidth = 200;
var regionHeight = 200;
this.topLeftBoundary = {
A: {x: 0, y: AppHeaderHeight},
B: {x: regionWidth, y: AppHeaderHeight},
C: {x: 0, y: regionHeight + AppHeaderHeight},
D: {x: regionWidth, y: regionHeight + AppHeaderHeight}
}
this.topRightBoundary = {
A: {x: screenWidth, y: AppHeaderHeight},
B: {x: screenWidth - regionWidth, y: AppHeaderHeight},
C: {x: screenWidth, y: regionHeight + AppHeaderHeight},
D: {x: screenWidth - regionWidth, y: regionHeight + AppHeaderHeight}
}
this.bottomRightBoundary = {
A: {x: screenWidth, y: screenHeight},
B: {x: screenWidth - regionWidth, y: screenHeight},
C: {x: screenWidth, y: screenHeight - regionHeight},
D: {x: screenWidth - regionWidth, y: screenHeight - regionHeight}
}
this.bottomLeftBoundary = {
A: {x: 0, y: screenHeight},
B: {x: regionWidth, y: screenHeight},
C: {x: 0, y: screenHeight - regionHeight},
D: {x: regionWidth, y: screenHeight - regionHeight}
}
console.log(this.topLeftBoundary);
console.log(this.topRightBoundary);
console.log(this.bottomRightBoundary);
console.log(this.bottomLeftBoundary);
checkIfTapFallsInBoundary = function (region, point) {
console.log("region " + JSON.stringify(region));
console.log("point" + JSON.stringify(point));
var r = region;
var m = point;
function vector(p1, p2) {
return {
x: (p2.x - p1.x),
y: (p2.y - p1.y)
};
}
function dot(u, v) {
console.log("DOT " + (u.x * v.x + u.y * v.y));
return u.x * v.x + u.y * v.y;
}
function pointInRectangle(m, r) {
var AB = vector(r.A, r.B);
var AM = vector(r.A, m);
var AC = vector(r.A, r.C);
var BC = vector(r.B, r.C);
var BM = vector(r.B, m);
console.log("AB " + JSON.stringify(AB));
console.log("AM " + JSON.stringify(AM));
console.log("AM " + JSON.stringify(AC));
console.log("BC " + JSON.stringify(BC));
console.log("BM " + JSON.stringify(BM));
var dotABAM = dot(AB, AM);
var dotABAB = dot(AB, AB);
var dotBCBM = dot(BC, BM);
var dotBCBC = dot(BC, BC);
var dotAMAC = dot(AM, AC);
var dotACAC = dot(AC, AC);
console.log("ABAM " + JSON.stringify(dotABAM));
console.log("ABAB " + JSON.stringify(dotABAB));
console.log("BCBM " + JSON.stringify(dotBCBM));
console.log("BCBC " + JSON.stringify(dotBCBC));
console.log("AMAC " + JSON.stringify(dotAMAC));
console.log("ACAC" + JSON.stringify(dotACAC));
var check = ((0 <= dotABAM && dotABAM <= dotABAB) && (0 <= dotBCBM && dotBCBM <= dotBCBC));
console.log(" first check" + check);
var check = ((0 <= dotABAM && dotABAM <= dotABAB) && (0 <= dotAMAC && dotAMAC <= dotACAC));
console.log("second check" + check);
return check;
}
return pointInRectangle(m, r);
}
//var point = {x: 136, y: 342};
checkIfTapFallsInBoundary(topLeftBoundary, {x: 136, y: 342});
checkIfTapFallsInBoundary(topRightBoundary, {x: 136, y: 274});
checkIfTapFallsInBoundary(bottomRightBoundary, {x: 141, y: 475});
checkIfTapFallsInBoundary(bottomRightBoundary, {x: 131, y: 272});
checkIfTapFallsInBoundary(bottomLeftBoundary, {x: 131, y: 272});