Kesişen dikdörtgenleri kontrol etmenin daha hızlı yolu? Benim Dikdörtgen-sınıftan hariç

Question

:

public boolean intersect(Rect r) { 
    return (((r.x >= this.x) && (r.x < (this.x + this.w))) || ((this.x >= r.x) && (this.x < (r.x + r.w)))) && 
    (((r.y >= this.y) && (r.y < (this.y + this.h))) || ((this.y >= r.y) && (this.y < (r.y + r.h)))); 
} 

Testi durumda:

public class Rect { 
    public int x; 
    public int y; 
    public int w; 
    public int h; 

    public Rect(int x, int y, int w, int h) { 
    this.x = x; 
    this.y = y; 
    this.w = w; 
    this.h = h; 
    } 

    ... 
} 

I (hayır cinas tasarlamak) iki rects kesişen kontrol etmek için bir yöntem var

r1 = (x, y, w, h) = (0, 0, 15, 20) center: (x, y) = (7, 10) 
r2 = (x, y, w, h) = (10, 11, 42, 15) center: (x, y) = (31, 18) 
r1 Intersect r2: true 

sınıf iyi çalışıyor.

Merak ettiğim şey başka bir şey varsa - dikdörtgenlerin kesişip kesişmediğini kontrol etmenin belki daha hızlı bir yolu. Bir şekilde optimize edebilir miyim?

Answer 1

Dikdörtgenleri min x, min y, max x ve max y olarak kaydetme eğilimindeyim. Sonra örtüşme zaman

r1.maxX > r2.minX && 
r1.minX < r2.maxX && 
r1.maxY > r2.minY && 
r1.minY < r2.maxY 

oluşur Ve onlar çakışırsa, kavşak Bazı bakım onlar aynı sınır varsa onları örtüşen verdiğini düşündüğümüz olup olmadığına bağlı olarak alınmalıdır

r3.minX = max(r1.minX, r2.minX); 
r3.minY = max(r1.minY, r2.minY); 
r3.maxX = min(r1.maxX, r2.maxX); 
r3.maxY = min(r1.maxY, r2.maxY); 

ile tanımlanır . Çakışan sınırların bir çakışma olarak sayılmadığı anlamına gelen katı eşitsizlikler kullandım. Tamsayılar kullandığınız göz önüne alındığında (ve böylece sınırların 1 genişliğindedir), çakışan sınırları bir çakışma olarak düşünmek istediğinizi varsayalım. Ben şöyle bir şey yapardım:

public class Rect { 
    public int minX; 
    public int minY; 
    public int maxX; 
    public int maxY; 

    public Rect() {} 

    public Rect(int x, int y, int w, int h) { 
     this.minX = x; 
     this.minY = y; 
     this.maxX = x + w -1; 
     this.maxY = y + h -1; 
    } 

    public boolean Intersect(Rect r) { 
     return this.maxX >= r.minX && 
       this.minX <= r.maxX && 
       this.maxY >= r.minY && 
       this.minY <= r.maxY;    
    } 

    public Rect GetIntersection(Rect r) { 
     Rect i = new Rect(); 
     if (this.Intersect(r)) { 
      i.minX = Math.max(this.minX, r.minX); 
      i.minY = Math.max(this.minY, r.minY); 
      i.maxX = Math.min(this.maxX, r.maxX); 
      i.maxY = Math.min(this.maxY, r.maxY); 
     } 
     return i;  
    } 

    public int GetWidth() { 
     return this.maxX - this.minX + 1; 
    } 

    public int GetHeight() { 
     return this.maxY - this.minY + 1; 
    } 

    public void SetPosition(int x, int y) { 
     int w = this.GetWidth(); 
     int h= this.GetHeight(); 
     this.minX = x; 
     this.minY = y; 
     this.maxX = x + w -1; 
     this.maxY = y + h -1; 
    } 
}