Cómo leer las imágenes PGM en Java?
https://stackoverflow.com/questions/3639198
-
30-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Me siento como si estuviera perdiendo algo simple aquí (como de costumbre).
Estoy intentando leer las imágenes PGM utilizando Java. Matlab lo hace muy bien - la salida de los píxeles de la imagen (por ejemplo, una pequeña imagen 32x32) en Matlab me da algo como esto:
1 0 11 49 94 118 118 106 95 88 85 96 124 143 142 133
Mi lector de Java, sin embargo, da salida a esto:
1 0 11 49 94 118 118 106 95 88 85 96 124 65533 65533 65533
Parece que los valores de píxeles por encima de 127 se rellenan con 65533, aunque sí conseguir algunos valores aleatorios incorrecto y cesionarios incluso casi toda la fila inferior al valor de -1.
Aquí está el código que estoy usando:
filePath = 'imagepath.pgm';
FileInputStream fileInputStream = new FileInputStream(filePath);
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));
// read the header information ...
int [][] data2D = new int [picWidth] [picHeight];
for (int row = 0; row < picHeight; row++) {
for (int col = 0; col < picWidth; col++) {
data2D[row][col] = bufferedReader.read();
System.out.print(data2D[row][col] + " ");
}
System.out.println();
}
fileInputStream.close();
Cualquier idea sería muy apreciada.
Editar Estos son los valores de PGM sin firmar:
1 0 11 49 94 118 118 106 95 88 85 96 124 143 142 133
30 26 29 57 96 122 125 114 102 94 91 101 127 146 145 136
96 85 70 75 101 128 136 126 111 106 106 112 131 149 153 147
163 147 114 93 99 120 132 123 110 113 124 129 137 154 166 168
215 195 149 105 88 99 114 111 106 123 148 158 160 174 191 197
245 224 173 115 81 82 100 109 117 144 179 194 194 205 222 230
235 217 170 115 78 78 113 117 100 83 80 212 214 226 244 253
178 167 135 93 68 78 123 129 106 77 69 202 204 222 244 255
114 110 92 64 54 81 107 105 83 59 56 182 184 201 222 231
79 80 71 52 55 97 67 55 41 33 42 184 179 181 185 183
62 66 65 52 63 115 29 16 12 17 30 209 197 174 150 132
40 47 52 44 55 109 171 196 188 186 208 229 218 179 136 107
31 38 44 37 43 89 145 167 158 159 191 223 219 179 133 105
48 52 56 51 57 91 128 133 117 120 157 196 200 168 128 105
64 67 70 73 87 114 127 107 79 81 118 159 173 154 123 104
63 67 73 83 107 132 129 91 54 54 88 130 153 146 123 106
Las miradas de cabecera como esta:
P5 # MatLab PGMWRITE file, saved 27-Jun-2002 16 16 255
Editar # 2
Aquí está la salida completa de la prueba de concepto a continuación:
Skipping unknow token: ""
Skipping unknow token: "1^vvj_XU`|���"
Skipping unknow token: ""
Skipping unknow token: "9`z}rf^[e���`UFKe��~ojjp������r]cx�{nq|������ÕiXcroj{��������sQRdmu��������٪sNNqudSP�����]DN{�jME�����rn\@6QkiS;8�����OPG47aC7)!*�����>BA4?s"
Skipping unknow token: ""
Skipping unknow token: ""
Skipping unknow token: "�Ů��(/4,7m�ļ���ڳ�k"
Skipping unknow token: "&,%+Y������۳�i04839[��ux��Ȩ�i@CFIWrkOQv���{h?CISk��[66X���{j"
Exception in thread "main" java.util.NoSuchElementException
at java.util.Scanner.throwFor(Scanner.java:838)
at java.util.Scanner.next(Scanner.java:1347)
at Test.main(Test.java:49)
Línea 49 se hace referencia en la excepción lanzada es:
System.out.println(String.format("Skipping unknow token: \"%s\"", scan.next()));
El problema, estoy seguro, tiene algo que ver con el hecho de que estos archivos de imagen consisten tanto en ASCII texto / números, así como datos de imagen binarios. Pero si Java no tiene problemas en la lectura de archivos PNG, ¿por qué la falta de apoyo a las PGM?
Editar 3
Bueno, he encontrado una aplicación que funciona ... Por desgracia, es en desuso:
filePath = "imagepath.pgm"
FileInputStream fileInputStream = new FileInputStream(filePath);
DataInputStream dis = new DataInputStream(fileInputStream);
StreamTokenizer streamTokenizer = new StreamTokenizer(dis);
// read header text using StreamTokenizer.nextToken()
data2D = new int [picWidth] [picHeight];
for (int row = 0; row < picHeight; row++) {
for (int col = 0; col < picWidth; col++) {
data2D[row][col] = dis.readUnsignedByte();
System.out.print(data2D[row][col] + " ");
}
System.out.println();
}
De acuerdo con la documentación de Java, el constructor StreamTokenizer(InputStream) está en desuso, debido a que el método de DataInputStream.readLine() no convierte correctamente bytes sin formato a caracteres. Sin embargo, parece que funciona en este caso específico en la cabecera, y obviamente funciona para los datos de imagen binaria resultante.
Por desgracia, sigue siendo obsoleta, y parece que entremezclando una BufferedReader como la documentación sugiere sólo se traduce en EOFExceptions después de leer el encabezado y de intentar utilizar el DataInputStream para leer los bytes sin formato. Sigue buscando una solución ...
Solución
El problema con el código es que está utilizando la clase equivocada para leer los datos en bruto a partir del archivo. Como dice la documentación BufferedReader:
public int read() throws IOExceptionLee un solo carácter.
Devuelve: La lectura de caracteres, como un entero en el rango de 0 a 65535 (0x00-0xffff), o -1 si el final de la secuencia se ha alcanzado
Así que cada llamada al método read() de BufferedReader consume realmente uno o dos bytes (basado en la codificación de caracteres) del flujo de entrada, que no es lo que desea. Esto también explica por qué se obtiene una gran cantidad de -1:. La corriente terminó mucho antes de lo que pensaba
Desde PGM contiene valores como decimal ASCII, es fácil de analizar mediante el clase escáner .
Aquí hay un casi sin probar código que muestra cómo leer una imagen PGM asumiendo que:
- que contiene un solo comentario después de que el número mágico (es decir, que no tiene líneas que comienzan con un #, excepto el segundo)
- el archivo PGM es exactamente 4 líneas de largo.
Aquí está el código:
String filePath = "image.pgm";
fileInputStream = new FileInputStream(filePath);
Scanner scan = new Scanner(fileInputStream);
// Discard the magic number
scan.nextLine();
// Discard the comment line
scan.nextLine();
// Read pic width, height and max value
int picWidth = scan.nextInt();
int picHeight = scan.nextInt();
int maxvalue = scan.nextInt();
fileInputStream.close();
// Now parse the file as binary data
fileInputStream = new FileInputStream(filePath);
DataInputStream dis = new DataInputStream(fileInputStream);
// look for 4 lines (i.e.: the header) and discard them
int numnewlines = 4;
while (numnewlines > 0) {
char c;
do {
c = (char)(dis.readUnsignedByte());
} while (c != '\n');
numnewlines--;
}
// read the image data
int[][] data2D = new int[picHeight][picWidth];
for (int row = 0; row < picHeight; row++) {
for (int col = 0; col < picWidth; col++) {
data2D[row][col] = dis.readUnsignedByte();
System.out.print(data2D[row][col] + " ");
}
System.out.println();
}
Necesidad de implementar: el apoyo a las líneas de comentarios, los valores para cada elemento debe dividirse por maxvalue, la comprobación de errores para archivos con formato incorrecto, manejo de excepciones. He comprobado en un archivo PGM usando UNIX de fin de líneas, pero debería funcionar también en Windows.
Permítanme subrayar que esto no es una implementación robusta ni completa de una PGM analizador . Este código está destinado al igual que la prueba de concepto de que tal vez logra sólo lo suficiente para sus necesidades.
Si realmente necesita un robusto analizador PGM, puede utilizar las herramientas proporcionadas por Netpbm .
