Bir noktanın bir dikdörtgenin içinde olup olmadığını bulmak istiyorum. Dikdörtgen herhangi bir şekilde yönlendirilebilir ve eksene göre hizalanması gerekmez.

Düşünebildiğim bir yöntem, dikdörtgen eksenini hizalamak için dikdörtgeni ve nokta koordinatlarını döndürmek ve ardından dikdörtgenin koordinatlarının içinde olup olmadıklarına bakılmaksızın basitçe noktanın koordinatlarını test etmekti.

Yukarıdaki yöntem rotasyon ve dolayısıyla kayan nokta işlemleri gerektirir. Bunu yapmanın başka etkili bir yolu var mı?

Dikdörtgen nasıl temsil edilir? Üç nokta? Dört puan mı? Nokta, kenarlar ve açı? İki nokta ve bir taraf? Başka bir şey? Bunu bilmeden, sorunuza cevap vermeye yönelik herhangi bir girişimin yalnızca tamamen akademik değeri olacaktır.

Her durumda, herhangi bir dışbükey çokgen için (dikdörtgen dahil) test çok basittir: her bir kenarın saat yönünün tersine yönlendirildiğini varsayarak çokgenin her bir kenarını kontrol edin ve noktanın kenarın solunda ( solda) olup olmadığını test edin. -el yarım düzlem). Tüm kenarlar testi geçerse - nokta içeride. En az biri başarısız olursa - nokta dışarıdadır.

Noktanın olup olmadığını test etmek için (xp, yp) kenarın sol tarafında(x1, y1) - (x2, y2) , hesaplamanız yeterlidir.

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

Eğer D > 0, nokta sol taraftadır. Eğer D < 0, nokta sağ taraftadır. Eğer D = 0, nokta çizgide.

Bu cevabın önceki versiyonu, sol taraf testinin görünüşte farklı bir versiyonunu açıkladı (aşağıya bakın). Ancak aynı değeri hesapladığı kolaylıkla gösterilebilir.

... Noktanın (xp, yp)kenarın sol tarafında olup olmadığını test etmek için , kenarı (x1, y1) - (x2, y2)içeren çizgi için çizgi denklemi oluşturmanız gerekir. Denklem aşağıdaki gibidir

A * x + B * y + C = 0

nerede

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

Şimdi yapmanız gereken tek şey hesaplamak

D = A * xp + B * yp + C

Eğer D > 0, nokta sol taraftadır. Eğer D < 0, nokta sağ taraftadır. Eğer D = 0, nokta çizgide.

Bununla birlikte, bu test yine herhangi bir dışbükey çokgen için işe yarar, yani bir dikdörtgen için fazla genel olabilir. Bir dikdörtgen, daha basit bir teste izin verebilir ... Örneğin, bir dikdörtgende (veya başka herhangi bir paralelkenarda) değerleri Ave Baynı büyüklükte, ancak karşılıklı (yani paralel) kenarlar için farklı işaretler var, bu da testi basitleştirmek için kullanılabilir. .

Dikdörtgenin AB ve BC dik olacak şekilde A, B, C üç noktasıyla temsil edildiğini varsayarsak, yalnızca M sorgu noktasının AB ve BC üzerindeki izdüşümlerini kontrol etmeniz gerekir:

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

ABkoordinatları (By-Ay Bx-Ax) ile, AB vektörüdür ve dot(U,V)vektörler U ve V'nin nokta ürün: Ux*Vx+Uy*Vy.

Güncelle . Bunu açıklamak için bir örnek alalım: A (5,0) B (0,2) C (1,5) ve D (6,3). Nokta koordinatlarından AB = (- 5,2), BC = (1,3), nokta (AB, AB) = 29, nokta (BC, BC) = 10 elde ederiz.

M (4,2) sorgu noktası için, AM = (- 1,2), BM = (4,0), nokta (AB, AM) = 9, nokta (BC, BM) = 4 var. M dikdörtgenin içindedir.

P (6,1) sorgu noktası için AP = (1,1), BP = (6, -1), nokta (AB, AP) = - 3, nokta (BC, BP) = 3 var. P dikdörtgenin içinde değildir, çünkü AB tarafındaki izdüşümü AB segmentinin içinde değildir.

Eric Bainville'in cevabından ödünç aldım:

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

Javascript'te aşağıdaki gibi görünür:

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

Örneğin:

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

sonra:

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

İşte çıktıyı görsel bir test olarak çizmek için bir kod parçası :) 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

Bunun eski bir konu olduğunun farkındayım, ancak buna tamamen matematiksel bir perspektiften bakmakla ilgilenen herkes için matematik yığını değişiminde mükemmel bir konu var:

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

Düzenleme: Bu iş parçacığından ilham alarak, noktanızın nerede olduğunu hızlıca belirlemek için basit bir vektör yöntemi oluşturdum.

P1 = (x1, y1), p2 = (x2, y2), p3 = (x3, y3) ve p4 = (x4, y4) noktalarında saat yönünde giden bir dikdörtgene sahip olduğunuzu varsayalım. Dikdörtgenin içinde bir p = (x, y) noktası bulunuyorsa, o zaman iç çarpım (p - p1). (P2 - p1) 0 ile | p2 - p1 | ^ 2 ve (p - p1) arasında olacaktır. (p4 - p1) 0 ile | p4 - p1 | ^ 2 arasında olacaktır. Bu, orijini p1 olmak üzere dikdörtgenin uzunluğu ve genişliği boyunca p - p1 vektörünün izdüşümünü almaya eşdeğerdir.

Eşdeğer bir kod gösterirsem bu daha mantıklı olabilir:

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"

Ve bu kadar. Paralelkenarlar için de çalışacaktır.

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

Sadece AnT's Answer'ı c ++ kullanarak uyguladım. Bu kodu, piksel koordinasyonunun (X, Y) şeklin içinde olup olmadığını kontrol etmek için kullandım.

Dikdörtgenin sorununu çözemezseniz, sorunu daha kolay sorunlara bölmeyi deneyin. Dikdörtgeni 2 üçgene bölün ve noktanın burada açıkladıkları gibi herhangi birinin içinde olup olmadığını kontrol edin.

Esasen, bir noktadan her iki çift çizginin kenarlarından geçersiniz. Ardından, çapraz çarpımı kullanarak noktanın iki çizgi arasında olup olmadığını kontrol etmek için çapraz çarpım kullanın. Tüm 3 nokta için doğrulanmışsa, nokta üçgenin içindedir. Bu yöntemin iyi yanı, açıları kontrol ettiğinizde meydana gelen herhangi bir kayan nokta hatası oluşturmamasıdır.

Bir nokta bir dikdörtgenin içindeyse. Uçakta. Matematikçi veya jeodezi (GPS) koordinatları için

• Dikdörtgenin A, B, C, D köşeleri ile ayarlanmasına izin verin. Nokta P'dir. Koordinatlar dikdörtgendir: x, y.
• Dikdörtgenin kenarlarını uzatalım. Yani 4 düz çizgimiz var l _AB , l _BC , l _CD , l _DA , veya kısaca l ₁ , l ₂ , l ₃ , l ₄ .

• Her l _i için bir denklem yapın . Denklem türü:

  f _ben (P) = 0.

P bir noktadır. L _i'ye ait noktalar için denklem doğrudur.

• Denklemlerin sol tarafındaki fonksiyonlara ihtiyacımız var. Bunlar f ₁ , f ₂ , f ₃ , f _4'tür .
• L _i'nin bir tarafından her nokta için f _i fonksiyonunun 0'dan büyük olduğuna, diğer taraftaki noktalar için f _i'nin 0'dan küçük olduğuna dikkat edin.
• Öyleyse, P'nin dikdörtgende olup olmadığını kontrol ediyorsak, sadece p'nin dört çizginin tamamının doğru taraflarında olmasına ihtiyacımız var. Öyleyse, işaretleri için dört işlevi kontrol etmeliyiz.
• Ama dikdörtgenin ait olduğu doğru çizginin hangi tarafı? Dikdörtgenin çizgiye ait olmayan köşelerinin bulunduğu taraftır. Kontrol etmek için, ait olmayan iki köşeden herhangi birini seçebiliriz.

• Yani, bunu kontrol etmeliyiz:

  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

Eşitsizlikler katı değildir, çünkü sınırda bir nokta varsa, o da dikdörtgene aittir. Sınırda noktalara ihtiyacınız yoksa, katı eşitsizlikler için eşitsizlikleri değiştirebilirsiniz. Ancak kayan nokta işlemlerinde çalışırken, seçim önemsizdir.

• Dikdörtgendeki bir nokta için, dört eşitsizliğin tümü doğrudur. Her dışbükey çokgen için de işe yaradığına dikkat edin, yalnızca çizgi / denklem sayısı farklı olacaktır.

• Geriye kalan tek şey, iki noktadan geçen bir doğru için bir denklem elde etmektir. İyi bilinen bir doğrusal denklemdir. AB doğrusu ve P noktası için yazalım:

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

Kontrol basitleştirilebilir - dikdörtgeni saat yönünde ilerleyelim - A, B, C, D, A. O zaman tüm doğru taraflar çizgilerin sağında olacaktır. Yani, başka bir tepe noktasının olduğu tarafla karşılaştırmamıza gerek yok. Ve bir dizi daha kısa eşitsizliği kontrol etmemiz gerekiyor:

f _AB (P)> = 0

f _BC (P)> = 0

f _CD (P)> = 0

f _DA (P)> = 0

Ancak bu, X'in sağda ve Y'nin üstte olduğu normal matematikçi (okul matematiğinden) koordinat seti için doğrudur. Ve GPS'de kullanıldığı gibi, X'in üstte ve Y'nin sağda olduğu jeodezi koordinatları için, eşitsizlikleri çevirmeliyiz:

f _AB (P) <= 0

f _BC (P) <= 0

f _CD (P) <= 0

f _DA (P) <= 0

Eksenlerin yönlerinden emin değilseniz, bu basitleştirilmiş kontrole dikkat edin - doğru eşitsizlikleri seçtiyseniz, bilinen yerleşimle bir noktayı kontrol edin.

Düşündüğüm en kolay yol, noktayı dikdörtgenin eksenine yansıtmaktı. Açıklamama izin ver:

Vektörü dikdörtgenin ortasından üst veya alt kenara ve sol veya sağ kenara kadar alabilirseniz. Ayrıca dikdörtgenin merkezinden sizin noktanıza kadar bir vektörünüz var, bu noktayı genişlik ve yükseklik vektörlerinize yansıtabilirsiniz.

P = nokta vektörü, H = yükseklik vektörü, W = genişlik vektörü

Vektörleri büyüklüklerine bölerek W ', H' Birim vektörünü elde edin

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

Yanılmadığım sürece, ki ki ben öyle düşünmüyorum ... (Yanılıyorsam düzeltin) ama noktanızın yükseklik vektörü üzerindeki izdüşümünün büyüklüğü, yükseklik vektörünün büyüklüğünden daha küçükse (yani Dikdörtgenin yüksekliğinin yarısı) ve noktanızın genişlik vektörü üzerindeki izdüşümünün büyüklüğü ise, dikdörtgenin içinde bir noktanız olur.

Evrensel bir koordinat sisteminiz varsa, vektör çıkarmayı kullanarak yükseklik / genişlik / nokta vektörlerini bulmanız gerekebilir. Vektör projeksiyonları harika! bunu hatırla.

Devamında paspaslar cevap verir. çalışmasını sağlamak için /math/190111/how-to-check-if-a-point-is-inside-a-rectangle/190373#190373 çözümünü kullanmamız gerekiyor

Aşağıda çalışmıyor
0 <= nokta (AB, AM) <= nokta (AB, AB) && 0 <= nokta (BC, BM) <= nokta (BC, BC)

Aşağıda işler
0 <= nokta (AB, AM) <= nokta (AB, AB) && 0 <= nokta (AM, AC) <= nokta (AC, AC)

Aşağıdakini javascript konsoluna yapıştırarak kontrol edin // Javascript çözümü aynı

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