Prüfen ob Punkt im Rechteck liegt

[JavaIsTheBest]

Hallo,
ich habe keine Ahnung, wie ich überprüfen kann ob ein Punkt im oder außerhalb des Rechtecks ist.
Wie mache ich das?

Spoiler: Rect

public class Rect {
    private double m1,m2,b,h,breiteHoehe;
   
    public Rect(double m1, double m2){
        this.m1=m1;
        this.m2=m2;
    }
    public Rect(double m1,double m2,double b, double h){
        this(m1,m2); // Warum nicht this.m1, this.m2
        this.b=b;
        this.h=h;
    }
    public Rect(double m1,double m2, double breiteHoehe){
        this(m1,m2);
        this.breiteHoehe=breiteHoehe;
    }
    public double area(){
        return this.b*this.h;
    }
    public double circumference(){
        return 2*b+2*h;
    }
    public void move(double x, double y){
        this.b+=x;
        this.h+=y;
    }
    public void scale (double faktor){
        this.b*=faktor;
        this.h*=faktor;
    }
    public boolean contains(Point p){ // Warum kein new Point...
       
        return false;
    }
   

}

 

[kneitzel]

Also wann liegt denn ein Punkt im Rechteck? Wenn die x-Koordinate des Punktes zwischen den x-Koordinaten des Rechtecks liegt und bezüglich der y-Koordinate ebenso.

Und wenn Du nur den Mittelpunkt + Höhe/Breite hast, dann ist es x-Koordinate von M +/- der Breite.

 

[Jardcore]

Das Koordinatensystem ist in Java so aufgebaut:

Folgender Code zeigt die Theorie kneitzels in Aktion.

if(
Punkt.x > Rechteck.mittelpunkt.x - Rechteck.breite / 2 &&
Punkt.x < Rechteck.mittelpunkt.x + Rechteck.breite / 2 &&
&&
Punkt.y > Rechteck.mittelpunkt.y - Rechteck.höhe / 2 &&
Punkt.y < Rechteck.mittelpunkt.y + Rechteck.höhe / 2) {
    // Punkt liegt innerhalb des Rechtecks
}

public boolean contains(Punkt p) {
    double breite = this.breite / 2;
    double hoehe = this.hoehe / 2;
    return
        p.x > this.mittelpunkt.x - breite &&
        p.x < this.mittelpunkt.x + breite &&
        &&
        p.y > this.mittelpunkt.y - hoehe &&
        p.y < this.mittelpunkt.y + hoehe;
}

Edit: Nach kneitzels Anmerkung, verbessert, hatte den Mittelpunkt übersehen 🙂

P.S: Die Formatierung des Codes, ist absichtlich auseinander gezogen^^

 

[kneitzel]

@Jardcore Nicht ganz, da nicht die Ecke oben Links gegeben ist, sondern der Mittelpunkt. So habe ich zumindest die Zeichnung verstanden und das erklärt dann auch die Verwendung von m.

über den Punkt bin ich auch gestolpert, aber dadurch ergibt sich dann die Berechnung der Koordinaten über minus (linker punkt) und plus (rechter Punkt) von Breite/2

 

[JavaIsTheBest]

Ich verstehe immer noch nicht, wie ich die rote Strecke rausbekomme.

 

[kneitzel]

Das hatte ich doch geschrieben. Du hast die x-koordinate von M und du hast die Breite. Da M in der Mitte ist, ist es x - Breite/2

 

[Xyz1]

Schaue mal hier, ist auch mit Pseudocode:
https://de.wikipedia.org/wiki/Punkt-in-Polygon-Test_nach_Jordan

 

[JavaIsTheBest]

Das hatte ich doch geschrieben. Du hast die x-koordinate von M und du hast die Breite. Da M in der Mitte ist, ist es x - Breite/2

Stimmt 🙂
Warum bin ich nicht selbst drauf gekommen? Im Prinzip ganz einfache Mathematik 🙂

 

[JavaIsTheBest]

Wisst ihr, warum nicht das richtige Ergebnis rauskommt, wenn ich überprüfen will ob der Punkt im Rechteck liegt?

Spoiler: Klasse Rect

public class Rect {
    private double mx,my,b,h,breiteHoehe;
   
    public Rect(double m1, double m2){
        this.mx=m1;
        this.my=m2;
    }
    public Rect(double m1,double m2,double b, double h){
        this(m1,m2); // Warum nicht this.m1, this.m2
        this.b=b;
        this.h=h;
    }
    public Rect(double m1,double m2, double breiteHoehe){
        this(m1,m2);
        this.breiteHoehe=breiteHoehe;
    }
    public double area(){
        return this.b*this.h;
    }
    public double circumference(){
        return 2*b+2*h;
    }
    public void move(double x, double y){
        this.b+=x;
        this.h+=y;
    }
    public void scale (double faktor){
        this.b*=faktor;
        this.h*=faktor;
    }
    public boolean contains(Point p){
        if(p.getX()<b && p.getX()>mx-b/2 && p.getY()<h && p.getY()>h/2-my) return true;
        else return false;
    }
   
    public static void main(String[] args){
        Rect r1=new Rect(3,3);
        Point p1=new Point(2.5,3.5);
       
        System.out.print(r1.contains(p1));
    }
   

}

 

[Meniskusschaden]

Du vergleichst offenbar die Koordinaten des Punktes mit den Abmessungen des Rechtecks. Die Position des Rechtecks ist aber auch relevant.

 

[kneitzel]

Also bezüglich der Prüfung, ob ein Punkt im Rechteck liegt hattest Du schon einige Antworten und in #3 ist sogar Code dabei, der die Prüfung zeigt.

   public Rect(double m1,double m2,double b, double h){
       this(m1,m2);// Warum nicht this.m1, this.m2
       this.b=b;
       this.h=h;
   }

Um diese Frage zu beantworten musst Du verstehen, was welche Variable ist!
Die Klasse definiert die Variablen mx, my, b und h. Daher sind diese Instanzvariablen immer mit this.mx, this.my, this.b und this.h ansprechbar. Das "this." kann dabei normalerweise weggelassen werden.

In dem oben gezeigten Konstruktor haben wir nun aber das Problem, dass die Instanzvariablen b und h durch die Parameter b und h verdeckt werden. b und h sind da nun die Parameter. Aber die Instanzvariablen sind über this.b und this.h immer noch zugreifbar.

Und die Werte sind natürlich in den Parametern, daher werden die Parameter m1 und m2 beim Aufruf des anderen Konstruktors angegeben. Und es existieren keine this.m1 und this.m2 weil die Variablen in der Instanz mx und my heissen.

Und dann ist mir noch aufgefallen:

   public void move(double x, double y){
       this.b+=x;
       this.h+=y;
   }

Wenn Du das Rechteck verschieben willst, verändern sich Breite und Höhe? Das halte ich für falsch.