Ich möchte herausfinden, ob ein Punkt innerhalb eines Rechtecks ​​liegt oder nicht. Das Rechteck kann in beliebiger Weise ausgerichtet werden und muss nicht achsenausgerichtet sein.

Eine Methode, die ich mir vorstellen konnte, bestand darin, die Rechteck- und Punktkoordinaten zu drehen, um die Rechteckachse auszurichten, und dann einfach die Punktkoordinaten zu testen, ob sie innerhalb der Rechteckkoordinaten liegen oder nicht.

Das obige Verfahren erfordert eine Drehung und damit Gleitkommaoperationen. Gibt es eine andere effiziente Möglichkeit, dies zu tun?

Wie wird das Rechteck dargestellt? Drei Punkte? Vier Punkte? Punkt, Seiten und Winkel? Zwei Punkte und eine Seite? Etwas anderes? Ohne das zu wissen, haben alle Versuche, Ihre Frage zu beantworten, nur rein akademischen Wert.

In jedem Fall ist der Test für jedes konvexe Polygon (einschließlich Rechteck) sehr einfach: Überprüfen Sie jede Kante des Polygons unter der Annahme, dass jede Kante gegen den Uhrzeigersinn ausgerichtet ist, und testen Sie, ob der Punkt links von der Kante liegt (links) -hand halbe Ebene). Wenn alle Kanten den Test bestehen, befindet sich der Punkt im Inneren. Wenn mindestens einer ausfällt, liegt der Punkt außerhalb.

Um zu testen, ob der Punkt (xp, yp)auf der linken Seite der Kante liegt (x1, y1) - (x2, y2), müssen Sie nur berechnen

D = (x2 - x1) * (yp - y1) - (xp - x1) * (y2 - y1)

Wenn ja D > 0, befindet sich der Punkt auf der linken Seite. Wenn ja D < 0, befindet sich der Punkt auf der rechten Seite. Wenn D = 0, liegt der Punkt auf der Linie.

Die vorherige Version dieser Antwort beschrieb eine scheinbar andere Version des Tests auf der linken Seite (siehe unten). Es kann jedoch leicht gezeigt werden, dass derselbe Wert berechnet wird.

... Um zu testen, ob der Punkt (xp, yp)auf der linken Seite der Kante liegt (x1, y1) - (x2, y2), müssen Sie die Liniengleichung für die Linie erstellen, die die Kante enthält. Die Gleichung lautet wie folgt

A * x + B * y + C = 0

wo

A = -(y2 - y1)
B = x2 - x1
C = -(A * x1 + B * y1)

Jetzt müssen Sie nur noch berechnen

D = A * xp + B * yp + C

Wenn ja D > 0, befindet sich der Punkt auf der linken Seite. Wenn ja D < 0, befindet sich der Punkt auf der rechten Seite. Wenn D = 0, liegt der Punkt auf der Linie.

Dieser Test funktioniert jedoch wieder für jedes konvexe Polygon, was bedeutet, dass er für ein Rechteck möglicherweise zu allgemein ist. Ein Rechteck kann einen einfacheren Test ermöglichen ... Zum Beispiel haben in einem Rechteck (oder einem anderen Parallelogramm) die Werte von Aund Bdieselbe Größe, aber unterschiedliche Vorzeichen für gegenüberliegende (dh parallele) Kanten, die zur Vereinfachung des Tests ausgenutzt werden können .

Angenommen, das Rechteck wird durch drei Punkte A, B, C mit AB und BC senkrecht dargestellt, müssen Sie nur die Projektionen des Abfragepunkts M auf AB und BC überprüfen:

0 <= dot(AB,AM) <= dot(AB,AB) &&
0 <= dot(BC,BM) <= dot(BC,BC)

ABist der Vektor AB mit Koordinaten (Bx-Ax, By-Ay) und dot(U,V)ist das Punktprodukt der Vektoren U und V : Ux*Vx+Uy*Vy.

Update . Nehmen wir ein Beispiel, um dies zu veranschaulichen: A (5,0) B (0,2) C (1,5) und D (6,3). Aus den Punktkoordinaten erhalten wir AB = (- 5,2), BC = (1,3), Punkt (AB, AB) = 29, Punkt (BC, BC) = 10.

Für den Abfragepunkt M (4,2) gilt AM = (- 1,2), BM = (4,0), Punkt (AB, AM) = 9, Punkt (BC, BM) = 4. M befindet sich innerhalb des Rechtecks.

Für den Abfragepunkt P (6,1) haben wir AP = (1,1), BP = (6, -1), Punkt (AB, AP) = –3, Punkt (BC, BP) = 3. P befindet sich nicht innerhalb des Rechtecks, da seine Projektion auf der Seite AB nicht innerhalb des Segments AB liegt.

Ich habe mir Eric Bainvilles Antwort geliehen:

0 <= dot(AB,AM) <= dot(AB,AB) && 0 <= dot(BC,BM) <= dot(BC,BC)

Was in Javascript so aussieht:

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

z.B:

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

dann:

pointInRectangle(m, r); // returns true.

Hier ist ein Codepen zum Zeichnen der Ausgabe als visueller Test :) http://codepen.io/mattburns/pen/jrrprN

# 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

Mir ist klar, dass dies ein alter Thread ist, aber für alle, die daran interessiert sind, dies aus einer rein mathematischen Perspektive zu betrachten, gibt es hier einen ausgezeichneten Thread zum Austausch von Mathematikstapeln:

/math/190111/how-to-check-if-a-point-is-inside-a-rectangle

Bearbeiten: Inspiriert von diesem Thread habe ich eine einfache Vektormethode zusammengestellt, mit der Sie schnell feststellen können, wo Ihr Punkt liegt.

Angenommen, Sie haben ein Rechteck mit Punkten bei p1 = (x1, y1), p2 = (x2, y2), p3 = (x3, y3) und p4 = (x4, y4) im Uhrzeigersinn. Wenn ein Punkt p = (x, y) innerhalb des Rechtecks ​​liegt, liegt das Punktprodukt (p - p1). (P2 - p1) zwischen 0 und | p2 - p1 | ^ 2 und (p - p1). (p4 - p1) liegt zwischen 0 und | p4 - p1 | ^ 2. Dies entspricht der Projektion des Vektors p - p1 entlang der Länge und Breite des Rechtecks ​​mit p1 als Ursprung.

Dies kann sinnvoller sein, wenn ich einen äquivalenten Code zeige:

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"

Und das ist es. Es funktioniert auch für Parallelogramme.

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

Ich habe gerade AnTs Antwort mit c ++ implementiert. Ich habe diesen Code verwendet, um zu überprüfen, ob die Koordination des Pixels (X, Y) innerhalb der Form liegt oder nicht.

Wenn Sie das Problem für das Rechteck nicht lösen können, teilen Sie es in einfachere Probleme auf. Teilen Sie das Rechteck in zwei Dreiecke und prüfen Sie, ob sich der Punkt in einem der Dreiecke befindet, wie hier erläutert

Im Wesentlichen durchlaufen Sie die Kanten aller zwei Linienpaare von einem Punkt aus. Verwenden Sie dann das Kreuzprodukt, um mithilfe des Kreuzprodukts zu überprüfen, ob der Punkt zwischen den beiden Linien liegt. Wenn es für alle 3 Punkte überprüft wurde, befindet sich der Punkt innerhalb des Dreiecks. Das Gute an dieser Methode ist, dass sie keine Gleitkommafehler erzeugt, die auftreten, wenn Sie nach Winkeln suchen.

Wenn sich ein Punkt innerhalb eines Rechtecks ​​befindet. In einem Flugzeug. Für Mathematiker- oder Geodäsiekoordinaten (GPS)

• Das Rechteck sei durch die Eckpunkte A, B, C, D gesetzt. Der Punkt ist P. Die Koordinaten sind rechteckig: x, y.
• Lasst uns die Seiten des Rechtecks ​​verlängern. Wir haben also 4 gerade Linien l _AB , l _BC , l _CD , l _DA oder, kurz gesagt, l ₁ , l ₂ , l ₃ , l ₄ .

• Machen Sie eine Gleichung für jedes l _i . Die Gleichung Art von:

  f _i (P) = 0.

P ist ein Punkt. Für Punkte, die zu l _{i gehören} , ist die Gleichung wahr.

• Wir brauchen die Funktionen auf der linken Seite der Gleichungen. Sie sind f ₁ , f ₂ , f ₃ , f ₄ .
• Beachten Sie, dass für jeden Punkt von einer Seite von l _i die Funktion f _i größer als 0 ist, für Punkte von der anderen Seite f _i kleiner als 0.
• Wenn wir also prüfen, ob P im Rechteck ist, muss sich das p nur auf den richtigen Seiten aller vier Linien befinden. Wir müssen also vier Funktionen auf ihre Vorzeichen überprüfen.
• Aber welche Seite der Linie ist die richtige, zu der das Rechteck gehört? Es ist die Seite, auf der die Eckpunkte des Rechtecks ​​liegen, die nicht zur Linie gehören. Zur Überprüfung können wir einen von zwei nicht dazugehörigen Eckpunkten auswählen.

• Also müssen wir das überprüfen:

  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

Die Ungleichungen sind nicht streng, denn wenn sich ein Punkt am Rand befindet, gehört er auch zum Rechteck. Wenn Sie keine Punkte an der Grenze benötigen, können Sie Ungleichungen gegen strenge ändern. Während Sie in Gleitkommaoperationen arbeiten, ist die Auswahl irrelevant.

• Für einen Punkt, dh im Rechteck, sind alle vier Ungleichungen wahr. Beachten Sie, dass es auch für jedes konvexe Polygon funktioniert, nur die Anzahl der Linien / Gleichungen unterscheidet sich.

• Das einzige, was noch übrig ist, ist eine Gleichung für eine Linie zu erhalten, die durch zwei Punkte verläuft. Es ist eine bekannte lineare Gleichung. Schreiben wir es für eine Linie AB und Punkt P:

  f _AB (P) ≡ (x _A x _B ) (y _P -Y _B ) - (y _A -y _B ) (x _P -X _B )

Die Prüfung könnte vereinfacht werden - gehen wir im Uhrzeigersinn entlang des Rechtecks - A, B, C, D, A. Dann befinden sich alle richtigen Seiten rechts von den Linien. Wir müssen uns also nicht mit der Seite vergleichen, auf der sich ein anderer Eckpunkt befindet. Und wir müssen eine Reihe kürzerer Ungleichungen überprüfen:

f _AB (P)> = 0

f _BC (P)> = 0

f _CD (P)> = 0

f _DA (P)> = 0

Dies gilt jedoch für den normalen Koordinatensatz eines Mathematikers (aus der Schulmathematik), wobei X rechts und Y oben steht. Und für die Geodäsiekoordinaten , wie sie in GPS verwendet werden, wobei X oben und Y rechts ist, müssen wir die Ungleichungen drehen:

f _AB (P) <= 0

f _BC (P) <= 0

f _CD (P) <= 0

f _DA (P) <= 0

Wenn Sie mit den Richtungen der Achsen nicht sicher sind, gehen Sie bei dieser vereinfachten Prüfung vorsichtig vor - prüfen Sie, ob ein Punkt mit der bekannten Platzierung vorhanden ist, wenn Sie die richtigen Ungleichungen ausgewählt haben.

Der einfachste Weg, den ich mir vorgestellt habe, war, den Punkt einfach auf die Achse des Rechtecks ​​zu projizieren. Lassen Sie mich erklären:

Wenn Sie den Vektor von der Mitte des Rechtecks ​​zur oberen oder unteren Kante und zur linken oder rechten Kante erhalten können. Und Sie haben auch einen Vektor von der Mitte des Rechtecks ​​zu Ihrem Punkt. Sie können diesen Punkt auf Ihre Breiten- und Höhenvektoren projizieren.

P = Punktvektor, H = Höhenvektor, W = Breitenvektor

Erhalten Sie den Einheitsvektor W ', H', indem Sie die Vektoren durch ihre Größe dividieren

proj_P, H = P - (P.H ') H' proj_P, W = P - (P.W ') W'

Es sei denn, ich irre mich, was ich nicht glaube ... (Korrigieren Sie mich, wenn ich falsch liege), aber wenn die Größe der Projektion Ihres Punktes auf den Höhenvektor geringer ist als die Größe des Höhenvektors (was ist) die Hälfte der Höhe des Rechtecks) und die Größe der Projektion Ihres Punktes auf den Breitenvektor ist, dann haben Sie einen Punkt innerhalb Ihres Rechtecks.

Wenn Sie ein universelles Koordinatensystem haben, müssen Sie möglicherweise die Vektoren für Höhe, Breite und Punkt mithilfe der Vektorsubtraktion ermitteln. Vektorprojektionen sind erstaunlich! erinnere dich daran.

In Fortsetzung Matts antworten. Wir müssen die /math/190111/how-to-check-if-a-point-is-inside-a-rectangle/190373#190373 Lösung verwenden, damit es funktioniert

Unten funktioniert nicht
0 <= Punkt (AB, AM) <= Punkt (AB, AB) && 0 <= Punkt (BC, BM) <= Punkt (BC, BC)

Unten funktioniert
0 <= Punkt (AB, AM) <= Punkt (AB, AB) && 0 <= Punkt (AM, AC) <= Punkt (AC, AC)

Sie überprüfen dies, indem Sie unten in die Javascript-Konsole // Javascript-Lösung für dieselbe einfügen

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