Esercitazioni Java

Traccia 1

Data la seguente immagine bitmap a 8 bit, implementare una classe Java che esegua i seguenti punti:

Aprire l'immagine e stampare a video le sue dimensioni (altezza e larghezza) e la dimensione del file in byte;
Creare l'immagine inversa, ovvero porre a 0 i pixel con valore 255 e viceversa, e salvare la nuova immagine in inversa.bmp;
Creare l'immagine ridotta di un fattore parametrico, quindi salvare l'immagine in compressa.bmp;
Creare un'immagine bitmap, sempre profondità 8 bit, di dimensione 4 x 4 tutta bianca, creando il file bianca.bmp;
Comprimere l'immagine utilizzando un metodo di compressione (per esempio run lenght).

Implementazione

```
import java.io.DataInputStream;
```
```
import java.io.File;
```
```
import java.io.FileInputStream;
```
```
import java.io.IOException;
```
```
import java.io.PrintWriter;
```
```
import java.io.RandomAccessFile;
```
```
import java.nio.ByteBuffer;
```
```
import java.nio.ByteOrder;
```
```
 
```
```
public class Immagine {
```
```
	// Nome del file
```
```
	private String imageName;
```
```
 
```

	// Variabili per gestire le dimensione dell'immagine

```
	private int width;
```
```
	private int height;
```
```
 
```
```
	// File binare per gestire l'immagine
```
```
	//private FileInputStream image;
```
```
	private RandomAccessFile image;
```
```
	private int[][] matrice;
```
```
 
```
```
	// Funzione Costruttore
```

	public Immagine(String path) throws IOException {

```
		imageName = path;
```

		image = new RandomAccessFile(new File(imageName), "r");

```
 
```
```
		ByteBuffer buffer = null;
```
```
		byte[] b = new byte[4];
```
```
 
```

		// Dal byte 18 trovo 2 interi che mi indicado num di colonne e di righe dell'immagine

```
		image.seek(18);
```
```
 
```
```
		image.read(b,0,4);
```

		width = buffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).getInt();

```
		image.read(b,0,4);
```

		height = buffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).getInt();

```
 
```

		// Alloco una matrice che possa contennere i pixel dell'immagine

```
		matrice = new int[width][height];
```
```
		getImagePixels();
```
```
	}
```
```
 
```
```
	public void getImagePixels() {
```
```
		int i = 0;
```
```
		int j = 0;
```
```
 
```
```
		try {
```
```
			image.seek(0);
```
```
			image.seek(1078);
```
```
 
```
```
			for (i = 0; i < width; i++) {
```
```
				for (j = 0; j < height; j++) {
```

					matrice[i][j] = image.readUnsignedByte();

```
				}
```
```
			}
```
```
 
```
```
		} catch (IOException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```
```
	public void stampaInformazioni() {
```
```
		try {
```

			System.out.println("La larghezza dell'immagine vale: " + width);

			System.out.println("L'altezza dell'immagine vale: " + height);

```
 
```

			System.out.println("La dimensione (in byte) dell'immagine vale: " + image.length());

```
 
```
```
		} catch (IOException e) {
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```

	public void creaImmagineInvertita(String newImageName) {

```
		int i, j;
```
```
		byte[] b = new byte[1078];
```

		int[][] invertedMatrix = new int[width][height];

```
 
```
```
		try {
```

			RandomAccessFile invertedImage = new RandomAccessFile(newImageName, "rw");

```
			image.seek(0);
```
```
			image.read(b, 0, 1078);
```
```
			invertedImage.write(b, 0, 1078);
```
```
 
```
```
			for (i = 0; i < width; i++) {
```
```
				for (j = 0; j < height; j++) {
```
```
					if (matrice[i][j] == 0)
```
```
						invertedMatrix[i][j] = 255;
```
```
					else
```
```
						invertedMatrix[i][j] = 0;
```

					invertedImage.writeByte(invertedMatrix[i][j]);

```
				}
```
```
			}
```
```
 
```
```
			invertedImage.close();
```
```
 
```
```
		} catch (IOException e) {
```
```
			e.printStackTrace();
```
```
		}	
```
```
	}
```
```
 
```

	public void comprimiImmagine(int factor) {

```
		int i,j;
```
```
 
```

		ByteBuffer buffer = ByteBuffer.wrap(new byte[8]).order(ByteOrder.LITTLE_ENDIAN);

```
		byte[] b = new byte[1078];
```
```
 
```
```
		try {
```
```
			int newWidth = width / factor;
```
```
			int newHeight = height / factor;
```
```
			int blockSize = newWidth / 8;
```
```
 
```

			RandomAccessFile compressedImage = new RandomAccessFile("compressed_" + factor + ".bmp", "rw");

```
			image.seek(0);
```
```
			image.read(b, 0, 1078);
```
```
			compressedImage.seek(0);
```
```
			compressedImage.write(b, 0, 1078);
```
```
 
```
```
			compressedImage.seek(18);
```
```
			buffer.putInt(newWidth);
```

			compressedImage.write(buffer.array(), 0, 4);

```
 
```

			System.out.println(compressedImage.getFilePointer());

```
 
```
```
			buffer.putInt(newHeight);
```

			compressedImage.write(buffer.array(), 4, 4);

```
 
```
```
			compressedImage.seek(1078);
```

			int[][] compressedMatrix = new int[newWidth][newHeight];

```
			int val = matrice[0][0];
```
```
			for (i = 0; i < newWidth; i++) {
```
```
				for(j = 0; j < newHeight; j++) {
```

					compressedMatrix[i][j] = matrice[i*factor][j*factor];

					compressedImage.writeByte(compressedMatrix[i][j]);

```
				}
```
```
			}
```
```
			compressedImage.close();
```
```
 
```
```
		} catch (IOException e) {
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```
```
	void creaImmagineBianca(int dim) {
```
```
		int i,j;
```

		ByteBuffer buffer = ByteBuffer.wrap(new byte[4]).order(ByteOrder.LITTLE_ENDIAN);

```
		byte[] b = new byte[1078];
```
```
 
```
```
		try {			
```

			RandomAccessFile biancaImage = new RandomAccessFile("bianca.bmp", "rw");

```
			image.seek(0);
```
```
			image.read(b, 0, 1078);
```
```
			biancaImage.seek(0);
```
```
			biancaImage.write(b, 0, 1078);
```
```
 
```
```
			biancaImage.seek(18);
```
```
			buffer.putInt(dim);
```

			biancaImage.write(buffer.array(), 0, 4);

			biancaImage.write(buffer.array(), 0, 4);

```
 
```
```
			biancaImage.seek(1078);
```
```
			for (i = 0; i < dim; i++) {
```
```
				for(j = 0; j < dim; j++) {
```
```
					biancaImage.writeByte(255);
```
```
				}
```
```
			}
```
```
			biancaImage.close();
```
```
 
```
```
 
```
```
		} catch (IOException e) {
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```
```
	void rleEncoding() {
```
```
		int counter;
```
```
		int k;
```
```
		int i,j;
```
```
		try {
```

			PrintWriter out = new PrintWriter(new File("codifica.txt"));

```
			image.seek(0);
```
```
 
```
```
			i = 0;
```
```
			j = 0;
```
```
			counter = 1;
```
```
			k = 0;
```
```
			int[] v = new int[width*height];
```
```
 
```
```
			for (i = 0; i < width; i++) {
```
```
				for (j = 0; j < height; j++) {
```
```
					v[k] = matrice[i][j];
```
```
					k++;
```
```
				}
```
```
			}
```
```
 
```
```
			for (k = 0; k < width*height-1; ) {
```

				while( k < width*height-1 && v[k] == v[k+1] ) {

```
					k++;
```
```
					counter++;
```
```
				}
```

				out.print(counter + "," + v[k] + " ");

```
				counter = 1;
```
```
				k++;
```
```
			}
```
```
			out.close();
```
```
 
```
```
		} catch (IOException e) {
```
```
			e.printStackTrace();
```
```
		}
```
```
	}	
```
```
}
```

```
import java.io.IOException;
```
```
import java.util.Scanner;
```
```
 
```
```
public class Principale {
```
```
 
```

	public static void main(String[] args) {

```
 
```
```
		int scelta = -1;
```
```
		try {
```

			Immagine bitmap = new Immagine("scacc.bmp");

```
			while (scelta != 0) {
```

				System.out.println("Immagine aperta;");

				System.out.println("Premi 1 per visualizzare le informazioni dell'immagine");

				System.out.println("Premi 2 per creare l'immagine inversa");

				System.out.println("Premi 3 per creare l'immagine compressa");

				System.out.println("Premi 4 per creare l'immagine bianca");

				System.out.println("Premi 5 per algoritmo rle");

				System.out.print("Inserisci scelta: ");

```
				Scanner s = new Scanner(System.in);
```
```
				scelta = s.nextInt();
```
```
 
```
```
				switch(scelta) {
```
```
				case 1:
```
```
					bitmap.stampaInformazioni();
```
```
					break;
```
```
				case 2:
```

					bitmap.creaImmagineInvertita("scacc_inverted.bmp");

```
					break;
```
```
				case 3:
```
```
					bitmap.comprimiImmagine(20);
```
```
					break;
```
```
				case 4:
```
```
					bitmap.creaImmagineBianca(4);
```
```
					break;
```
```
				case 5:
```
```
					bitmap.rleEncoding();
```
```
					break;
```
```
				}
```
```
			}
```
```
		} catch (IOException e) {
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
}
```

Esercitazioni Java

Traccia 1

Implementazione

Menu di navigazione

Strumenti personali

Namespace

Varianti

Visite

Azioni

Ricerca

Navigazione

Strumenti