Visualizza sorgente di 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 ===
<syntaxhighlight lang="java" line>
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();
		}
	}	
}

</syntaxhighlight>

<syntaxhighlight lang="java" line>
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();
		}
	}
}
</syntaxhighlight>