Immagini e applet

Java fornisce un supporto nativo per immagini GIF e JPEG grazie alle funzionalità dei package java.applet, java.awt e java.awt.Image. Ogni immagine è rappresentata da un'istanza della classe java.awt.Image e può essere caricata con i metodi getImage() di java.awt.Toolkit e java.applet.Applet.  Il caricamento può avvenire a partire dal nome del file o indicando un URL. Naturalmente, nel caso di applicazioni Java, è possibile utilizzare entrambi i metodi, mentre nel caso delle applet bisognerà adeguarsi ai vincoli a cui tali classi sono sottoposte. Per motivi di prestazioni, e grazie alla natura multithreaded di Java, getImage() termina immediatamente, anche se l'immagine non è stata caricata completamente. 

miaImg = getImage(URL);

miaImg = Toolkit.getDefaultToolkit().
 
 

getImage(fileOrURL);

g.drawImage(miaImage, 0, 0, this);

Generalmente in un'applet il MediaTracker viene creato e inizializzato nel metodo init():

public void init() {
  tracker = new MediaTracker(this);
  img = getImage(getDocumentBase(), "img.gif");
  tracker.addImage(img, 0);
}

public void run() {
 try {
  tracker.waitForAll();
 } catch (InterruptedException ie) {
 return;
}
repaint();
}

public void paint(Graphics g) {
 if ((tracker.statusAll(false) & MediaTracker.ERRORED) != 0) {
   g.setColor(Color.red);
   g.fillRect(0, 0, size().width,size().height);
   return;
 }
g.drawImage(img, 0, 0, this);
}

Nuovi formati grafici in Java

La gestione delle immagini grafiche nell'AWT è basata su un modello produttore-consumatore. Si definisce Image Producer un oggetto in grado di interpretare i dati di un'immagine in un formato specifico e di trasformarli in una rappresentazione interna univoca. Questa vede l'immagine come una matrice bidimensionale di NxM pixel alla quale corrisponde un array di NxM valori che rappresentano il colore dei singoli pixel. Il modo con cui viene codificato un valore di colore è definito dal Color Model e, generalmente, corrisponde con la codifica RGB, nella quale a ogni pixel vengono assegnati tre byte contenenti i valori delle componenti di rosso, verde e blu della tinta da rappresentare. I dati così trasformati possono essere forniti a un Image Consumer che può elaborarli o, semplicemente, visualizzarli. In questo modello il consumer deve essere in grado di elaborare i dati man mano che il producer glieli fornisce. Il ciclo di produzione è basato su chiamate, da parte dell'Image Producer, di metodi callback implementati nell'Image Consumer.

Ecco come tecnicamente l'AWT realizza tutto ciò. AWT formalizza il "comportamento" degli Image Producer e Image Consumer attraverso le interfacce java.awt.Image.ImageProducer e java.awt.Image.ImageConsumer. Gli oggetti che vogliono ricevere i dati di un'immagine devono implementare l'interfaccia ImageConsumer e ridefinire il comportamento dei metodi callback setColorModel(), setDimensions(), setHints(), setPixel() che servono per ricevere rispettivamente il modello di colori, le dimensioni, le modalità di produzione e i dati relativi ai pixel dell'immagine. Il metodo imageComplete() del consumer viene infine invocato dal producer per segnalare il completamento dell'operazione. Probabilmente ci si chiederà come il producer venga a conoscenza degli oggetti consumer che esso deve alimentare. La risposta è nell'implementazione dell'interfaccia ImageProducer. A tal fine, infatti, questa impone di ridefinire i metodi addConsumer(), isConsumer(), removeConsumer(). Il metodo startProduction(), invece, comanda all'ImageProducer di iniziare la generazione dei dati. L'interfaccia java.awt.Image.ImageProducer definisce un ultimo metodo, requestTopDownLeftRightResend(), che permette a un ImageConsumer di richiedere che il produttore fornisca nuovamente parte dei dati dell'immagine (seguendo l'ordine alto-basso, sinistra-destra). Se il produttore non supporta questa funzionalità può fornire un'implementazione vuota del metodo. Per estendere Java con un nuovo formato grafico è sufficiente predisporre una classe che implementi l'interfaccia ImageProducer e sfruttare il metodo:

public Image createImage(ImageProducer producer)

Il formato BMP

Il formato BMP è quello privilegiato dai sistemi operativi OS/2 e Windows. Nell'ambito dei due sistemi vi sono alcune differenze che, come si vedrà in seguito, sono facilmente aggirabili. Un file bitmap può contenere immagini a 1, 4, 8, 24 bit per pixel, in formato compresso o non compresso. Nel primo caso possono essere utilizzati più schemi di compressione, basati principalmente su algoritmi run-length encoding (RLE). Le classi descritte in questo articolo leggono solo file bitmap non compressi.
 

Fig 1: struttura di un file BMP

La figura 1  mostra la struttura di un file BMP. Si nota un header della dimensione di 14 byte (detto File Info Header), seguito da una seconda intestazione contenente le informazioni sull'immagine (detta Bitmap Info Header). La dimensione di questo secondo blocco di dati è specificata nel primo long (4 byte) della struttura e corrisponde a 64 byte nel caso dei bitmap di OS/2 e a 40 byte per il formato DIB (Device-Independent Bitmap) di Windows. Dal punto di vista del codice presentato nell'articolo questa è l'unica differenza significativa tra i due tipi di file. Alle strutture di descrizione seguono i blocchi di dati che rappresentano l'immagine. Nel caso di immagini con palette (per esempio a 4 e 8 bit per pixel) il primo blocco che segue gli header è la palette dei colori, vale a dire un array di valori RGB. I pixel dell'immagine faranno riferimento agli indici di questa tabella per indicare il loro colore. Se l'immagine è a 24-bit la palette dei colori non esiste e i dati che seguono indicano direttamente il colore dei singoli pixel attraverso la usuale notazione RGB. I dati dell'immagine sono memorizzati riga per riga, a partire dall'ultima fino alla prima (cioè i primi dati che si incontrano sono quelli relativi all'ultima riga della figura). I dati di ogni linea sono allineati a multipli di 4 byte. I primi due byte di un file BMP ne indicano il formato. Possono assumere i seguenti valori:

Visualizzare un'immagine BMP in Java

Il codice di seguito descritto lo trovate integralmente sul dischetto allegato alla rivista o al sito Ftp di Infomedia. è costituito dai seguenti file:

public Image createImage

public BMPProducer(URL url) {
  super();
  vConsumatori = new Vector();
  urlBitmap = url;
}

public synchronized void addConsumer(ImageConsumer ic) {
  if (vConsumatori.contains(ic)) {
   return;
  }
  vConsumatori.addElement(ic);
}

public synchronized boolean isConsumer(ImageConsumer ic) {
  return vConsumatori.contains(ic);
}

public synchronized void removeConsumer(ImageConsumer ic) {
 vConsumatori.removeElement(ic);
}

addConsumer(ic);

try {
  synchronized (this) {
   if (fLetta == false) {
    leggiBitmap(urlBitmap.openStream());
    fLetta = true;
   }
  }
}
catch (Exception e) {
 ic.imageComplete(ImageConsumer.IMAGEERROR);
 removeConsumer(ic);
 return;
}

ic.setColorModel(ColorModel.getRGBdefault());

ic.setDimensions(bmpInfo.iWidth,bmpInfo.iHeight);

ic.setHints(ImageConsumer.COMPLETESCANLINES | ImageConsumer.SINGLEPASS | 
            ImageConsumer.SINGLEFRAME);
ic.setPixels(0, 0, bmpInfo.iWidth-1, bmpInfo.iHeight-1,
     ColorModel.getRGBdefault(), aiDatiImg,0, bmpInfo.iWidth);

ic.imageComplete(ImageConsumer.STATICIMAGEDONE);

void leggiBitmap(InputStream is)

    throws IOException, UnknownBitmapException {
            DataInputStream dis = new DataInputStream(is);
            byte[] ab = new byte[4];
            short sTipo = dis.readShort();
            if (sTipo != 0x424D) {
                    dis.close();
                    throw new UnknownBitmapException();
           }
           dis.read(ab);   // OS/2 : dimensione del bitmap file header
                           // Windows : dimensione del file
           dis.read(ab);   // Hotspot (x e y)
           dis.read(ab);   // Offeset dati bitmap
           dis.read(ab);   // Dimensioni del bitmap info header
           // Leggo il bitmap info header
           byte[] abBIH = new byte[ab2int(ab)];
           abBIH[0] = ab[0]; abBIH[1] = ab[1];
           abBIH[2] = ab[2]; abBIH[4] = ab[3];
           dis.read(abBIH,4,abBIH.length-4);
           bmpInfo = new BMPInfoHeader(abBIH);
           bmpInfo.iWidth = bmpInfo.iWidth;
           bmpInfo.iHeight = bmpInfo.iHeight;

           if (bmpInfo.iBitPixel == 24) {
                   // ...
           } 
           else if (bmpInfo.iBitPixel == 8) {
           // Leggo la palette
            int aiPalette[] = new int[bmpInfo.iColori];
            byte abPalette[] = new byte[bmpInfo.iColori*4];
            dis.readFully(abPalette);
            int iIndex = 0;
            for(n=0; n<bmpInfo.iColori; ++n, iIndex += 4) {
             aiPalette[n] =  (255&0xff)<<24 | 
                 (((int)abPalette[iIndex+2]&0xff)<<16) | 
                 ((int)abPalette[iIndex+1]&0xff)<<8)    |
                 ((int)abPalette[iIndex]&0xff);
            }
            int iPad = 
              (bmpInfo.iDimensione / bmpInfo.iHeight) -  bmpInfo.iWidth;
               aiDatiImg =  new int[bmpInfo.iWidth*bmpInfo.iHeight];
            byte[] abDatiImg = 
               new byte[(bmpInfo.iWidth+iPad)*bmpInfo.iHeight];
            dis.readFully(abDatiImg);
            iIndex = 0;
            int n = 0;
            for(int j=0; j<bmpInfo.iHeight; ++j) {
              for (int i=0; i<bmpInfo.iWidth; ++i) {
                n = bmpInfo.iWidth*(bmpInfo.iHeight-j-1)+i;
                aiDatiImg[n] = aiPalette[((int)abDatiImg[iIndex]&0xff)];
                ++iIndex;
              }       // next i
              iIndex += iPad;
            }       // next j
            } else if (bmpInfo.iBitPixel == 4) {
            // ...

            }
            else {
              dis.close();
              throw new UnknownBitmapException();
            }
            dis.close();
    }       // leggiBitmap

La prima verifica da compiere è sui due byte che indicano il formato del file. Quindi segue la lettura del File Info Header e della dimensione del Bitmap Info Header. In base a questo dato viene letto l'intero Bitmap Info Header e viene creata un'istanza di BMPInfoHeader. Quest'ultima classe è definita in BMPInfoHeader.java e incapsula le informazioni contenute nel Bitmap Info Header. Non ha alcun metodo e possiede un solo costruttore il quale decodifica il blocco di dati in ingresso (passati come un array di byte) inizializzando opportunamente i campi della classe (vedi il listato  seguente).

public class BMPInfoHeader {
  public int   iPiani, // piani di colore
  iBitPixel,           // bit per pixel
  iCompressione,       // indicatore di compressione
  iDimensione,         // dimensione del  blocco di dati dell'immagine
  iPPMX,           // pixel per metro asse X
  iPPMY,           // pixel per metro asse Y
  iColori,            // n§ di colori utilizzati
  iImportanti,      // n§ di colori importanti
  iWidth,            // larghezza immagine
  iHeight,           // altezza immagine
  iDimRGB;        // n§ di byte utilizzati per contenere un  valore RGB

public BMPInfoHeader(byte[] abBIH) {
 // ... decodifica del Bitmap Info Header  in abBIH ...
 }

}

Visualizzare l'immagine in un'applet

Buona parte del codice necessario per realizzare l'applet desiderata è quello descritto nel paragrafo "Immagini e applet". Infatti l'unica cosa che è necessario compiere è quella di ridefinire il metodo getImage() per utilizzare createImage() con il nuovo ImageProducer:

public Image getImage(URL urlBase, String name) {
  String stURL = urlBase.toString();
  int p = stURL.lastIndexOf('/');
  if (p >= 0) {
    stURL = stURL.substring(0, p+1)+name;
  }

Image imgRet = null;
try {
imgRet = createImage(new BMPProducer
(new URL(stURL)));
} catch (Exception e) {}
return imgRet;
}

<APPLET CODE="BMP.class" WIDTH=100 HEIGHT=100>
<PARAM NAME="immagine" VALUE="unaimmagine.bmp">
</APPLET>

getImage(getDocumentBase(),

 getParameter("immagine"));

Fig 2: l'applet BMP.class eseguita in Netscape Navigator per OS/2

Un semplice browser di immagini

In figura 3 è possibile vedere in azione il nuovo ImageProducer all'interno di un'applicazione Java. 
 

Fig 3: un semplice browser di immagini GIF, JPEG e BMP eseguito come applicazione Java sulla Work Place Shell di OS/2 struttura di un file BMP

Si tratta di un semplice browser di immagini in grado di visualizzare GIF, JPG e BMP. Il funzionamento del programma è molto semplice. La finestra è costituita da due Panel, uno per la scelta del file da visualizzare (a sinistra) e l'altro per il disegno dell'immagine (a destra). Quando un file viene selezionato (facendo doppio click nella lista dei file) viene determinato il tipo di immagine (in base all'estensione del nome del file); se questa è un GIF o un JPG viene utilizzato il metodo getImage() del Toolkit di default, mentre se si carica un file BMP viene impiegato BMPProducer:

if (stNome.toUpperCase().endsWith(".BMP")) {
  try {
    URL url = new URL("file", "localhost", hostNome);
    img = createImage(new BMPProducer(url));
  } 
  catch (MalformedURLException mue) {
    img = null;
  }
} else {
img = Toolkit.getDefaultToolkit().
getImage(stNome);
}

Conclusioni

Nel corso dell'articolo siamo partiti dalle nozioni di base necessarie per visualizzare un'immagine e per decodificare un file BMP, per poi approfondire le classi che stanno alla base della produzione e visualizzazione delle immagini. Questo ha permesso la realizzazione di un'applet e di una applicazione in grado di visualizzare bitmap OS/2 e Windows. È importante notare che l'approccio seguito è riproducibile per qualsiasi tipo di formato grafico; è stato scelto il formato BMP perché è molto diffuso e abbastanza conosciuto, ma nulla vieta di realizzare degli ImageProducer per i formati grafici più disparati.