Finden, ob ein Punkt innerhalb eines Rechtecks ​​liegt oder nicht

82

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?

avd
quelle
Sie können schnell überprüfen, ob der Punkt in den orthogonalen Begrenzungsrahmen des gedrehten Rechtecks ​​fällt, und wenn nicht, schnell fehlschlagen. (Ja, das ist nur eine halbe Antwort (hmmm, es gibt drei orthogonale Kästchen, die durch die Eckpunkte gebildet werden können ... und es ist spät (konzeptionelle Geometrie ist die erste, die geht))).
Msw
Aber ich muss mich zuerst drehen, oder?
Durchschnittlich
1
Bis Sie uns sagen, wie Ihr Rechteck definiert ist, werden die Antworten nicht viel praktischen Wert haben. Wenn Sie mit ganzzahligen Koordinaten arbeiten, ist die Methode zur Darstellung der Form bei der Auswahl des Algorithmus von entscheidender Bedeutung.
AnT

Antworten:

80

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 .

Ameise
quelle
Dies gilt nur für die eingestellten mathematischen Koordinaten. Auf dem PC-Bildschirm und für GPS sind die Achsenrichtungen unterschiedlich und Sie können nicht sicher sein, ob Sie die richtigen Ungleichungen haben. Oder Sie können sicher sein, dass Sie es nicht getan haben. Meine Antwort ist besser :-).
Gangnus
AndreyT @Gangnus, schnelle Präzision, Sie müssen nur überprüfen, ob das Vorzeichen der Gleichung für alle Punkte der konvexen Form in Bezug auf P gleich ist. Dadurch können Sie sich keine Gedanken über Koordinatensysteme oder die Richtung Ihrer konvexen Form machen definiert;))
Jason Rogers
2
Es gibt ein paar Erweiterungen, mit denen Sie die Dinge beschleunigen können. 1. Da die beiden gegenüberliegenden Seiten des Rechtecks ​​parallel sind, können ihre A-, B-Koeffizienten gleich sein. 2. Da die beiden anderen Seiten senkrecht zu diesen stehen, können ihre Koeffizienten A'und B'durch A'=Bund angegeben werden B'=-A. 3. Es macht keinen Sinn, A xp + B ypbeide Kanten zu berechnen. Kombinieren Sie sie daher zu einem einzigen Test. Dann wird Ihr Test für ein Rechteck (v_min < A xp + B yp < v_max) && ( w_min < B xp - A yp < w_max ).
Michael Anderson
@ MichaelAnderson Und was sind v_min, etc?
Anonym
v_minist der Mindestwert A x + B yfür alle Werte im Inneren des Rechtecks ​​(dies ist der Mindestwert, wenn er an den Ecken ausgewertet wird). v_maxist das entsprechende Maximum. Die w_?Werte sind die gleichen, aber für Bx - A y.
Michael Anderson
41

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.

Eric Bainville
quelle
1
0,2 - 10,2 - 10,10 - 2,10 ist kein Rechteck.
Eric Bainville
2
Bitte zeichnen Sie die Punkte auf und überprüfen Sie die Richtigkeit Ihres ersten Kommentars.
Eric Bainville
3
Das ist die beste Antwort!
Tahlil
1
Ich finde es gut, dass diese Antwort kurz ist, die Anzahl der Operationen mehr oder weniger so niedrig hält wie die anderen guten Antworten hier, aber auch den Vorteil hat, sehr intuitiv und sichtbar zu sein.
Anonym
22

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

Geben Sie hier die Bildbeschreibung ein

matte Verbrennungen
quelle
Hi @matt burns Ich habe Ihre Methode verwendet und sie in ein Testprojekt von mir eingefügt : jsfiddle.net/caymanbruce/06wjp2sk/6 Aber ich konnte sie nicht zum Laufen bringen. Keine Ahnung, warum der Punkt innerhalb des ursprünglichen Rechtecks ​​immer noch ohne Drehung getestet wird. Ich verwende ein mouseoverEreignis in meinem Projekt. Wenn sich die Maus über dem Punkt befindet, der sich innerhalb des Rechtecks ​​befinden soll, wird ein schwarzer Kreispunkt um die Maus angezeigt, und außerhalb des Rechtecks ​​sollte nichts angezeigt werden. Ich brauche Hilfe, damit es funktioniert, aber ich bin so verwirrt.
Newguy
mouseoversollte sein mousemove, nur Tippfehler.
Newguy
Referenz
Zmart
Im Prinzip ist Ihre Methode korrekt, aber Ihr Rechteck ist in Ihrem Beispiel kein Rechteck. Ich habe hier eine verbesserte Version von Ihnen erstellt , in der ich mich an die ursprüngliche Formel und das ursprüngliche Namensschema halte und in der die Eingabe tatsächlich ein echtes Rechteck ist.
JohannesB
15
# 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
Jonas Elfström
quelle
Lesen Sie dies wie folgt: "Wenn wir den Punkt mit drei Scheitelpunkten des Rechtecks ​​verbinden, sollten die Winkel zwischen diesen Segmenten und Seiten spitz sein"
P Shved
3
Das Problem bei solchen Ansätzen ist, dass sie theoretisch funktionieren, aber in der Praxis kann es zu Problemen kommen. Das OP hat nicht gesagt, wie das Rechteck dargestellt wird. Diese Antwort geht davon aus, dass sie durch drei Punkte dargestellt wird - a, bund d. Während drei Punkte theoretisch ein gültiger Weg sind, um ein beliebiges Rechteck darzustellen, ist es in der Praxis im allgemeinen Fall unmöglich, genau in Interger-Koordinaten zu arbeiten. Im Allgemeinen wird ein Parallelogramm erstellt, das dem Rechteck sehr nahe kommt, aber immer noch kein Rechteck ist.
AnT
3
Das heißt, die Winkel in dieser Form betragen nicht genau 90 Grad. Man muss sehr vorsichtig sein, wenn man in einer solchen Situation winkelbasierte Tests durchführt. Auch hier kommt es darauf an, wie das OP "innen" für ein ungenau dargestelltes "Rechteck" definiert. Und wieder, wie das Rechteck dargestellt wird.
AnT
+1 auf beide Kommentare. Nur @avd kann uns sagen, ob dies gut genug ist.
Jonas Elfström
Funktioniert perfekt für mich ... Mit Trigonometrie und Geometrie ist es schön, keine Formel zu finden, um ein häufiges Problem zu lösen. Vielen Dank.
sq2
12

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.

Matt Thompson
quelle
Können Sie die bisherige Diskussion dort zusammenfassen? Andernfalls sollte dies wahrscheinlich ein Kommentar und keine Antwort gewesen sein. Mit etwas mehr Wiederholungen können Sie Kommentare posten .
Nathan Tuggy
7
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;}

Punkte innerhalb des Polygons

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.

Alghyalin
quelle
Eine Erklärung für das, was Sie hier tun, wäre wirklich hilfreich.
Brad
Ich wollte mich nur bedanken. Ich habe konvertiert, was Sie für einen Unity Shader arbeiten mussten, und es für 3 statt 4 Punkte reduziert. Gut funktioniert! Prost.
Dustin Jensen
Es hat bei mir funktioniert, hier ist eine Implementierung in C #, die ich für Unity DOTS erstellt habe: gist.github.com/rgoupil/04b59be8ddb56c992f25e1489c61b310
JamesDev
6

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.

Cristian T.
quelle
Das ist richtig, aber schrecklich ineffektiver Algorithmus.
Gangnus
4

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 1 , l 2 , l 3 , l 4 .
  • 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 1 , f 2 , f 3 , f 4 .
  • 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.

Gangnus
quelle
"Wo X oben und Y rechts ist, müssen wir die Ungleichungen drehen:" Das hängt davon ab, wie Sie "im Uhrzeigersinn" bestimmen. Wenn Sie die Koordinaten als mathematische betrachten, wird der Uhrzeigersinn automatisch gegen den Uhrzeigersinn und Sie können immer noch den ersten Satz von Ungleichungen verwenden. Mit anderen Worten, Sie können ohne dieses Durcheinander gut auskommen, wenn Sie nur die Koordinaten in allen Aspekten als mathematisch betrachten. Das Umkehren oder Austauschen der Koordinaten hat keine Auswirkung auf dieses Prädikat.
Palo
@Palo Mathematics hat keine eigene Orientierung. Ja. Der Algorithmus hat jedoch mehrere Punkte, und es wäre viel besser, an jedem Punkt verständliche und vernünftige Ergebnisse (im wirklichen Leben) zu haben, um testen zu können. Ohne das bis zum Ende Ihres zweiten Satzes können Sie kaum überprüfen, ob Sie Ungleichungen mit Ihrer Raumvorstellung richtig lösen.
Gangnus
0

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.

Matthew
quelle
0

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