1) In java si puo' utilizzare il comando drawImage() dell'oggetto Graphics2D
presente in un metodo pain() per disegnare un'immagine sullo schermo.
Il suo utilizzo piu' semplice e' nella forma:

	g2.drawImage(img, x, y, null);
	
dove img e' un oggetto di tipo BufferedImage. L'ultimo parametro (impostato
a null) serivrebbe per prevedere la possibilita' di eseguire delle visualizzazioni
parziali durantee il caricamento  di immagini scaricate da internet.


2) La forma

	g2.drawImage(img, x, y, w, h, null);
	
esegue un ridimensionamento dell'immagine in modo da farla diventare di dimensioni
w, h. Non e' possibile controllare il modo in cui l'immagine viene scalata.
  
  
3) La forma piu' complicata

	g2.drawImage(img, x1d, y1d, x2d, y2d, x1s, y1s, x2s, y2s, null);
	
permette invece di "ritagliare" il rettangolo i cui estremi sono
alle coordinate x1s, y1s, x2s, y2s dell'immagine sorgente, e di copiarlo
nel rettangolo i cui vertici sono alle coordinate x1d, y1d, x2d, y2d della
finestra corrente.

4) Per poter ruotare, scalare e controllare l'algoritmo usato per
ricampionare l'immagine bisogna utilizzare la versione:

	g2.drawImage(img, op, 0, 0);
	
dove op e' un oggetto di tipo AffineTransformOp che rappresenta la
trasformazione applicata all'immagine. Gli ultimi due 0, 0 rappresentano
l'angolo a sinistra in alto in cui copiare l'immagine. Se si una una
trasformazione di tipo AffineTransformOp, queste coordinate sono inutili
(in quanto gia' presnti dentro op), per cui possono essere lasciate
uguali a zero.

5) L'oggetto AffineTransformOp contiene sia la trasformazione che il tipo
di interpolazione. Entrambe vanno passati al costruttore:

	op = new AffineTransformOp(at, interpType).
	
Il tipo di interpolazione (interpType) viene stabilito con le seguenti costanti:

	AffineTransformOp.TYPE_NEAREST_NEIGHBOR 	// Pixel piu' vicino
	AffineTransformOp.TYPE_BILINEAR 			// ricampionamento bilineare
	AffineTransformOp.TYPE_BICUBIC 	        	// ricampionamento bicubico  

6) La trasformazione viene invece definita attraverso la costruzione di un
oggetto di tipo affineTransform. Il modo piu' semplice di creare la trasformazione
giusta e' quello di partire da una trasformazione vuota, e poi concatenarle di
seguito tutte le operazioni da fare. 

Se si vuole ruotare l'immagine di un angolo alpha, rispetto ad un centro di coordinate xc,yc,
scalandola di un fattore sx,xy e posizionando il nuovo centro alle coordinate xt, yt,
allora si dovra' eseguire:

	AffineTransform at = new AffineTransform();
	at.concatenate(AffineTransform.getTranslateInstance(xt, yt));			// posiziona l'immagine nel punto finale
	at.concatenate(AffineTransform.getScaleInstance(sx, sy));				// esegue la scala
	at.concatenate(AffineTransform.getRotateInstance(alpha));				// esegue la rotazione
	at.concatenate(AffineTransform.getTranslateInstance(-xc,-yc));			// porta il centro nell'origine

In questo caso i comandi:
	AffinteTransform.getTranslateInstance(dx,dy)   crea una translaizone di dx,dy
	AffinteTransform.getScaleInstance(sx, sy)      crea una variaizione di scala di entita' sx, sy
	AffinteTransform.getRotateInstance(a)          crea una rotazione di a rispetto all'origine degli assi

Notare come le trasformazioni vadano effettuate in ordine inverso!
	
Per disegnare l'immagine trasformata con campionamento bilineare ad esempio, occorrera' eseguire
le seguenti istruzioni:


	AffineTransform at = new AffineTransform();
	at.concatenate(AffineTransform.getTranslateInstance(xt, yt));			// posiziona l'immagine nel punto finale
	at.concatenate(AffineTransform.getScaleInstance(sx, sy));				// esegue la scala
	at.concatenate(AffineTransform.getRotateInstance(alpha));				// esegue la rotazione
	at.concatenate(AffineTransform.getTranslateInstance(-xc,-yc));			// porta il centro nell'origine
	AffineTransformOp op = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);	// crea l'operatore di trasformazione
	g2.drawImage(img, op, 0, 0);			// disegna l'immagine