कैसे बताया जाए कि एक बिंदु एक रेखा के दाईं या बाईं ओर है

Question

मेरे पास अंकों का एक सेट है। मैं उन्हें 2 अलग-अलग सेटों में अलग करना चाहता हूं। ऐसा करने के लिए, मैं दो बिंदु ( ए और बी ) चुनता हूं और उनके बीच एक काल्पनिक रेखा खींचता हूं। अब मैं उन सभी बिंदुओं को रखना चाहता हूं जो इस लाइन से एक सेट में छोड़ दिए जाते हैं और जो दूसरे सेट में इस लाइन से सही हैं।

मैं किसी भी दिए गए बिंदु z के लिए कैसे बता सकता हूं कि यह बाएं में है या दाएं सेट में? मैंने azb के बीच के कोण की गणना करने की कोशिश की - 180 से छोटे कोण दाहिने हाथ की तरफ, बाएं हाथ की तरफ 180 से अधिक हैं - लेकिन आर्ककोस की परिभाषा के कारण, गणना किए गए कोण हमेशा 180 ° से छोटे होते हैं। क्या 180 ° (या किसी अन्य सूत्र को दाईं या बाईं ओर चुनने के लिए) कोणों की गणना करने का कोई सूत्र है?

Comments

कैसे सही या बाएं परिभाषित किया गया है? A) P1 से P2 या B की ओर देखने के मामले में) विमान में रेखा के बाएँ या दाएँ।

— 18

अपने प्रश्न के दूसरे भाग को स्पष्ट करने के लिए, आप सही कोण की गणना करने के लिए एकानोस () के बजाय atan2 () का उपयोग कर सकते हैं। हालांकि, एक क्रॉस उत्पाद का उपयोग करना सबसे अच्छा समाधान है क्योंकि एरिक बैनविले ने बताया।

— dionyziz

नीचे दिए गए कई समाधान काम नहीं करते हैं क्योंकि वे विपरीत उत्तर देते हैं यदि आप इंटरचेंज अंक और बी (वे बिंदु जो हम अपनी लाइन को परिभाषित करने के लिए उपयोग कर रहे हैं)। मैं क्लोजर में एक समाधान देता हूं जो दो बिंदुओं को लेक्सोग्राफिक रूप से पहले तीसरे बिंदु से तुलना करने से पहले हल करता है।

— पर्पलजेट

Answer 1

वैक्टर के निर्धारक के संकेत का उपयोग करें (AB,AM), जहां M(X,Y)क्वेरी बिंदु है:

position = sign((Bx - Ax) * (Y - Ay) - (By - Ay) * (X - Ax))

यह 0लाइन पर है, और +1एक तरफ, -1दूसरी तरफ है।

Comments

+1 अच्छा, एक बात से अवगत होना: बिंदु पर लाइन लगभग बहुत होने पर राउंडिंग एरर एक चिंता का विषय हो सकता है। अधिकांश उपयोगों के लिए कोई समस्या नहीं है , लेकिन यह समय-समय पर लोगों को काटता है।

— स्टीफन कैनन

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

— स्टीफन कैनन

स्पष्टीकरण के लिए, यह लाइन (बीए) और वेक्टर से बिंदु (मा) के बीच क्रॉस उत्पाद के जेड-घटक के समान है। अपने पसंदीदा वेक्टर-वर्ग में: स्थिति = साइन ((बा) .cross (मा) [2])

— लार्समोआ

स्वैपिंग ए एंड बी एक ही लाइन नहीं रखेंगी, लेकिन साइन इन करें positions?

— जयन

हाँ। ए, बी अभिविन्यास को परिभाषित करता है, जैसे "ए पर खड़े होने पर और बी को देखने पर आपके बाएं तरफ"।

— एरिक बैनविले

Answer 2

इस कोड को आज़माएं जो एक क्रॉस उत्पाद का उपयोग करता है :

public bool isLeft(Point a, Point b, Point c){
     return ((b.X - a.X)*(c.Y - a.Y) - (b.Y - a.Y)*(c.X - a.X)) > 0;
}

जहां = एक पंक्ति बिंदु 1; बी = लाइन बिंदु 2; सी = के खिलाफ जाँच करने के लिए बिंदु।

यदि सूत्र 0 के बराबर है, तो अंक कॉलिनियर हैं।

यदि रेखा क्षैतिज है, तो यह सही है यदि बिंदु रेखा के ऊपर है।

Comments

यदि रेखा लंबवत है तो?

— टॉफिक अहमद

क्या आपका मतलब है डॉट प्रोडक्ट?

— बैयान हुआंग

@lzprgmr: नहीं, यह एक क्रॉस उत्पाद है, जो समान रूप से एक 2D मैट्रिक्स का निर्धारक है। पंक्तियों (ए, बी) और (सी, डी) द्वारा परिभाषित 2 डी मैट्रिक्स पर विचार करें। निर्धारक विज्ञापन - ई.पू. ऊपर दिया गया रूप, एक वेक्टर, (a, b) में 2 बिंदुओं द्वारा दर्शाई गई रेखा को रूपांतरित कर रहा है और फिर प्राप्त करने के लिए PointA और PointC का उपयोग करके एक और वेक्टर को परिभाषित कर रहा है (c, d): (a, b) = (PointB.x - PointA.x, PointB.y - PointA.y) (c, d) = (PointC.x - PointA.x, PointC.y - PointA.y) निर्धारक इसलिए है जैसा कि इसके पद में बताया गया है।

— एंडीज

मुझे लगता है कि यह एक क्रॉस उत्पाद या डॉट उत्पाद है, इस पर भ्रम है क्योंकि यह दो आयामों में है। यह है पार उत्पाद, दो आयामों में: mathworld.wolfram.com/CrossProduct.html

— brianmearns

इसके लायक क्या है, इसके लिए थोड़ा सरलीकरण किया जा सकता है return (b.x - a.x)*(c.y - a.y) > (b.y - a.y)*(c.x - a.x);, लेकिन कंपाइलर शायद वैसे भी अनुकूलन करता है।

— निकु स्टियुरका

Answer 3

आप निर्धारक के चिन्ह को देखते हैं

| x2-x1  x3-x1 |
| y2-y1  y3-y1 |

यह एक तरफ अंक के लिए सकारात्मक होगा, और दूसरे पर नकारात्मक (और रेखा पर अंक के लिए शून्य)।

Comments

इस उत्तर पर विस्तार करते हुए, यदि लोग क्रॉस प्रोडक्ट की तरह दिखते हैं तो यह नहीं जानते हैं। अगला विज़ुअल स्टेप है ((x2-X1) * (y3-y1)) - ((y2 - y1) * (x3-X1))

— Franky Rivera

Answer 4

वेक्टर (y1 - y2, x2 - x1)लाइन के लंबवत है, और हमेशा दाएं इंगित करता है (या हमेशा इंगित करता है कि यदि आप विमान अभिविन्यास खदान से अलग हैं)।

फिर आप उस वेक्टर के डॉट उत्पाद की गणना कर सकते हैं और (x3 - x1, y3 - y1)यह निर्धारित कर सकते हैं कि बिंदु लंबवत वेक्टर (डॉट उत्पाद> 0) के समान रेखा पर स्थित है या नहीं।

Answer 5

लाइन एब के समीकरण का उपयोग करते हुए , लाइन पर x-निर्देशांक को उसी y- समन्वय पर ले जाएं, जिस बिंदु को क्रमबद्ध किया जाना है।

• यदि बिंदु का x> रेखा का x है, तो बिंदु रेखा के दाईं ओर है।
• यदि बिंदु का x <रेखा का x है, तो बिंदु रेखा के बाईं ओर है।
• यदि बिंदु का x == रेखा का x है, तो बिंदु रेखा पर है।

Comments

यह गलत है, क्योंकि जैसा कि आप पहले उत्तर पर आगिनोर की टिप्पणी से देख सकते हैं, हम यह पता नहीं लगाना चाहते हैं कि बिंदु दाईं ओर की रेखा एबी के बाईं ओर है या नहीं, यदि आप A पर खड़े हैं और देख रहे हैं B की ओर यह आपके बाईं ओर है या आपके दाएं तरफ है?

— dionyziz

@dionyziz - हुह? मेरा जवाब एबी के माध्यम से लाइन को "दिशा" प्रदान नहीं करता है। मेरा उत्तर मानता है कि "बाएं" गलियारे प्रणाली की -x दिशा है। स्वीकृत उत्तर ने वेक्टर AB को परिभाषित करने के लिए चुना , और क्रॉस उत्पाद का उपयोग करके बाएं को परिभाषित किया। मूल प्रश्न निर्दिष्ट नहीं करता है कि "बाएं" का क्या मतलब है।

— मबेकिश

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

— टूलमेकरसैट

यह पूरी तरह से मैं क्या देख रहा था। मैं यह जानना नहीं चाहता कि A, B से ऊपर या नीचे है। मैं यह जानना चाहता हूं कि क्या यह रेखा की बाईं (ऋणात्मक x दिशा) है!

— Jayen

Answer 6

यदि आपके पास एक ऊर्ध्वाधर रेखा है, तो पहले जांचें:

if (x2-x1) == 0
  if x3 < x2
     it's on the left
  if x3 > x2
     it's on the right
  else
     it's on the line

फिर, ढलान की गणना करें: m = (y2-y1)/(x2-x1)

फिर, बिंदु ढलान फॉर्म का उपयोग करके लाइन का एक समीकरण बनाएं y - y1 = m*(x-x1) + y1:। मेरे स्पष्टीकरण के लिए, इसे ढलान-अवरोधन रूप में सरल करें (आपके एल्गोरिथ्म में आवश्यक नहीं) y = mx+b:।

अब में प्लग (x3, y3)के लिए xऔर y। यहां कुछ छद्मकोड का विवरण दिया गया है कि क्या होना चाहिए:

if m > 0
  if y3 > m*x3 + b
    it's on the left
  else if y3 < m*x3 + b
    it's on the right
  else
    it's on the line
else if m < 0
  if y3 < m*x3 + b
    it's on the left
  if y3 > m*x3+b
    it's on the right
  else
    it's on the line
else
  horizontal line; up to you what you do

Comments

विफलता: ऊर्ध्वाधर लाइनों के लिए ढाल गणना अमान्य है। अंतहीन अगर / और सामान। यकीन नहीं होता है कि अगर ओपी का मतलब बाएं / दाएं से है - तो अगर इसे 90 डिग्री घुमाया जाए तो यह कोड आधे में कट जाएगा क्योंकि "ऊपर" दाएं या बाएं होगा।

— फकहलर

इस जवाब में कई समस्याएं हैं। ऊर्ध्वाधर रेखाएं शून्य से विभाजित होने का कारण बनती हैं। इससे भी बदतर, यह विफल हो जाता है क्योंकि यह इस बारे में चिंता नहीं करता है कि रेखा का ढलान सकारात्मक है या नकारात्मक।

@phkahler, वर्टिकल लाइन इश्यू तय किया। निश्चित रूप से एक परीक्षण के मामले को भूलने में विफलता नहीं है लेकिन दयालु शब्दों के लिए धन्यवाद। "अंतहीन अगर / और" गणितीय सिद्धांत को समझाने के लिए है; ओपी के सवाल में कुछ भी प्रोग्रामिंग का उल्लेख नहीं है। @woodchips, वर्टिकल लाइन इशू को ठीक करता है। ढलान चर एम है; मैं जांच करता हूं कि यह कब सकारात्मक या नकारात्मक है।

— maksim

Answer 7

मैंने इसे जावा में लागू किया और एक इकाई परीक्षण (नीचे स्रोत) चलाया। उपरोक्त समाधानों में से कोई भी काम नहीं करता है। यह कोड यूनिट टेस्ट पास करता है। अगर किसी को एक यूनिट टेस्ट मिलता है जो पास नहीं होता है, तो कृपया मुझे बताएं।

कोड: नोट: nearlyEqual(double,double)यदि दो नंबर बहुत करीब हैं तो यह सच है।

/*
 * @return integer code for which side of the line ab c is on.  1 means
 * left turn, -1 means right turn.  Returns
 * 0 if all three are on a line
 */
public static int findSide(
        double ax, double ay, 
        double bx, double by,
        double cx, double cy) {
    if (nearlyEqual(bx-ax,0)) { // vertical line
        if (cx < bx) {
            return by > ay ? 1 : -1;
        }
        if (cx > bx) {
            return by > ay ? -1 : 1;
        } 
        return 0;
    }
    if (nearlyEqual(by-ay,0)) { // horizontal line
        if (cy < by) {
            return bx > ax ? -1 : 1;
        }
        if (cy > by) {
            return bx > ax ? 1 : -1;
        } 
        return 0;
    }
    double slope = (by - ay) / (bx - ax);
    double yIntercept = ay - ax * slope;
    double cSolution = (slope*cx) + yIntercept;
    if (slope != 0) {
        if (cy > cSolution) {
            return bx > ax ? 1 : -1;
        }
        if (cy < cSolution) {
            return bx > ax ? -1 : 1;
        }
        return 0;
    }
    return 0;
}

यहाँ इकाई परीक्षण है:

@Test public void testFindSide() {
    assertTrue("1", 1 == Utility.findSide(1, 0, 0, 0, -1, -1));
    assertTrue("1.1", 1 == Utility.findSide(25, 0, 0, 0, -1, -14));
    assertTrue("1.2", 1 == Utility.findSide(25, 20, 0, 20, -1, 6));
    assertTrue("1.3", 1 == Utility.findSide(24, 20, -1, 20, -2, 6));

    assertTrue("-1", -1 == Utility.findSide(1, 0, 0, 0, 1, 1));
    assertTrue("-1.1", -1 == Utility.findSide(12, 0, 0, 0, 2, 1));
    assertTrue("-1.2", -1 == Utility.findSide(-25, 0, 0, 0, -1, -14));
    assertTrue("-1.3", -1 == Utility.findSide(1, 0.5, 0, 0, 1, 1));

    assertTrue("2.1", -1 == Utility.findSide(0,5, 1,10, 10,20));
    assertTrue("2.2", 1 == Utility.findSide(0,9.1, 1,10, 10,20));
    assertTrue("2.3", -1 == Utility.findSide(0,5, 1,10, 20,10));
    assertTrue("2.4", -1 == Utility.findSide(0,9.1, 1,10, 20,10));

    assertTrue("vertical 1", 1 == Utility.findSide(1,1, 1,10, 0,0));
    assertTrue("vertical 2", -1 == Utility.findSide(1,10, 1,1, 0,0));
    assertTrue("vertical 3", -1 == Utility.findSide(1,1, 1,10, 5,0));
    assertTrue("vertical 3", 1 == Utility.findSide(1,10, 1,1, 5,0));

    assertTrue("horizontal 1", 1 == Utility.findSide(1,-1, 10,-1, 0,0));
    assertTrue("horizontal 2", -1 == Utility.findSide(10,-1, 1,-1, 0,0));
    assertTrue("horizontal 3", -1 == Utility.findSide(1,-1, 10,-1, 0,-9));
    assertTrue("horizontal 4", 1 == Utility.findSide(10,-1, 1,-1, 0,-9));

    assertTrue("positive slope 1", 1 == Utility.findSide(0,0, 10,10, 1,2));
    assertTrue("positive slope 2", -1 == Utility.findSide(10,10, 0,0, 1,2));
    assertTrue("positive slope 3", -1 == Utility.findSide(0,0, 10,10, 1,0));
    assertTrue("positive slope 4", 1 == Utility.findSide(10,10, 0,0, 1,0));

    assertTrue("negative slope 1", -1 == Utility.findSide(0,0, -10,10, 1,2));
    assertTrue("negative slope 2", -1 == Utility.findSide(0,0, -10,10, 1,2));
    assertTrue("negative slope 3", 1 == Utility.findSide(0,0, -10,10, -1,-2));
    assertTrue("negative slope 4", -1 == Utility.findSide(-10,10, 0,0, -1,-2));

    assertTrue("0", 0 == Utility.findSide(1, 0, 0, 0, -1, 0));
    assertTrue("1", 0 == Utility.findSide(0,0, 0, 0, 0, 0));
    assertTrue("2", 0 == Utility.findSide(0,0, 0,1, 0,2));
    assertTrue("3", 0 == Utility.findSide(0,0, 2,0, 1,0));
    assertTrue("4", 0 == Utility.findSide(1, -2, 0, 0, -1, 2));
}

Answer 8

अंक (कुल्हाड़ी, आय) (बीएक्स, बाय) और (सीएक्स, साइ) मानते हुए, आपको गणना करने की आवश्यकता है:

(Bx - कुल्हाड़ी) * (Cy - अय) - (By - Ay) * (Cx - कुल्हाड़ी)

यदि बिंदु C, A और B द्वारा बनाई गई रेखा पर है, तो यह शून्य के बराबर होगा और पक्ष के आधार पर एक अलग संकेत होगा। यह आपके (x, y) निर्देशांक के उन्मुखीकरण पर निर्भर करता है, लेकिन आप इस सूत्र में A, B और C के लिए परीक्षण मानों को प्लग कर सकते हैं ताकि यह निर्धारित किया जा सके कि नकारात्मक मान बाईं ओर हैं या दाईं ओर।

Answer 9

मैं भौतिकी से प्रेरित एक समाधान प्रदान करना चाहता था।

लाइन के साथ लगाए गए बल की कल्पना करें और आप बिंदु के बारे में बल के टोक़ को माप रहे हैं। यदि टोक सकारात्मक (वामावर्त) है तो बिंदु रेखा के "बाएं" पर है, लेकिन यदि टोक नकारात्मक है तो बिंदु रेखा का "दाईं" है।

इसलिए यदि बल वेक्टर रेखा को परिभाषित करने वाले दो बिंदुओं के बराबर होता है

fx = x_2 - x_1
fy = y_2 - y_1

आप (px,py)निम्नलिखित परीक्षण के संकेत के आधार पर एक बिंदु के किनारे का परीक्षण करते हैं

var torque = fx*(py-y_1)-fy*(px-x_1)
if  torque>0  then
     "point on left side"
else if torque <0 then
     "point on right side"  
else
     "point on line"
end if

Answer 10

मूल रूप से, मुझे लगता है कि एक समाधान है जो बहुत आसान और सीधे आगे है, किसी भी दिए गए बहुभुज के लिए, चार कोने (p1, P2, p3, p4) से मिलकर कह सकते हैं, बहुभुज में दो चरम विपरीत कोने खोजें, एक और में उदाहरण के लिए, उदाहरण के लिए सबसे ऊपर बाईं ओर का शीर्ष (P1 कहने दें) और विपरीत शीर्ष जो सबसे नीचे दाईं ओर स्थित है (कहने दें)। इसलिए, आपके परीक्षण बिंदु C (x, y) को देखते हुए, अब आपको C और p1 और C और p4 के बीच दोहरी जांच करनी होगी:

अगर cx> p1x और cy> p1y ==> का अर्थ है कि C कम है और p1 के दाईं ओर है तो cx <P2x और cy <P2y ==> का अर्थ है कि C ऊपरी है और p4 के बाएँ

निष्कर्ष, C आयत के अंदर है।

धन्यवाद :)

Comments

(१) एक अलग प्रश्न का उत्तर पूछा गया था? "बाउंडिंग बॉक्स" परीक्षण की तरह लगता है, जब एक आयत दोनों अक्षों के साथ गठबंधन किया जाता है। (2) अधिक विस्तार से: 4 बिंदुओं के बीच संभावित संबंधों के बारे में धारणा बनाता है। उदाहरण के लिए, एक आयत लें, और इसे 45 डिग्री घुमाएं, ताकि आपके पास एक हीरा हो। उस हीरे में "टॉप-लेफ्ट पॉइंट" जैसी कोई चीज नहीं है। सबसे बाएं बिंदु न तो सबसे ऊपर या सबसे नीचे है। और निश्चित रूप से, 4 अंक भी अजनबी आकार बना सकते हैं। उदाहरण के लिए, 3 अंक एक दिशा में दूर हो सकते हैं, और 4 अंक दूसरी दिशा में। कोशिश करते रहो!

— टूलमेकरसैट

Answer 11

माणिक में @ एवीबी का जवाब

det = Matrix[
  [(x2 - x1), (x3 - x1)],
  [(y2 - y1), (y3 - y1)]
].determinant

यदि detइसके ऊपर सकारात्मक है, यदि इसके नीचे नकारात्मक है। यदि 0, लाइन पर इसके।

Answer 12

यहाँ एक संस्करण है, फिर से क्रॉस प्रोडक्ट लॉजिक का उपयोग करते हुए, क्लीजुरे में लिखा गया है।

(defn is-left? [line point]
  (let [[[x1 y1] [x2 y2]] (sort line)
        [x-pt y-pt] point]
    (> (* (- x2 x1) (- y-pt y1)) (* (- y2 y1) (- x-pt x1)))))

उदाहरण उपयोग:

(is-left? [[-3 -1] [3 1]] [0 10])
true

जो यह कहना है कि बिंदु (0, 10), (-3, -1) और (3, 1) द्वारा निर्धारित रेखा के बाईं ओर है।

नोट: यह कार्यान्वयन एक ऐसी समस्या को हल करता है जो अन्य (अब तक) कोई भी नहीं करता है! लाइन निर्धारित करने वाले बिंदुओं को देते समय आदेश मायने रखता है । यानी, यह एक निश्चित अर्थ में, "निर्देशित रेखा" है। तो उपरोक्त कोड के साथ, यह मंगलाचरण भी परिणाम देता है true:

(is-left? [[3 1] [-3 -1]] [0 10])
true

इस कोड के स्निपेट के कारण ऐसा है:

(sort line)

अंत में, अन्य क्रॉस उत्पाद आधारित समाधानों की तरह, यह समाधान एक बूलियन देता है, और कोलिनैरिटी के लिए तीसरा परिणाम नहीं देता है। लेकिन यह एक परिणाम देगा जो समझ में आता है, उदाहरण के लिए:

(is-left? [[1 1] [3 1]] [10 1])
false

Answer 13

नेटर्स द्वारा प्रदान किए गए समाधान की भावना प्राप्त करने का एक वैकल्पिक तरीका थोड़ा ज्यामिति निहितार्थ को समझना है।

बता दें कि pqr = [P, Q, R] ऐसे बिंदु हैं जो एक ऐसा विमान बनाते हैं जिसे रेखा [P, R] द्वारा 2 भुजाओं में विभाजित किया जाता है । हमें पता लगाना है कि pqr पर दो अंक विमान , A, B, एक ही तरफ हैं।

Pqr समतल पर किसी भी बिंदु T को 2 वैक्टर के साथ दर्शाया जा सकता है: v = PQ और u = RQ, जैसे:

टी '= टीक्यू = आई * वी + जे * यू

अब ज्यामिति निहितार्थ:

1. i + j = 1: पीआर लाइन पर टी
2. i + j <1: Sq पर T
3. i + j> 1: T Snq पर
4. i + j = 0: T = Q
5. i + j <0: T Sq पर और Q के परे है।

i+j: <0 0 <1 =1 >1 ---------Q------[PR]--------- <== this is PQR plane ^ pr line

सामान्य रूप में,

• i + j एक माप है कि T, Q या रेखा से कितनी दूर है [P, R] और
• के हस्ताक्षर मैं जे -1 + को दोषी टी sideness।

I और j के अन्य ज्यामिति महत्व (इस समाधान से संबंधित नहीं) हैं:

• i , j एक नए निर्देशांक प्रणाली में T के लिए स्केलर्स हैं जहाँ v, u नए अक्ष और Q हैं नया मूल है;
• मैं , जे के रूप में देखा जा सकता है बल खींच के लिए पी, आर क्रमश। बड़ा i , दूर T R से दूर है ( P से बड़ा पुल )।

समीकरणों को हल करके i, j का मान प्राप्त किया जा सकता है:

i*vx + j*ux = T'x
i*vy + j*uy = T'y
i*vz + j*uz = T'z

तो हमें विमान पर 2 अंक, ए, बी दिए जाते हैं:

A = a1 * v + a2 * u B = b1 * v + b2 * u

यदि A, B एक ही तरफ हैं, तो यह सच होगा:

sign(a1+a2-1) = sign(b1+b2-1)

ध्यान दें कि यह प्रश्न पर भी लागू होता है: क्या ए, बी विमान के एक ही पक्ष में हैं [पी, क्यू, आर] , जिसमें:

टी = आई * पी + जे * क्यू + के * आर

और i + j + k = 1 का तात्पर्य है कि T समतल [P, Q, R] पर है और i + j + k-1 का चिह्न इसकी शिथिलता को दर्शाता है। इससे हमारे पास:

A = a1 * P + a2 * Q + a3 * R B = b1 * P + b2 * Q + b3 * R

और ए, बी विमान के एक ही तरफ हैं [पी, क्यू, आर] यदि

sign(a1+a2+a3-1) = sign(b1+b2+b3-1)