Union e interseccion de rectangulos en java

[ninga]

Hola amigos de nuevo molestandolos espero que me puedan ayudar, bueno nos dejaron crear una clase rectangulo a patir de dos clases linea y punto, ya la e echo casi toda solo me falta la union interseccion y rotarlo si me ayudan se los agradecere.

Codigo linea:

Código Java:

/**
 * Linea.java
*/
public class Linea{
  private Punto p1;
  private Punto p2;
  
  public Linea(){
    this(new Punto(0,0),new Punto(1,1));
  }
  
  public Linea (Punto p1Ini, Punto p2Ini) {
    if(!p1Ini.equals(p2Ini)){
         p1 = p1Ini;
         p2 = p2Ini;
    }
    else{
      p1 = new Punto(3,5);
      p2 = new Punto(4,6);
    }
  }
  
  public Linea(Linea l) {
    p1 = l.p1;
    p2 = l.p2;
  }
  
  public Punto getP1(){
   return p1;
  }
 
  public Punto getP2(){
   return p2;
  }
 
  public String ecuacion(){
    if (p1.getY() == p2.getY())
      return "y = " + p1.getY();  //Recta paralela al eje x
 
    if (p1.getX() == p2.getX())
      return "x = " + p1.getX();  //Recta paralela al eje y
 
    double m = pendiente();
    double b = ordenada();
    return (b > 0) ? "y = " + m + "x + " + b
                   : "y = " + m + "x " + b;
  }
 
  public double pendiente() {
    double divisor = p2.getX() - p1.getX();
 
    return (divisor != 0) ? 
                  (p2.getY() - p1.getY())/divisor
                  : Double.POSITIVE_INFINITY;            //Recta paralela al eje Y
  }
  
 
  public double ordenada() {
    return p1.getX() == p2.getX()? 
                         Double.POSITIVE_INFINITY
                         : p1.getY() - pendiente()*p1.getX();
  }
  
 
  public boolean contiene(Punto p) {
    return p.estanAlineados(p1,p2);
  }
 
  public boolean equals(Linea l1) {
    return pendiente() == l1.pendiente() && ordenada() == l1.ordenada();
  }
 
  public boolean esParalela(Linea l1) {
    return pendiente () == l1.pendiente();
  }
  
  public boolean esPerpendicular(Linea l1) {
    double m = pendiente();
    double m1 = l1.pendiente();
    final double INFINITO = Double.POSITIVE_INFINITY;
 
    if (m == 0 || m1 == 0 || m == INFINITO || m1 == INFINITO){
      return ((m == 0 && m1 == INFINITO) || (m1 == 0 && m == INFINITO))
        ? true : false;
    }
 
    return m == -1/m1;
  }
  
  public Punto interseccion(Linea l1) {
      int nuevaX, nuevaY;
      if (esParalela(l1)){
        nuevaX = nuevaY = (int)Double.POSITIVE_INFINITY;
      }
      else {
        nuevaX = (int)(ordenada()- l1.ordenada())/(int)(l1.pendiente() - pendiente());
        nuevaY = (int)(pendiente()*nuevaX + ordenada());
      }
      return new Punto(nuevaX, nuevaY);
  }  
}
 

Codiglo punto:

Código Java:

/**
 * Punto.java
 */
public class Punto {
   private int x;      // Coordenada x
   private int y;      // Coordenada y
 
  public Punto() {
    this(0,0);
  }
  
  public Punto(int x, int y) {
    this.x = x; //setX(x);
    this.y = y; //setY(y);
  }
  
  public Punto(Punto p) {
    x = p.x; //p.getX();
    y = p.y; //p.getY();
  }
  
  /**
   * Asigna valor a la coordenada x del punto.
   * @param int nuevo valor para la coordenada x
   */
  public void setX(int nuevaX) {
    x = nuevaX;
  }
  
  /**
   * Asigna valor a la coordenada y del punto.
   * @param int nuevo valor para la coordenada y.
   */
  public void setY(int nuevaY) {
    y = nuevaY;
  }
  
  public int getX() {
    return x;
  }
  
  public int getY() {
    return y;
  }
  
  public void desplazar(int deltaX, int deltaY) {
    x += deltaX; // x = x + deltaX;
    y += deltaY;
  }
  
  public double distancia(Punto p) {
    //Math.pow(x-p.x,2) + Math.pow(y-p.y,2)
    return Math.sqrt((double)((x-p.x)*(x-p.x) +
                              (y-p.y)*(y-p.y)));
  }
  
  public boolean estanAlineados(Punto p1, Punto p2) {
    return (y - p1.y)*(p2.x - p1.x) == (p2.y - p1.y)*(x -p1.x);
  }
  
  public boolean equals(Punto p) {
    return x == p.x && y == p.y;
  }
  
  public String toString() {
    return "(" + x + "," + y + ")";
  }
}
 

Codigo Rectangulo:

Código Java:

import javax.swing.JOptionPane;
 
public class Rectangulo {
 
    private Linea L1;
    private Linea L2;
    private Linea L3;
    private Linea L4;
 
    /**
     * Constructor del rectangulo inicial formado por los puntos
     */
    public Rectangulo() {
        Punto p1;
        Punto p2;
        Punto p3;
        Punto p4;
        p1 = new Punto(20, 20);
        p2 = new Punto(200, 20);
        p3 = new Punto(20, 150);
        p4 = new Punto(200, 150);
        L1 = new Linea(p1, p2);
        L2 = new Linea(p3, p4);
        L3 = new Linea(p1, p3);
        L4 = new Linea(p2, p4);
    }
 
    /**
     * Constructor de un rectangulo que recibe como parametros cuatro lineas.
     * @param a Recibe una linea de la clase Linea.java.
     * @param b Recibe una linea de la clase Linea.java.
     * @param c Recibe una linea de la clase Linea.java.
     * @param d Recibe una linea de la clase Linea.java.
     */
    public Rectangulo(Linea a, Linea b, Linea c, Linea d) {
        L1 = a;
        L2 = b;
        L3 = c;
        L4 = d;
    }
 
    /**
     * Costructor de un rectangulo a patir de otro(costructor copia).
     * @param r Recibe un objeto de la clase Rectangulo.java.
     */
    public Rectangulo(Rectangulo r) {
        L1 = r.L1;
        L2 = r.L2;
        L3 = r.L3;
        L4 = r.L4;
    }
    /**
     * Metodo que determina el lado A del rectangulo
     * @return double El primer lado del rectangulo
     */
    public double ladoA() {
        return L1.getP1().distancia(L1.getP2());
 
    }
 
    /**
     * Metodo que determina el lado B del rectangulo
     * @return double El segundo lado del rectangulo
     */
    public double ladoB() {
        return L2.getP1().distancia(L2.getP2());
    }
 
    /**
     * Metodo que determina el lado C del rectangulo
     * @return double El tercer lado del rectangulo
     */
    public double ladoC() {
        return L3.getP1().distancia(L3.getP2());
    }
 
    /**
     * Metodo que determina el lado D del rectangulo
     * @return double El cuarto lado del rectangulo
     */
    public double ladoD() {
        return L4.getP1().distancia(L4.getP2());
    }
 
    /**
     * Metodo que calcula el perimetro de un rectangulo.
     * @return double Devuelve el perimetro del rectángulo es igual a la suma de
     * las longitudes de sus cuatro lados(p = 2[b*h]).
     */
    public double perimetro() {
        double p;
        p = 2 * (ladoB() + ladoD());
        return p;
    }
 
    /**
     * Metodo que determina el area de un rectangulo.
     * @return dobule Devuelve la area de un rectangulo que es igual a la base
     * por la altura(a = b*h).
     */
    public double area() {
        double a;
        a = (ladoB() * ladoD());
        return a;
 
    }
 
    /**
     * Metodo para determinar si se trata de un rectangulo o un cuadrado
     */
    public void TipoFigura() {
        double d1, d2, d3, d4;
        d1 = ladoA();
        d2 = ladoB();
        d3 = ladoC();
        d4 = ladoD();
        if (d1 == d2 & d2 == d3 & d3 == d4) {
            JOptionPane.showMessageDialog(null, "La figura creda es un \"Cuadrado\"");
        } else if (d1 == d2 & d2 != d3 & d3 == d4) {
            JOptionPane.showMessageDialog(null, "La figura creda es un \"Rectangulo\"");
        } else {
            JOptionPane.showMessageDialog(null, "La figura creda no es nada ni Rectangulo o Cuadrado");
        }
    }
 
    /**
     * Metodo que determina si dos rectangulos son iguales.
     * @param Rectangulo Objeto de la clase rectangulo con el cual se comparara.
     * @return boolean Devuelve true sin son iguales, false en otro caso.
     */
    public boolean equals(Rectangulo r) {
        boolean a;
        if (L1.equals(r.L1) == L2.equals(r.L2) == L3.equals(r.L3)) {
            a = true;
        } else if (ladoA() == r.ladoA() && ladoB() == r.ladoB() && ladoC() == r.ladoC() && ladoD() == r.ladoD()) {
            a = true;
        } else {
            a = false;
        }
        return a;
    }
    
    /**
     * Metodo que desplasa el rectangulo horizontalmente(eje X).
     * @param d Recibe un entero la cantidad de unidades para desplazar.
     */
    public void desplasarX(int d){
        int f = 0;
        L1.getP1().desplazar(d, f); L1.getP2().desplazar(d, f);
        L2.getP1().desplazar(d, f); L2.getP2().desplazar(d, f);
        L3.getP1().desplazar(d, f); L3.getP2().desplazar(d, f);
        L4.getP1().desplazar(d, f); L4.getP2().desplazar(d, f);
    }
    
    /**
     * Metodo que desplasa el rectangulo verticalmente(eje Y).
     * @param d Recibe un entero la cantidad de unidades para desplazar.
     */
    public void desplasarY(int d){
        int f = 0;
        L1.getP1().desplazar(f, d); L1.getP2().desplazar(f, d);
        L2.getP1().desplazar(f, d); L2.getP2().desplazar(f, d);
        L3.getP1().desplazar(f, d); L3.getP2().desplazar(f, d);
        L4.getP1().desplazar(f, d); L4.getP2().desplazar(f, d);
    }
    
    /**
     * Metodo que calcula la union de dos rectangulos es decir, el rectangulo
     * menor que incluya a ambos
     */
    public Rectangulo union(Rectangulo r){
        return null;
    
    }
    
    /**
     * Metodo para calcular la interseccion de dos rectangulos
     */
    public Rectangulo interseccion(Rectangulo r){
    
    }
 
}
 

[ninga]

Enserio? nadie quien me ayude?

[Xerelo]

Crear un rectángulo ya sabes, así que ¿qué es lo que no sabes hacer?

¿Unir rectángulos? Suma lados.
¿Intersección? Resta lados.
¿Rotar? Tienes que decidir cual es el origen de la rotación y calcular la nueva situación de los puntos en función del ángulo girado. ya sabes seno y coseno.

[ninga]

Iniciado por Xerelo

Crear un rectángulo ya sabes, así que ¿qué es lo que no sabes hacer?

¿Unir rectángulos? Suma lados.
¿Intersección? Resta lados.
¿Rotar? Tienes que decidir cual es el origen de la rotación y calcular la nueva situación de los puntos en función del ángulo girado. ya sabes seno y coseno.

Pues para la union e interseccion me deve de devolver un rectangulo, no solo es restarlos, el probelma es como hacerlo, solo usando las clases que di, punto y linea y eso es lo que no se como se hace

[Xerelo]

Pero si es lo mismo que ya tienes hecho.

Sumar/restar dos rectángulos es desplazar dos de sus puntos una distancia. Evidentemente la distancia es el lado del segundo rectángulo.

[ninga]

Iniciado por Xerelo

Pero si es lo mismo que ya tienes hecho.

Sumar/restar dos rectángulos es desplazar dos de sus puntos una distancia. Evidentemente la distancia es el lado del segundo rectángulo.

Pero no entiendo como hacer la interseccion, la union ya la entendi mas o menos, pero con el codigo no entiendo