/**
 * Un oggetto della classe <code>Rettangolo</code> rappresenta un rettangolo nel piano cartesiano
 * avente i lati paralleli agli assi cartesiani.
 *<BR>
 * Nella nostra rappresentazione, un rettangolo &egrave; identificato  dalla coppia di vertici (P1,P2) tali che: 
 *  <ul>
 *  <li> P1 &egrave; il vertice in basso a sinistra del rettangolo, 
 *  <li> P2 &egrave; il vertice in alto a destra del rettangolo.
 * </ul>  
 *
 * <pre>  
 *     --------------- P2
 *     |               |
 *     |               |
 *     P1---------------
 *
 *  </pre>
 * 
 * Ad esempio, il rettangolo avente  vertici opposti  (0,3) e (5,0), 
 * &egrave; rappresentato come ((0,0), (5,3)).
 * 
*
 * <pre>  
 *   (0,3)------------(5,3)
 *     |                |
 *     |                |
 *   (0,0)------------(5,0)
 *
 *
 *  </pre>
 */




public class  Rettangolo  {

  // CAMPI
 
    private Punto p1; // punto P1 (vertice in basso a sinistra)
    private Punto p2; // punto P2 (vertice in alto a destra)
    private int base;  // misura della base
    private int altezza;    // misura dell'altezza

     

 // COSTRUTTORI


 /**
   * Costruisce il rettangolo in cui <code>puntoA</code> e  <code>puntoB</code> 
   *  sono vertici opposti (non necessariamente i vertici P1 e P2).
 */



    public Rettangolo(Punto puntoA, Punto puntoB){
/*  Non occorre fare una distinzione in casi.
I punti P1 e P2 possono essere immediatamente determinati 
usando i metodi minXminY, ...   della classe Punto   */
    }


/**
   * Costruisce il rettangolo in cui <code>(xA,yA)</code> e  <code>(xB,yB) </code> sono vertici opposti.
   *  
   */
    


    public Rettangolo(int xA, int yA, int xB,  int yB){
	// utilizzare il costruttore definito sopra         
    }



 // METODI 



/**
   * Restituisce la stringa  che rappresenta il rettangolo che esegue il metodo.
   * @return la stringa che rappresenta il punto che esegue il metodo.
   */


// riscrive toString della classe Object

// deve restituire una stringa della forma  "((x1,y1),(x2,y2))" dove (x1,y1) = P1 e (x2,y2) = P2


  public String toString() {
      return "";
  }




 /**
   * Restituisce la misura della base del rettangolo.
   * @return    misura della base del rettangolo che esegue il metodo.
   */



public int getBase() {
    return -1;
  }


/**
   * Restituisce la misura dell'altezza del rettangolo.
   * @return  misura dell'altezza del rettangolo che esegue il metodo.
   */

public int getAltezza() {
    return -1;
}





/**
   * Restituisce il perimetro del rettangolo.
   * @return Perimetro del rettangolo che esegue il metodo
   */

public int getPerimetro() {
    return -1;
}

 

/**
   * Restituisce l'area del rettangolo.
   * @return  Area del rettangolo che esegue il metodo
   */

public int getArea() {
    return -1;
}




/**
   * Restituisce i vertici del rettangolo ordinati in senso  orario   a partire da P1.
   * @return    Restituisce un array  contenente i vertici del rettangolo che esegue il metodo,
   *  ordinati in senso  orario   a partire da P1.
   */



    public Punto[] getVertici(){
// occorre creare un array di 4 punti in cui vanno messi i punti richiesti
	return null;
    }





  /**
   * Controlla se il rettangolo contiene il punto passato come argomento.
   * 
   * @param p punto di cui si vuole controllare l'appartenenza al rettangolo.
   * @return <code>true</code> se il rettangolo che esegue il metodo contiene il punto,  
   *    <code>false</code> altrimenti.
   */
   


    public boolean contiene(Punto p){
    // usare i metodi della classe Punto
	return  false;
    }


 /**
   * Controlla se il rettangolo contiene il rettangolo  <code>r</code>
   * passato come argomento, ossia se tutti i punti di   <code>r</code>
   * sono contenuti nel rettangolo che esegue il metodo.
   * @param r un rettangolo.
   * @return <code>true</code> se il rettangolo che esegue il metodo contiene   <code>r</code>,  
   *   <code>false</code> altrimenti.
   */
   

  

    public boolean contiene(Rettangolo r){
  //  non occorre controllare che tutti i punti di r siano  contenuti nel rettangolo!
	return false;
    }




/**
   * Confronta il rettangolo che esegue il  metodo con il rettangolo specificato come argomento. 
   *  Restituisce  <code>true</code> se i rettangoli sono uguali, 
   *    <code>false</code>   altrimenti.
   * @param r il rettangolo da confrontare con quello che esegue il metodo.
   * @return <code>true</code> se il rettangolo che esegue il metodo &egrave; uguale a quello passato come argomento,     
   *         <code>false</code> altrimenti.
   */
  

    public boolean equals(Rettangolo r) {
      return false ;
  }

  

}// end class