Come leggere le immagini PGM in Java?
https://stackoverflow.com/questions/3639198
-
30-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
mi sento come se mi manca qualcosa di semplice qui (come al solito).
Sto cercando di leggere le immagini PGM utilizzando Java. Matlab lo fa bene - l'emissione dei pixel dell'immagine (per esempio, piccola immagine di un 32x32) in Matlab mi dà qualcosa di simile:
1 0 11 49 94 118 118 106 95 88 85 96 124 143 142 133
Il mio lettore di Java, tuttavia, Risulterà:
1 0 11 49 94 118 118 106 95 88 85 96 124 65533 65533 65533
Sembra valori dei pixel sopra 127 sono riempiti con 65533, anche se non ottenere alcuni valori casuali corretto, e anche aventi quasi l'intera riga inferiore al valore di -1.
Ecco il codice che sto 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();
Tutte le idee sarebbe molto apprezzato.
Modifica Questi sono i valori PGM senza segno:
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
Gli sguardi di intestazione come questo:
P5 # MatLab PGMWRITE file, saved 27-Jun-2002 16 16 255
Modifica # 2
Ecco l'output completo del codice di prova di seguito:
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)
Linea 49 di cui al l'eccezione generata è:
System.out.println(String.format("Skipping unknow token: \"%s\"", scan.next()));
Il problema, ne sono certo, ha qualcosa a che fare con il fatto che questi file di immagine sono costituiti da due ASCII testo / numeri così come i dati immagine binari. Ma se Java non ha alcun problema di lettura PNG, perché la mancanza di supporto per PGM?
Modifica 3
Ok, ho trovato un'implementazione che le opere ... Purtroppo, è deprecato:
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();
}
In base alla documentazione Java, il costruttore StreamTokenizer(InputStream) è deprecato, perché il metodo DataInputStream.readLine() non converte correttamente i byte prime ai caratteri. Tuttavia, sembra funzionare in questo caso specifico sull'intestazione, e ovviamente funziona per i dati conseguente immagine binaria.
Purtroppo, è ancora deprecato, e sembra che da un intermixing BufferedReader la documentazione suggerisce solo i risultati in EOFExceptions dopo aver letto l'intestazione e il tentativo di utilizzare il DataInputStream per leggere i byte grezzi. Ancora alla ricerca di una soluzione ...
Soluzione
Il problema con il vostro codice è che si sta utilizzando la classe sbagliata per leggere i dati grezzi dal file. Come la documentazione BufferedReader dice:
public int read() throws IOExceptionLegge un singolo carattere.
Reso: La lettura di caratteri, come un numero intero nell'intervallo da 0 a 65535 (0x00-0xffff), oppure -1 se la fine del flusso è stata raggiunta
Così ogni chiamata al metodo read() di BufferedReader consuma in realtà uno o due byte (basato sulla codifica dei caratteri) dal flusso di input, che non è quello che si desidera. Questo spiega anche perché si ottiene un sacco di -1:. Il flusso si è conclusa molto prima di quanto si pensava
Dal PGM contiene valori come decimale ASCII, è facile da analizzare utilizzando il Scanner classe.
Ecco un quasi non testati di codice che mostra come leggere un'immagine PGM assumendo che:
- contiene un singolo commento dopo il numero magico (vale a dire che non ha le linee che iniziano con un # tranne il secondo)
- il file PGM è esattamente lungo 4 linee.
Ecco il codice:
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();
}
necessità di attuare: il supporto per le righe di commento, valori per ogni elemento deve essere diviso per maxvalue, controllo degli errori per i file malformati, la gestione delle eccezioni. L'ho testato su un file PGM utilizza UNIX end-of-line, ma dovrebbe funzionare anche su Windows.
Vorrei sottolineare che questa non è un'implementazione robusta né completa di un PGM parser . Questo codice è destinato proprio come prova di concetto che forse compie appena sufficiente per le vostre esigenze.
Se davvero bisogno di un robusto parser PGM, è possibile utilizzare gli strumenti forniti da Netpbm .
