Esercitazioni Java: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
(→‎Traccia)
(→‎Traccia 1)
 
(3 versioni intermedie di uno stesso utente non sono mostrate )
Riga 1: Riga 1:
 
== Traccia 1==
 
== Traccia 1==
−
Data la seguente immagine bitmap a 8 bit, implementare una classe Java che esegua i seguenti punti:
+
Data la seguente [http://www.vitoantoniobevilacqua.it/wiki/files/scacchiera.bmp 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;
 
# 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 inversa, ovvero porre a 0 i pixel con valore 255 e viceversa, e salvare la nuova immagine in inversa.bmp;
Riga 8: Riga 8:
  
 
=== Implementazione ===
 
=== 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>

Versione attuale delle 14:24, 22 mag 2017

Traccia 1

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

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

Implementazione

  1. import java.io.DataInputStream;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.PrintWriter;
  6. import java.io.RandomAccessFile;
  7. import java.nio.ByteBuffer;
  8. import java.nio.ByteOrder;
  9.  
  10. public class Immagine {
  11. 	// Nome del file
  12. 	private String imageName;
  13.  
  14. 	// Variabili per gestire le dimensione dell'immagine
  15. 	private int width;
  16. 	private int height;
  17.  
  18. 	// File binare per gestire l'immagine
  19. 	//private FileInputStream image;
  20. 	private RandomAccessFile image;
  21. 	private int[][] matrice;
  22.  
  23. 	// Funzione Costruttore
  24. 	public Immagine(String path) throws IOException {
  25. 		imageName = path;
  26. 		image = new RandomAccessFile(new File(imageName), "r");
  27.  
  28. 		ByteBuffer buffer = null;
  29. 		byte[] b = new byte[4];
  30.  
  31. 		// Dal byte 18 trovo 2 interi che mi indicado num di colonne e di righe dell'immagine
  32. 		image.seek(18);
  33.  
  34. 		image.read(b,0,4);
  35. 		width = buffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).getInt();
  36. 		image.read(b,0,4);
  37. 		height = buffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).getInt();
  38.  
  39. 		// Alloco una matrice che possa contennere i pixel dell'immagine
  40. 		matrice = new int[width][height];
  41. 		getImagePixels();
  42. 	}
  43.  
  44. 	public void getImagePixels() {
  45. 		int i = 0;
  46. 		int j = 0;
  47.  
  48. 		try {
  49. 			image.seek(0);
  50. 			image.seek(1078);
  51.  
  52. 			for (i = 0; i < width; i++) {
  53. 				for (j = 0; j < height; j++) {
  54. 					matrice[i][j] = image.readUnsignedByte();
  55. 				}
  56. 			}
  57.  
  58. 		} catch (IOException e) {
  59. 			// TODO Auto-generated catch block
  60. 			e.printStackTrace();
  61. 		}
  62. 	}
  63.  
  64. 	public void stampaInformazioni() {
  65. 		try {
  66. 			System.out.println("La larghezza dell'immagine vale: " + width);
  67. 			System.out.println("L'altezza dell'immagine vale: " + height);
  68.  
  69. 			System.out.println("La dimensione (in byte) dell'immagine vale: " + image.length());
  70.  
  71. 		} catch (IOException e) {
  72. 			e.printStackTrace();
  73. 		}
  74. 	}
  75.  
  76. 	public void creaImmagineInvertita(String newImageName) {
  77. 		int i, j;
  78. 		byte[] b = new byte[1078];
  79. 		int[][] invertedMatrix = new int[width][height];
  80.  
  81. 		try {
  82. 			RandomAccessFile invertedImage = new RandomAccessFile(newImageName, "rw");
  83. 			image.seek(0);
  84. 			image.read(b, 0, 1078);
  85. 			invertedImage.write(b, 0, 1078);
  86.  
  87. 			for (i = 0; i < width; i++) {
  88. 				for (j = 0; j < height; j++) {
  89. 					if (matrice[i][j] == 0)
  90. 						invertedMatrix[i][j] = 255;
  91. 					else
  92. 						invertedMatrix[i][j] = 0;
  93. 					invertedImage.writeByte(invertedMatrix[i][j]);
  94. 				}
  95. 			}
  96.  
  97. 			invertedImage.close();
  98.  
  99. 		} catch (IOException e) {
  100. 			e.printStackTrace();
  101. 		}	
  102. 	}
  103.  
  104. 	public void comprimiImmagine(int factor) {
  105. 		int i,j;
  106.  
  107. 		ByteBuffer buffer = ByteBuffer.wrap(new byte[8]).order(ByteOrder.LITTLE_ENDIAN);
  108. 		byte[] b = new byte[1078];
  109.  
  110. 		try {
  111. 			int newWidth = width / factor;
  112. 			int newHeight = height / factor;
  113. 			int blockSize = newWidth / 8;
  114.  
  115. 			RandomAccessFile compressedImage = new RandomAccessFile("compressed_" + factor + ".bmp", "rw");
  116. 			image.seek(0);
  117. 			image.read(b, 0, 1078);
  118. 			compressedImage.seek(0);
  119. 			compressedImage.write(b, 0, 1078);
  120.  
  121. 			compressedImage.seek(18);
  122. 			buffer.putInt(newWidth);
  123. 			compressedImage.write(buffer.array(), 0, 4);
  124.  
  125. 			System.out.println(compressedImage.getFilePointer());
  126.  
  127. 			buffer.putInt(newHeight);
  128. 			compressedImage.write(buffer.array(), 4, 4);
  129.  
  130. 			compressedImage.seek(1078);
  131. 			int[][] compressedMatrix = new int[newWidth][newHeight];
  132. 			int val = matrice[0][0];
  133. 			for (i = 0; i < newWidth; i++) {
  134. 				for(j = 0; j < newHeight; j++) {
  135. 					compressedMatrix[i][j] = matrice[i*factor][j*factor];
  136. 					compressedImage.writeByte(compressedMatrix[i][j]);
  137. 				}
  138. 			}
  139. 			compressedImage.close();
  140.  
  141. 		} catch (IOException e) {
  142. 			e.printStackTrace();
  143. 		}
  144. 	}
  145.  
  146. 	void creaImmagineBianca(int dim) {
  147. 		int i,j;
  148. 		ByteBuffer buffer = ByteBuffer.wrap(new byte[4]).order(ByteOrder.LITTLE_ENDIAN);
  149. 		byte[] b = new byte[1078];
  150.  
  151. 		try {			
  152. 			RandomAccessFile biancaImage = new RandomAccessFile("bianca.bmp", "rw");
  153. 			image.seek(0);
  154. 			image.read(b, 0, 1078);
  155. 			biancaImage.seek(0);
  156. 			biancaImage.write(b, 0, 1078);
  157.  
  158. 			biancaImage.seek(18);
  159. 			buffer.putInt(dim);
  160. 			biancaImage.write(buffer.array(), 0, 4);
  161. 			biancaImage.write(buffer.array(), 0, 4);
  162.  
  163. 			biancaImage.seek(1078);
  164. 			for (i = 0; i < dim; i++) {
  165. 				for(j = 0; j < dim; j++) {
  166. 					biancaImage.writeByte(255);
  167. 				}
  168. 			}
  169. 			biancaImage.close();
  170.  
  171.  
  172. 		} catch (IOException e) {
  173. 			e.printStackTrace();
  174. 		}
  175. 	}
  176.  
  177. 	void rleEncoding() {
  178. 		int counter;
  179. 		int k;
  180. 		int i,j;
  181. 		try {
  182. 			PrintWriter out = new PrintWriter(new File("codifica.txt"));
  183. 			image.seek(0);
  184.  
  185. 			i = 0;
  186. 			j = 0;
  187. 			counter = 1;
  188. 			k = 0;
  189. 			int[] v = new int[width*height];
  190.  
  191. 			for (i = 0; i < width; i++) {
  192. 				for (j = 0; j < height; j++) {
  193. 					v[k] = matrice[i][j];
  194. 					k++;
  195. 				}
  196. 			}
  197.  
  198. 			for (k = 0; k < width*height-1; ) {
  199. 				while( k < width*height-1 && v[k] == v[k+1] ) {
  200. 					k++;
  201. 					counter++;
  202. 				}
  203. 				out.print(counter + "," + v[k] + " ");
  204. 				counter = 1;
  205. 				k++;
  206. 			}
  207. 			out.close();
  208.  
  209. 		} catch (IOException e) {
  210. 			e.printStackTrace();
  211. 		}
  212. 	}	
  213. }


  1. import java.io.IOException;
  2. import java.util.Scanner;
  3.  
  4. public class Principale {
  5.  
  6. 	public static void main(String[] args) {
  7.  
  8. 		int scelta = -1;
  9. 		try {
  10. 			Immagine bitmap = new Immagine("scacc.bmp");
  11. 			while (scelta != 0) {
  12. 				System.out.println("Immagine aperta;");
  13. 				System.out.println("Premi 1 per visualizzare le informazioni dell'immagine");
  14. 				System.out.println("Premi 2 per creare l'immagine inversa");
  15. 				System.out.println("Premi 3 per creare l'immagine compressa");
  16. 				System.out.println("Premi 4 per creare l'immagine bianca");
  17. 				System.out.println("Premi 5 per algoritmo rle");
  18. 				System.out.print("Inserisci scelta: ");
  19. 				Scanner s = new Scanner(System.in);
  20. 				scelta = s.nextInt();
  21.  
  22. 				switch(scelta) {
  23. 				case 1:
  24. 					bitmap.stampaInformazioni();
  25. 					break;
  26. 				case 2:
  27. 					bitmap.creaImmagineInvertita("scacc_inverted.bmp");
  28. 					break;
  29. 				case 3:
  30. 					bitmap.comprimiImmagine(20);
  31. 					break;
  32. 				case 4:
  33. 					bitmap.creaImmagineBianca(4);
  34. 					break;
  35. 				case 5:
  36. 					bitmap.rleEncoding();
  37. 					break;
  38. 				}
  39. 			}
  40. 		} catch (IOException e) {
  41. 			e.printStackTrace();
  42. 		}
  43. 	}
  44. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esercitazioni_Java&oldid=512"