Esercitazioni Java: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
(→‎Traccia)
(→‎Implementazione)
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>

Versione delle 11:05, 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.  
  142. 		} catch (IOException e) {
  143. 			e.printStackTrace();
  144. 		}
  145. 	}
  146.  
  147. 	void creaImmagineBianca(int dim) {
  148. 		int i,j;
  149. 		ByteBuffer buffer = ByteBuffer.wrap(new byte[4]).order(ByteOrder.LITTLE_ENDIAN);
  150. 		byte[] b = new byte[1078];
  151.  
  152. 		try {			
  153. 			RandomAccessFile biancaImage = new RandomAccessFile("bianca.bmp", "rw");
  154. 			image.seek(0);
  155. 			image.read(b, 0, 1078);
  156. 			biancaImage.seek(0);
  157. 			biancaImage.write(b, 0, 1078);
  158.  
  159. 			biancaImage.seek(18);
  160. 			buffer.putInt(dim);
  161. 			biancaImage.write(buffer.array(), 0, 4);
  162. 			biancaImage.write(buffer.array(), 0, 4);
  163.  
  164. 			biancaImage.seek(1078);
  165. 			for (i = 0; i < dim; i++) {
  166. 				for(j = 0; j < dim; j++) {
  167. 					biancaImage.writeByte(255);
  168. 				}
  169. 			}
  170. 			biancaImage.close();
  171.  
  172.  
  173. 		} catch (IOException e) {
  174. 			e.printStackTrace();
  175. 		}
  176. 	}
  177.  
  178. 	void rleEncoding() {
  179. 		int counter;
  180. 		int k;
  181. 		int i,j;
  182. 		try {
  183. 			PrintWriter out = new PrintWriter(new File("codifica.txt"));
  184. 			image.seek(0);
  185.  
  186. 			i = 0;
  187. 			j = 0;
  188. 			counter = 1;
  189. 			k = 0;
  190. 			int[] v = new int[width*height];
  191.  
  192. 			for (i = 0; i < width; i++) {
  193. 				for (j = 0; j < height; j++) {
  194. 					v[k] = matrice[i][j];
  195. 					k++;
  196. 				}
  197. 			}
  198.  
  199. 			for (k = 0; k < width*height-1; ) {
  200. 				while( k < width*height-1 && v[k] == v[k+1] ) {
  201. 					k++;
  202. 					counter++;
  203. 				}
  204. 				out.print(counter + "," + v[k] + " ");
  205. 				counter = 1;
  206. 				k++;
  207. 			}
  208. 			out.close();
  209.  
  210. 		} catch (IOException e) {
  211. 			e.printStackTrace();
  212. 		}
  213.  
  214. 	}	
  215. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esercitazioni_Java&oldid=509"