Figure geometriche

Un applet che disegna delle linee

Il sistema di coordinate permette di specificare delle posizioni nella finestra, e quindi permette di fare dei disegni. Per disegnare una linea fra due punti di coordinate (a,b) e (c,d), in Java si usa la funzione drawLine(a,b,c,d). Per poter chiamare questa funzione, occorre prependere l'argomento della funzione paint, ossia quello che sta fra parentesi dopo il Graphics, in questo caso g (ma si può usare un qualsiasi altro nome). Se usiamo lo schema visto sopra, per disegnare una linea si fa g.drawLine(a,b,c,d).

L'applet DueLinee.java disegna due linee.

/*
  Un semplice applet: due linee in diagonale.
*/

import java.awt.*;

public class DueLinee extends java.applet.Applet {
  public void paint(Graphics g) {
    g.drawLine(0, 0, 100, 100);
    g.drawLine(0, 100, 100, 0);
  }
}

La seconda istruzione è g.drawLine(0, 100, 100, 0), che disegna una nuova linea. I due estremi hanno coordinate (0, 100) e (100, 0).

Le due linee sono quindi in diagonale. L'esecuzione di questo applet produce una finestra che contiene il seguente disegno.

Disegna una griglia

La istruzione di stampa della linea in questo caso è sufficente. Si tratta infatti di disegnare una serie di linee verticali e una serie di linee orizzontali. Prendiamo per esempio le linee verticali. Supponiamo che la dimensione (larghezza e altezza) totale della griglia sia 200, e che i quadratini devono avere lato 10. Allora, le linee verticali sono fatte come nel disegno, in cui sono riportate anche le coordinate dei punti estremi di ogni linea.

Il programma completo Griglia.java viene realizzato usando un ciclo per disegnare le linee verticali, e un altro ciclo per disegnare le linee orizzontali.

/*
  Disegna una griglia.
*/

import java.awt.*;

public class Griglia extends java.applet.Applet {
  public void paint(Graphics g) {
    int x,y;

    /* disegna le linee verticali */
    for(x=0; x<=200; x=x+10) {
      g.drawLine(x, 0, x, 200);
    }

    /* disegna le linee orizzontali */
    for(y=0; y<=200; y=y+10) {
      g.drawLine(0, y, 200, y);
    }
  }
}

Rettangoli

/*
  Disegna un rettangolo usando quattro linee.
*/

import java.awt.*;

public class Rettangolo extends java.applet.Applet {
  public void paint(Graphics g) {
    g.drawLine(20, 50, 20, 200);
    g.drawLine(20, 200, 80, 200);
    g.drawLine(80, 200, 80, 50);
    g.drawLine(80, 50, 20, 50);
  }
}

/*
  Disegna un rettangolo usando quattro linee.
*/

import java.awt.*;

public class RettUno extends java.applet.Applet {
  public void paint(Graphics g) {
    g.drawRect(20, 50, 60, 150);
  }
}

L'esecuzione produce il seguente disegno:

Grafico elementi di un vettore

Dal momento che occorre un rettangolo per ogni elemento del vettore, è necessario un ciclo in cui una variabile i assume tutti i valori da 0 fino al numero di elementi del vettore meno 1. Ad ogni passo, è necessario disegnare un rettangolo. Occorre decidere come deve esseere fatto questo rettangolo. Sappiamo che la sua altezza deve essere proporzionale a vett[i]. Per quello che riguarda la specifica dell'altezza siamo quindi a posto. Per la larghezza, possiamo assumere che tutti i rettangoli siano larghi 10.

Ci mancano quindi solo la coordinate dell'angolo in alto a sinistra del rettangolo. Per quello che riguarda la coordinata y, è facile: da momento che tutti i rettangoli devono partire dallo stesso piano, possiamo mettere per esempio y=100 per tutti i rettangoli.

La coordinata x si determina sapendo che i rettangoli vanno messi l'uno dietro l'altro. Il rettangolo che corrisponde a vett[0], per esempio, può essere compreso fra le coordinate 0 e 10, mentre quello di vett[1] sta fra 10 e 20, ecc. Non è difficile capire che il rettangolo che corrisponde a vett[i] si trova tra le coordinate x di valore i*10 e (i+1)*10. La coordinata x dell'angolo in alto a sinistra è quindi data da i*10.

Il programma GraficoRect.java realizza il grafico usando esattamente questo tipo di coordinate.

/*
  Grafico dei valori di un vettore usando rettangoli.
*/

import java.awt.*;

public class GraficoRect extends java.applet.Applet {
  public void paint(Graphics g) {
    int vett[]={3, 4, -5, -6, 2, 4, 4, -2, 0, 2, -9, 2, 9, 4, 5};
    int i;

    for(i=0; i<=vett.length-1; i=i+1) {
      g.drawRect(10*i, 100, 10, vett[i]*10);
    }
  }
}

Naturalmente, non è esattamente quello che si voleva ottenere. Per prima cosa, i valori negativi non sono stati disegnati. Secondo, i valori positivi corrispondono a rettangoli che ``scendono'' anzichè salire. Il primo problema si risolve con una istruzione condizionale che controlla se il contenuto di un elemento del vettore è positivo oppure negativo. Per quello che riguard il secondo problema, occorre cambiare gli argomenti della istruzione di stampa del rettangolo. Non si entra qui nel dettaglio di come questa cosa vada fatta. Il programma completo è GraficoRectDue.java:

/*
  Grafico dei valori di un vettore usando rettangoli:
  versione corretta che ammette valori negativi.
*/

import java.awt.*;

public class GraficoRectDue extends java.applet.Applet {
  public void paint(Graphics g) {
    int vett[]={3, 4, -5, -6, 2, 4, 4, -2, 0, 2, -9, 2, 9, 4, 5};
    int i;

    for(i=0; i<=vett.length-1; i=i+1) {
      if( vett[i]<0 ) {
        g.drawRect(10*i, 100, 10, -vett[i]*10);
      }
      else {
        g.drawRect(10*i, 100-vett[i]*10, 10, vett[i]*10);
      }
    }
  }
}

Poligoni

Per disegnare un poligono in Java, si può chiaramente usare la funzione drawLine, ma esiste anche un meccanismo che rende le cose più facili. Il procedimento consiste in tre passi:

1. dichiarazione di una variabile di tipo poligono
2. assegnazione di valori a questa variabile
3. disegno del poligono

Definizione di poligoni con vettori

    int x={....};
    int y={....};
    Polygon pol=new Polygon(x, y, x.lenght);

Aggiunta di punti a un poligono

    Polygon nomepoligono=new Polygon();

    nomepoligono.addPoint(x,y);

Disegno del poligono

/*
  Disegna due poligoni.
*/

import java.awt.*;

public class Poligoni extends java.applet.Applet {
  public void paint(Graphics g) {
    /* metodo 1: definizione con due vettori */
    int x[]={10, 20, 30, 40};
    int y[]={5, 30, 5, 21};
    Polygon pol=new Polygon(x, y, x.length);


    /* metodo 2: si parte dal poligono vuoto e si aggiungono
       ogni volta dei punti */
    Polygon p=new Polygon();

    p.addPoint(100,100);
    p.addPoint(100,180);
    p.addPoint(180,140);
    p.addPoint(160,110);


    /* disegna i poligoni */
    g.drawPolygon(pol);
    g.drawPolygon(p);
  }
}

Poligoni regolari

Quello che si vuole fare è disegnare un poligono regolare con n lati.

L'esercizio si risolve tenendo presente che ogni poligono regolare si può sempre inscrivere in un cerchio. Il problema si sposta quindi dal disegno del poligono alla individuazione di n punti sulla circonferenza. Il medodo che usiamo è questo: l'angolo giro vale 2*Math.PI, e questo va diviso esattamente in n parti. Quindi, possiamo fare un ciclo, in cui una variabile i va da 0 a n. L'angolo che consideriamo ogni volta vale 2*Math.PI*i/n.

Una volta noto l'angolo corrispondente ai punti della circonferenza che ci servono, occorre calcolare le loro coordinate. Se per esempio assumiamo che il centro del cerchio sia posizionato in (xcentro,ycentro), e che il suo raggio sia memorizzato nella variabile raggio, allora le coordinate di un punto si ottengono usando le note formule trigonometriche:

      x=xcentro+raggio*Math.cos(2*Math.PI*i/n);
      y=ycentro+raggio*Math.sin(2*Math.PI*i/n);

/*
  Disegna un poligono regolare con n lati
*/

import java.awt.*;

public class Regolari extends java.applet.Applet {
  public void paint(Graphics g) {
    int n=8;
    Polygon reg=new Polygon();
    int i;
    double x,y;
    double xcentro=100, ycentro=100, raggio=100;

    for(i=0; i<=n-1; i=i+1) {
      x=xcentro+raggio*Math.cos(2*Math.PI*i/n);
      y=ycentro+raggio*Math.sin(2*Math.PI*i/n);

      reg.addPoint( Math.round((float) x), Math.round((float) y) );
    }

    g.drawPolygon(reg);
  }
}

Cerchi e ovali

La istruzione per gli ovali si chiama drawOval(x,y,w,h), e ha quattro argomenti, che rappresentano posizione e dimensione del rettangolo circoscritto all'ovale. Il modo più facile per capire come funziona il disegno di ovali è di pensare che x,y,w,h rappresentano un rettangolo, e che l'ovale che viene disegnato è quello circoscritto nel rettangolo.

Per esempio, dal punto di vista concettuale, possiamo pensare prima al rettangolo che verrebbe disegnato usando gli stessi quattro numeri:

L'ovale che viene realmente disegnato è quello inscritto in questo rettangolo (in altre parole, il rettangolo non viene disegnato):

Il programma Ovali.java disegna due ovali e un cerchio. In particolare, il secondo ovale viene disegnato con la istruzione g.drawOval(100,50,50,120), e per confronto si fa vedere cosa succede se si disegna un rettangolo usando gli stessi parametri, ossia si fa anche g.drawRect(100,50,50,120).

/*
  Disegna due ovali e un cerchio
*/

import java.awt.Graphics;

public class Ovali extends java.applet.Applet {
  public void paint(Graphics g) {
    /* disegna un ovale */
    g.drawOval(0,0,100,50);

    /* un altro ovale, e il rettangolo con le stesse dimensioni */
    g.drawOval(100,50,50,120);
    g.drawRect(100,50,50,120);

    /* un cerchio: e' un ovale con larghezza=altezza */
    g.drawOval(0,100,50,50);
  }
}

La coppia ovale-rettangolo fa capire in che modo viene disegnato l'ovale: quando si esegue la istruzione g.drawOval(x,y,w,h), è come se venisse localizzato il rettangolo prodotto da g.drawRect(x,y,w,h), ma quello che si disegna in effetti è l'ovale inscritto. Nel nostro caso, abbiamo poi disegnato anche il rettangolo.

L'ultima istruzione dell'applet disegna un cerchio: questo si ottiene semplicemente usando lo stesso numero come altezza e larghezza del rettangolo circoscritto: in questo modo il rettangolo diventa un quadrato, e quindi l'ovale all'interno è un cerchio.

Simbolo delle olimpiadi

Usando la istruzione drawOval la cosa risulta particolarmente facile: i tre cerchi in alto sono messi l'uno accanto all'altro, per cui sono circoscritti da tre quadrati messi l'uno a fianco dell'altro.

I due cerchi di sotto si trovano spostati sia a destra che in basso di esattamente il raggio dei cerchi. Il raggio è la metà dal lato del quadrato circoscritto. Questo permette di disegnare gli altri due cerchi.

Il programma completo è Olimpiadi.java, di cui si riporta qui sotto il codice:

/*
  Disegna il simbolo delle olimpiadi.
*/

import java.awt.*;

public class Olimpiadi extends java.applet.Applet {
  public void paint(Graphics g) {
    /* i tre cerchi di sopra */
    g.drawOval(0, 0, 20, 20);
    g.drawOval(20, 0, 20, 20);
    g.drawOval(40, 0, 20, 20);

    /* i tre cerchi di sotto */
    g.drawOval(10, 10, 20, 20);
    g.drawOval(30, 10, 20, 20);
  }
}

Archi

Un arco è semplicemente una parte di un cerchio o di una ellisse. Il modo più semplice di dire come deve essere fatto un arco è quello di specificare come è fatta l'ellisse completa, e poi di dare l'indicazione del punto in cui l'arco comincia e quello in cui finisce. In Java, l'ellisse si specifica esattamente in questo modo: i primi tre numeri x,y,w,h sono esattamente la specifica della ellisse ``completa'', di cui l'arco fa parte; il numero s è il numero di gradi del punto in cui l'arco inizia; n è invece la ``lunghezza'' dell'arco in gradi.

Consideriamo di nuovo il disegno dell'ovale:

Quello che dobbiamo fare è segnare l'angolo che corrisponde a s, e da qui partiamo con un angolo ampio n.

La parte di ovale che viene realmente disegnata è solo quella compresa nell'angolo ampio n.

Non è difficile rendersi conto che questi sei numeri che vanno messi nella istruzione drawArc sono in grado di caratterizzare completamente l'arco: infatti, una volta specificato come è fatta l'ellisse completa, e i punti in cui inizia e finisce l'arco, questo è completamente specificato.

Il programma Archi.java disegna alcuni archi nella finestra.

/*
  Disegna degli archi.
*/

import java.awt.*;

public class Archi extends java.applet.Applet {
  public void paint(Graphics g) {
    g.drawArc(0,0,100,100,45,360-90);

    g.drawArc(100,0,100,100,-45,90);
  }
}

Una figura composta

Come si può facilemente notare, questa figura è in effetti composta da due segmenti e da due archi di cerchio. I due segmenti non presentano nessuna difficoltà: il segmento orizzontale si trova tra le coordinate (200,100) e le coordinate (250,100), mentre il secondo si trova tra i due punti (300,150) e (300,200).

Per quello che riguarda gli archi, occorre per prima cosa individuare le coordinate dell'ovale di cui fanno parte. In questo caso, si tratta di archi di cerchio. Il cerchio piccolo è inscritto nel quadrato che ha l'angolo in alto in (200,100) e ha lato 100. Inoltre, l'arco parte da 0 gradi e si estende per 90 gradi. Quindi, l'istruzione necessaria per disegnare questo arco è:

    g.drawArc(200,100,100,100,0,90);

    g.drawArc(100,100,200,200,90,360-90);

/*
  Disegna una figura fatta di segmenti e archi
*/

import java.awt.*;

public class Composta extends java.applet.Applet {
  public void paint(Graphics g) {

	/* i due segmenti */
    g.drawLine(200,100,250,100);
    g.drawLine(300,150,300,200);

	/* l'arco piccolo */
    g.drawArc(200,100,100,100,0,90);

	/* l'arco grande */
    g.drawArc(100,100,200,200,90,360-90);
  }
}