Come stabilire se un punto si trova sul lato destro o sinistro di una linea

Ho una serie di punti. Voglio separarli in 2 set distinti. Per fare questo, ho scelto due punti ( a e b ) e disegnare una linea immaginaria tra di loro. Ora voglio avere tutti i punti rimasti da questa linea in un set e quelli che sono proprio da questa linea nell'altro set.

Come posso sapere per ogni dato punto z se si trova nel set di sinistra o nel set di destra? Ho provato a calcolare l'angolo tra azb - gli angoli più piccoli di 180 sono sul lato destro, maggiori di 180 sul lato sinistro - ma a causa della definizione di ArcCos, gli angoli calcolati sono sempre più piccoli di 180 °. Esiste una formula per calcolare angoli maggiori di 180 ° (o qualsiasi altra formula per scegliere il lato destro o sinistro)?

Utilizzare il segno del determinante dei vettori (AB,AM), dove si M(X,Y)trova il punto di query:

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

È 0sulla linea, e +1da un lato, -1dall'altro lato.

Prova questo codice che utilizza un prodotto incrociato :

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;
}

Dove a = punto linea 1; b = punto linea 2; c = punto da verificare.

Se la formula è uguale a 0, i punti sono lineari.

Se la linea è orizzontale, questo ritorna vero se il punto è sopra la linea.

Guardi il segno del determinante di

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

Sarà positivo per i punti da un lato e negativo dall'altro (e zero per i punti sulla linea stessa).

Il vettore (y1 - y2, x2 - x1)è perpendicolare alla linea e punta sempre a destra (o punta sempre a sinistra, se l'orientamento del piano è diverso dal mio).

È quindi possibile calcolare il prodotto punto di quel vettore e (x3 - x1, y3 - y1)determinare se il punto si trova sullo stesso lato della linea del vettore perpendicolare (prodotto punto> 0) oppure no.

Utilizzando l' equazione della linea ab , ottenere la coordinata x sulla linea con la stessa coordinata y del punto da ordinare.

• Se il punto x> linea è x, il punto si trova a destra della linea.
• Se il punto è x <linea è x, il punto è a sinistra della linea.
• Se il punto è x == la linea è x, il punto è sulla linea.

Prima controlla se hai una linea verticale:

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

Quindi, calcola la pendenza: m = (y2-y1)/(x2-x1)

Quindi creare un'equazione della linea tramite il modulo pendenza punto: y - y1 = m*(x-x1) + y1. Per il bene della mia spiegazione, semplificare al modulo di pendenza-intercetta (non è necessario nel vostro algoritmo): y = mx+b.

Ora collega (x3, y3)per xe y. Ecco alcuni pseudocodici che dettagliano cosa dovrebbe accadere:

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

Ho implementato questo in Java e ho eseguito un test unitario (fonte sotto). Nessuna delle soluzioni precedenti funziona. Questo codice supera il test unitario. Se qualcuno trova un test unitario che non supera, per favore fatemelo sapere.

Codice: NOTA: nearlyEqual(double,double)restituisce vero se i due numeri sono molto vicini.

/*
 * @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;
}

Ecco il test unitario:

@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));
}

Supponendo che i punti siano (Ax, Ay) (Bx, By) e (Cx, Cy), è necessario calcolare:

(Bx - Ax) * (Cy - Ay) - (By - Ay) * (Cx - Ax)

Questo sarà uguale a zero se il punto C si trova sulla linea formata dai punti A e B e avrà un segno diverso a seconda del lato. Quale lato dipende dall'orientamento delle coordinate (x, y), ma puoi inserire i valori di test per A, B e C in questa formula per determinare se i valori negativi sono a sinistra o a destra.

Volevo fornire una soluzione ispirata alla fisica.

Immagina una forza applicata lungo la linea e stai misurando la coppia della forza attorno al punto. Se la coppia è positiva (in senso antiorario), allora il punto è alla "sinistra" della linea, ma se la coppia è negativa il punto è la "destra" della linea.

Quindi, se il vettore della forza è uguale all'intervallo dei due punti che definiscono la linea

fx = x_2 - x_1
fy = y_2 - y_1

si esegue il test per il lato di un punto in (px,py)base al segno del test seguente

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

fondamentalmente, penso che ci sia una soluzione che è molto più semplice e diretta, per ogni dato poligono, diciamo che consiste di quattro vertici (p1, p2, p3, p4), trova i due vertici estremi opposti nel poligono, in un altro parole, trova ad esempio il vertice più in alto a sinistra (diciamo p1) e il vertice opposto che si trova nella parte più in basso a destra (diciamo). Quindi, dato il tuo punto di prova C (x, y), ora devi fare un doppio controllo tra C e p1 e C e p4:

se cx> p1x AND cy> p1y ==> indica che C è inferiore e a destra di p1 successivo se cx <p2x AND cy <p2y ==> indica che C è superiore e a sinistra di p4

conclusione, C è all'interno del rettangolo.

Grazie :)

@ Risposta di AVB in rubino

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

Se detè positivo è sopra, se negativo è sotto. Se 0, è sulla linea.

Ecco una versione, sempre usando la logica del prodotto incrociato, scritta in Clojure.

(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)))))

Esempio di utilizzo:

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

Vale a dire che il punto (0, 10) è a sinistra della linea determinata da (-3, -1) e (3, 1).

NOTA: questa implementazione risolve un problema che nessuno degli altri (finora) fa! L'ordine è importante quando si danno i punti che determinano la linea. Vale a dire, è una "linea diretta", in un certo senso. Quindi, con il codice sopra, questa invocazione produce anche il risultato di true:

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

Questo a causa di questo frammento di codice:

(sort line)

Infine, come con le altre soluzioni basate su prodotti incrociati, questa soluzione restituisce un valore booleano e non fornisce un terzo risultato per la collinearità. Ma darà un risultato sensato, ad esempio:

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

Un modo alternativo di farsi un'idea delle soluzioni fornite dalle reti è quello di comprendere le implicazioni della geometria.

Sia pqr = [P, Q, R] sono punti che formano un piano che è diviso in 2 lati per linea [P, R] . Dobbiamo scoprire se due punti sul piano pqr , A, B, sono sullo stesso lato.

Qualsiasi punto T sul piano pqr può essere rappresentato con 2 vettori: v = PQ e u = RQ, come:

T '= TQ = i * v + j * u

Ora le implicazioni della geometria:

1. i + j = 1: T sulla riga pr
2. i + j <1: T su Sq
3. i + j> 1: T su Snq
4. i + j = 0: T = Q
5. i + j <0: T su Sq e oltre Q.

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

In generale,

• i + j è una misura di quanto T è lontano da Q o linea [P, R] e
• il segno di i + j-1 implica la disparità di T.

Gli altri significati geometrici di i e j (non correlati a questa soluzione) sono:

• i , j sono gli scalari di T in un nuovo sistema di coordinate in cui v, u sono i nuovi assi e Q è la nuova origine;
• i , j può essere visto come forza di tiro per P, R , rispettivamente. La grande i , T è più lontano da R (maggiore trazione da P ).

Il valore di i, j può essere ottenuto risolvendo le equazioni:

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

Quindi ci vengono dati 2 punti, A, B sull'aereo:

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

Se A, B sono dalla stessa parte, questo sarà vero:

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

Si noti che ciò vale anche per la domanda: sono A, B sullo stesso lato del piano [P, Q, R] , in cui:

T = i * P + j * Q + k * R

e i + j + k = 1 implica che T è sul piano [P, Q, R] e il segno di i + j + k-1 implica la sua laterale. Da questo abbiamo:

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

e A, B sono sullo stesso lato del piano [P, Q, R] se

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