Strings und Binärdaten aus der gleichen Datei auslesen

[starcom]

Hallo
ich benötige mal eure Hilfe, ich seh den Wald vor lauter Bäumen aktuell wohl nicht

Problem : ich möchte eine Datei einlesen, die in den ersten Zeilen Metainformationen
enthält, leider kann die Anzahl der Zeilen variieren.

Darauf folgt dann ein großer Block an Binärdaten (ein Bild).

Die Metadaten benötige ich später Zeilenweise, die Bilddaten muss ich nur getrennt wieder
schreiben können.

Die Dateien haben das Format :

name <Tabulator> Wert
datum <Tabulator> Wert
laufende nummer <Tabulator> Wert
.
.
.
155 //
150 //
255 // diese 3 Zahlen sind immer vorhanden, jedoch immer unterschiedlich
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 13 12 21 19 10 1 14 15 13 5 2 1 6 12 11 5 16 8 4 11 14 2 6 16 20 15 9 13 5 3 19 20 40 73 129 162 158 130 118 133 152 145 152 189 164 85 65 83 84 100 155 187 164 160 186 202 205 201 189 184 180 193 216 180 102 86 54 33 24 21 103 182 213 209 212 222 213 204 208 197 176 165 178 201 198 171 170 191 204 194 174 168 176 179 185 186 183 188 204 212 196 175 189 211 200 201 220 198 159 147 133 118 121 98 80 75 90 74 3 60 86 134 161 161 166 171 167 174 181 171 155 138 120 111 89 41 27 64 96 118 157 167 146 158 156 132 158 186 153 66 19 23 31 4 32 27 28 16 2 15 19 6 9 20 26 10 2 7 7 9 3 11 7 13 16 14 16 6 8 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
.
.
.

Meine Frage ist jetzt, wie lese ich die gesamte Datei am sinnvollsten ein (ca. 30MB),
und wie kann ich dann am besten damit arbeiten ?

Ich hoffe ich habe mein Problem verständlich genug geschildert

Vielen Dank schon mal !

 

[nrg]

les sie mit einem BufferedReader ein und speicher Zeile für Zeile in einer Liste. Wenn die Metadaten immer gleich sind, macht es vllt sinn, die Datei direkt in einer Klasse abzubilden

 

[starcom]

les sie mit einem BufferedReader ein und speicher Zeile für Zeile in einer Liste. Wenn die Metadaten immer gleich sind, macht es vllt sinn, die Datei direkt in einer Klasse abzubilden

Hey, das war meine Idee ebenfalls... jedoch macht dies bei den eigentlichen Bilddaten keine Probleme ?
Die Metadaten darüber einlesen, ist ja kein Problem..

oder funktioniert es so wie oben beschrieben, ich müsste die Bilddaten dann nur über
Outputstream schreiben, und die Metadaten normal mit dem Filewriter ?


grüße & danke

 

[nrg]

was möchtest du denn machen? zum kopieren von binären daten eignet sich bufreader nicht so besonders gut.

 

[starcom]

was möchtest du denn machen? zum kopieren von binären daten eignet sich bufreader nicht so besonders gut.

genau das ist das Problem

ok, ich versuch es noch etwas genauer zu beschreiben

Inputfile :

name blubb
date	23.03.2011
.
.
.
155
150
255
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 4 2 2 2 5 7 4 1 2 1 7 4 4 7 4 9 11 7 14 9 3 5 4 2 3 2 5 5 3 5 2 3 1 2 2 6 5 3 5 2 5 3 1 8 6 7 5 4 4 7 8 7 12 7 12 8 5 8 11 4 8 1 7 1 3 12 8 3 3 2 2 4 2 6 6 4 7 4 9 9 7 3 5 5 8 9 5 1 4 1 4 2 7 6 1 5 3 8 1 3 2 3 2 1 6 7 4 13 9 1 4 8 6 2 1 4 5 1 6 5 5 3 3 6 4 7 6 2 4 7 2 6 0 11 4 6 2 2 7 4 2 4 1 3 2 5 2 3 1 3 6 10 6 5 6 5 0 6 6 14 1 2 4 0 6 6 9 6 3 8 4 0 4 5 3 2 1 5 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 1 7 2 5 6 5 3 3 5 5 4 3 3 2 9 3 11 12 4 4 5 4 2 4 4 4 4 2 4 0 1 3 3 2 2 3 7 7 4 4 3 2 1 9 10 3 1 2 5 8 6 7 3 1 4 3 3 2 0 3 5 7 1 7 4 1 3 2 8 7 1 3 4 2 0 3 3 4 6 3 4 3 8 7 2 5 3 3 8 5 3 3 2 3 1 3 5 2 5 4 3 6 6 2 1 0 3 3 3 8 5 5 2 2 8 14 6 6 3 9 5 3 3 1 6 3 2 5 2 6 1 5 3 10 3 7 2 2 1 4 2 6 8 4 7 2 2 7 2 4 2 3 6 2 4 2 6 9 4 4 8 6 1 3 3 2 7 6 0 5 9 3 6 2 8 6 7 3 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 5 6 3 0 1 6 7 6 9 7 1 0 3 6 4 1 3 2 8 6 10 10 4 7 5 2 4 6 1 3 3 0 2 4 3 0 3 7 5 6 9 3 11 12 4 5 9 9 1 5 3 6 3 3 11 11 4 6 7 2 3 3 2 3 4 6 5 0 4 4 8 5 8 6 3 3 5 4 4 7 4 6 3 5 4 7 2 5 4 1 6 8 1 6 3 1 1 6 2 7 4 6 7 2 8 5 2 1 8 7 2 1 3 0 1 5 6 5 4 1 1 4 4 7 5 8 3 6 2 6 2 4 4 5 6 9 4 5 7 5 2 6 2 2 3 3 1 1 3 2 2 0 6 7 1 3 3 9 5 1 8 9 6 6 2 10 9 2 1 3 7 7 2 6 8 6 4 8 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
.
.
.

Ich benötige nun :
jede Zeile der oberen Meta-Daten einzeln
UND
die restlichen Binär/Bilddaten um diese getrennt von den Metadaten wieder neu in
eine Datei schreiben zu können.


Hoffe so war es jetzt einfacher zu verstehen, sorry - mein Fehler



Gibt es denn eine Möglichkeit die ganze Datei über einen "DataInputStream" einzulesen,
und die Metdaten da irgendwie raus zu bekommen ? (in menschen-leserlicher Form )
grüße und danke

 

[nrg]

Für den Binärdaten musst du dann mit einem FileChannel arbeiten. Die Metadaten kannste ja mit einem BufferedReader einlesen.

 

[starcom]

jep, das problem ist dort aber immernoch : wie bekomme ich die metadaten aus de binärdaten raus ?
die neue datei darf nur noch die binärdaten enthalten, leider

 

[AmunRa]

Nach welchen Regeln sind den diese Daten aufgebaut, du hast doch geschrieben, dass es beliebig viele Metadaten geben kann.

Gibt es vl irgendeine Regel die das ende der Metadaten markiert. (z.B eine Tag) oder beginnen die Bilddaten immer mit den vielen 0?

 

[Semox]

Hallo starcom

Ich würde das so machen: Entweder effizient und sicher über einen Regulären Ausdruck filtern, oder eine kleine Routine, schreiben, die ab der so und so vielten Zeile das Stückweise einlesen aus der Quelldatei in ein Byte-Array realisiert. Danach kann man damit anstellen was man will.

Hier ist ein Post aus einem anderen Forum, wo eine ähnliche Frage gestellt wurde. Da ist auch ein Schnipsel, wie das gelöst wurde. Vorsicht, kann inspirierend wirken. Google half mir das zu finden.

Bild in ein Byte Array schreiben @ tutorials.de: Tutorials, Forum & Hilfe

Grüße,
Semo

 

[starcom]

Nach welchen Regeln sind den diese Daten aufgebaut, du hast doch geschrieben, dass es beliebig viele Metadaten geben kann.

Gibt es vl irgendeine Regel die das ende der Metadaten markiert. (z.B eine Tag) oder beginnen die Bilddaten immer mit den vielen 0?

Hey,
das Problem ist, laut Definition können in den Metadaten "Kommentarzeilen (mit einer # markiert)" auftauchen, die aber nicht beachtet werden
müssen. D.h. abtrennen nach x-Zeilen klappt leider nicht.
Es können also mal 10 Zeilen sein (mindestens sind es 10), mit Pech aber auch mal 15.

sie enden aber immer mit den 3 Zeilen mit jeweils einer 3stelligen Zahl.

Daher fällt leider auch das "ab der sovielten Zeile in ein ByteArray lesen" weg.



Im Moment verfolge ich den Ansatz die gesamte Datei in ein ByteArray zu lesen, und dort erst
mal mir die Meta-Daten rauszufiltern.
Eventuell wäre dann die Idee die Größe der Meta-Daten in Byte´s zu ermitteln und diese
dann aus dem Array entfernen ?
Nur so ne Idee, bin noch nicht so weit, dass ich es testen kann

 

[AmunRa]

Na dann hast du ja schon mal eine Abbruch bedingung, wenn 3 Zahlen mit jeweils ziffer aufgetauch sind weißt du dass dies die Daten sind die du suchst. Alles was danach kommt sind die Bilddaten

Lesen kannst du glaub ich am Besten mit einem DataInputStream dem du eben eine FileInputStream übergibst

 

[Semox]

Hallo starcom

Wenn Du das erst in einen Array liest und dann suchst, ist das nur eine Verlagerung des Problems...

Das ist doch die ideale Einsatzmöglichkeit für ein Regex!

Was gibt es Schöneres? Sauber und effizient!

Viele Grüße,
Semo

 

[Ark]

Lesen kannst du glaub ich am Besten mit einem DataInputStream dem du eben eine FileInputStream übergibst

Das ist eine gute Idee, allerdings würde ich noch einen BufferedInputStream dazwischenschalten:

DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(datei)));

Das mit den Strings ist so eine Sache. Wenn du weißt, dass die Datei immer genau so Strings enthält, dass sie richtig mit [c]in.readUTF()[/c] gelesen werden können (was ich bezweifle), kannst du darauf zurückgreifen. Wenn du weißt, dass es sich immer nur um ASCII-Zeichen handelt, kannst du auch [c](char)in.readUnsignedByte()[/c] verwenden und dich Zeichen für Zeichen durchhangeln. Gleiches gilt für UTF-16 Big-Endian, da ist [c]in.readChar()[/c] interessant. (Wenn es Little-Endian ist, musst du die Bytes außerdem noch paarweise vertauschen.) Um das Finden der Zeilenenden musst du dich dann selbst kümmern.

In anderen Fällen wird es etwas kompliziert. Ein [c]BufferedReader[/c] zum bequemen Einlesen von Zeilen scheidet hier nämlich aus, weil ein solcher (unabhängig von der Puffergröße und Unabhängig vom Zeichensatz!) bei Verwendung von [c]BufferedReader.readLine()[/c] eine nicht näher festgelegte Anzahl von Bytes einliest, die dir dann bei den Binärdaten fehlen würden.

@Semox: Mir ist nicht klar, wie hier Regex helfen sollten.

Ark

 

[starcom]

Erstmal vielen Dank für die rege Hilfe

im Moment habe ich den Spaß erstmal so :

FileInputStream in = new FileInputStream(sourceFile);

		
		byte[] buffer = new byte[1024];
		DataOutputStream out = null;
		out = new DataOutputStream(new FileOutputStream(destFile));
		for (int i; (i = in.read(buffer)) != -1;) {
			//System.out.print(new String(buffer, 0, i));
			
			out.write(buffer, 0, i);
		}

Die print-Anweisung ist nur für meine Kontrolle drin
Im Moment erstellt mir dieser Schnipsel erstmal eine direkte 1:1 Kopie der Files - jedoch
bin ich wie gesagt jetzt recht überfordert wie ich den Stream insofern manipulieren kann,
dass ich die Metadaten abtrennen kann.

 

[AmunRa]

Wie ich zuvor bereits geschreiben habe, haben wir ja bereits eine Erkennung gefunden.


versuch dir mal zu über legen wie du mit dem DataInputStream eine ganze Zeile einlesen kannst.+

z.B. kannst du ja so lang eine Char lesen bis du ein \n oder so liest.

 public static String readLine(DataInputStream d){
	  
	  StringBuilder sb= new StringBuilder();
	  char c;
	  do{
		  try {
			c= (char)d.readByte();
		} catch (IOException e) {
			break;
		}
		if (c!='\n'){
		  sb.append(c);
		}
	  }while(c!='\n');
	  
	  return sb.toString();
  }

 

[Ark]

z.B. kannst du ja so lang eine Char lesen bis du ein \n oder so liest.

Das reicht nicht, es sei denn, es ist garantiert, dass der Zeilenumbruch genau mit [c]\n[/c] (nicht mehr und nicht weniger) erfolgt.

Wenn [c]\r[/c] eingelesen wird, muss sofort mit Hinweis auf (alten Mac-)Zeilenumbruch angehalten werden. Außerdem muss man sich merken, dass gerade eben ein Zeilenumbruch durch [c]\r[/c] auftrat. Wenn nämlich das nächste Zeichen ein [c]\n[/c] ist, muss dies ignoriert werden (denn dann war der vormals als Mac-Zeilenumbruch erkannte Zeilenumbruch nur der Anfang eines Windows-Zeilenumbruchs)! Und da ist dann auch das Problem: Handelt es sich nämlich beim letzten Zeilenumbruch um einen Mac-Zeilenumbruch (also [c]\r[/c], aber nicht gefolgt von [c]\n[/c]), so müsste das zuletzt eingelesene Zeichen wieder zurückgenommen werden. Hier wird dann wohl ein [c]PushbackInputStream[/c] nötig sein. Oder genauer: ein [c]PushbackReader[/c], aber dann wird es noch komplizierter, da nämlich auch die einzelnen Bytes zurück in den InputStream müssten.

Mein Vorschlag deshalb: Rauskriegen, ob irgendwo Zeilenumbruch und verwendeter Zeichensatz eindeutig und verbindlich festgelegt/spezifiziert sind.

Ark

 

[AmunRa]

Mein Vorschlag deshalb: Rauskriegen, ob irgendwo Zeilenumbruch und verwendeter Zeichensatz eindeutig und verbindlich festgelegt/spezifiziert sind.

Ark

Da muss ich dir auch vollkommen recht geben dieses Problem hab ich mir natürlich auch gedacht, ich hab nur noch nicht darauf hingewiesen, da eben, über den Zeilenumbruch in den Metadaten keine Information gegeben wurden

 

[Semox]

Hallo starcom

Mich würde ja mal interessieren, welchen Typs Deine Datei ist, die Du da prüfen/parsen willst. Denn üblicherweise kann man anhand des Typs, z.B. JPEG auch bestimmen, wie groß der Header dann ist. Das wiederum führt zu der Möglichkeit die Datei in einen Puffer zu packen und dann ab einem bestimmbaren Offset den Header-Krempel abzutrennen und die verbleibenden Bits zu manipulieren oder damit was auch immer anzustellen was Du willst.

Um binäre Daten in menschenlesbare Form zu wandeln, würde ich die Datei ins Sedezimales System übertragen. Der klassische Hex-Editor tut's auch.

@ark
Es gibt immer eine Kombi aus 3er Zahlen, die so vermutlich den Bereich 2⁸ umfassen. Der binäre Teil besteht hingegen aus binären Zahlen. Wenn man dann also davon ausgeht, daß nach einem beliebigen 3er Zahlen auf jeden Fall ein Umbruch besteht, dann muß geprüft werden, ob danach eine Anzahl 0 folgt.

Aber ich will zuerst einmal wissen, welcher Dateityp vorliegt. Vielleicht kann man sich den ganzen Aufwand sparen...


Grüße,
Semo

 

[starcom]

Vielen Dank für das große Interesse und eure Hilfe

Es handelt sich bei dem File, dass geparsed werden soll um ein (zugegebener Maßen seltsames) Bildformat aus dem medizinischen Bereich.

Ich habe mich nochmal mit der Struktur etwas genauer befasst und würde das nochmal auflisten
bzw. die genauen Anforderungen euch hier posten

Die Datei enthält Schlüssel-Wert Paare, wobei Schlüssel und Wert jeweils mit einem Tab („\t“) voneinander getrennt sind. Pro Zeile ist hierbei ein Schlüssel-Wert Paar angegeben, wobei die Reihenfolge der Schlüssel-Wert Paare beliebig sein kann. Innerhalb dieses Block dürfen Leerzeilen oder Kommentarzeilen (beginnend mit #) enthalten sein.

nochmal der Aufbau des Files :

name xyz
datum 01.06.2010
.
.
.
image	null //möglicher Link auf externes Bild (jpg)
DATA     
250       
256
175
// hier muss getrennt werden
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 1 2 6 3 8 3 11 12 2 2 7 8 3 4 2 5 12 9 2 1 5 5 2 2 2 4 4 1 5 5 2 7 9 3 2 7 4 6 4 1 3 4 2 5 1 3 8 7 3 5 5 3 6 3 8 7 5 1 3 3 2 3 10 8 2 4 4 4 5 8 1 0 1 2 4 2 7 10 4 1 5 5 2 1 2 4 2 9 8 4 7 3 3 5 5 2 4 2 2 1 4 5 2 2 4 4 6 2 6 8 1 3 2 3 3 2 5 4 4 6 4 1 1 1 5 3 5 7 5 5 3 7 3 8 7 6 2 5 6 2 0 3 0 5 1 1 4 3 4 4 2 5 3 6 9 6 4 3 10 6 6 7 8 7 12 4 3 4 4 3 5 6 6 4 6 6 5 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 4 0 1 3 5 6 1 4 8 3 1 5 3 5 4 4 7 8 7 3 1 1 7 8 6 12 6 3 6 5 8 7 4 8 6 11 6 11 11 4 2 11 5 2 4 6 3 3 5 8 7 11 2 3 4 9 8 0 1 3 1 0 8 9 6 9 2 10 9 4 2 6 3 4 7 5 4 4 6 0 5 2 4 8 7 7 3 4 4 5 4 6 4 3 3 1 4 4 6 4 7 4 3 3 3 4 3 9 2 7 3 2 8 3 4 6 5 4 4 1 4 1 2 5 6 2 7 7 0 2 2 5 5 3 7 2 6 1 1 6 8 6 4 7 2 2 3 5 7 3 12 11 5 2 6 5 1 0 6 7 4 2 5 5 1 6 5 1 5 6 4 5 5 3 3 8 4 3 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 6 4 2 3 6 6 0 4 1 0 6 7 4 5 1 1 3 1 10 6 4 2 2 1 9 10 5 6 9 6 11 4 2 5 6 6 8 3 3 4 6 7 2 8 6 4 1 7 9 6 3 5 6 7 1 2 1 1 2 3 6 7 8 2 9 4 4 2 3 5 2 3 3 4 3 2 7 4 4 7 4 1 7 13 4 6 3 4 3 2 3 1 6 8 3 7 5 2 4 4 3 9 3 8 5 8 0 4 7 1 3 3 4 7 1 8 3 3 6 3 5 4 1 5 3 9 5 4 13 5 5 4 4 2 0 1 7 9 8 8 3 2 6 0 5 3 2 7 5 5 6 2 5 3 1 1 3 8 10 4 8 1 9 8 4 8 8 11 8 2 1 1 8 4 4 6 4 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 6 2 2 4 6 2 6 1 9 4 7 3 3 5 1 5 8 9 2 4 1 3 8 6 8 12 0 9 2 3 4 2 8 3 7 1 6 1 4 3 3 8 5 4 9 5 4 4 8 10 5 2 9 7 0 4 5 7 5 8 5 7 4 8 8 3 3 3 4 4 6 4 4 6 4 4 5 2 3 4 3 1 3 8 3 13 7 7 5 7 3 8 3 4 9 10 10 6 7 9 3 2 2 1 3 3 5 8 4 5 4 1 3 4 4 7 1 5 3 3 5 5 0 1 2 5 6 9 4 5 2 3 1 1 12 7 8 4 11 9 4 4 5 2 3 5 7 5 3 5 8 1 5 3 1 6 2 4 5 3 5 7 3 6 0 7 8 5 4 3 4 3 7 4 2 5 3 1 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 2 9 3 5 10 2 8 3 4 2 4 0 2 3 3 4 3 4 3 5 0 4 10 8 14 12 5 3 7 6 3 5 4 2 7 2 3 1 2 6 14 4 5 5 6 4 1 2 7 1 9 5 7 7 3 1 6 7 0 0 5 12 9 5 5 1 2 1 3 3 8 5 8 3 2 0 2 3 7 11 14 12 4 4 3 6 0 2 7 1 4 5 9 4 1 3 1 1 6 5 3 4 7 7 8 9 1 4 2 5 6 6 11 4 3 7 8 8 6 5 0 5 5 4 5 7 4 3 1 4 3 3 8 4 5 10 8 8 5 2 1 5 2 8 3 5 4 1 1 4 5 2 1 4 2 4 1 4 4 1 1 3 1 9 11 5 9 3 5 2 6 7 6 6 5 4 6 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 3 3 6 6 9 3 1 2 3 2 1 3 1 4 4 4 4 5 9 7 9 10 2 7 1 4 5 11 10 8 8 8 9 2 3 5 4 10 2 7 3 2 0 1 2 4 4 5 4 4 9 3 2 5 9 4 1 2 3 3 5 2 0 4 5 3 10 6 6 4 7 9 6 5 7 5 5 0 7 5 2 0 6 10 4 3 8 6 8 8 3 8 1 0 5 4 3 4 3 4 4 1 2 3 1 1 5 6 7 6 5 4 3 4 6 1 3 4 6 7 5 2 5 1 1 4 5 10 5 6 5 1 1 6 6 8 2 2 1 2 5 6 1 1 1 7 4 1 2 5 3 0 6 4 4 2 2 8 9 7 6 9 6 7 3 5 4 4 4 1 3 0 8 3 3 1 5 9 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Ich denke man könnte den Ansatz verfolgen das ganze bei DATA zu trennen ?

Die Anforderung an den Reader sind im Moment :
- Schlüssel-Wert-Paare auslesen (d.h. name=Max Mustermann, date=..., etc)
damit ich diese getrennt anzeigen lassen kann
- abspeichern der binärdaten (ohne die Meta-Daten!) in einem eigenen File


vielen Dank für eure Hilfe

 

[AmunRa]

Das Problem das du hast is noch immer wie du eine ganze Zeile lesen kannst.
Ist irgendwo definiert, welches Zeilentrennungszeichen verwendet wird?

\n
\n\r
\r
\r\n
oder  ganz was eigenes

 

[starcom]

leider nein

ich habe einen Tip bekommen und werden den jetzt testweise mal verfolgen

- ganzes File mit dem Filereader einlesen
- dadurch lassen sich die Metadaten logischerweise sehr leicht auslesen
- Binärdaten in ein Array packen, in short konvertieren und neu schreiben (da sind noch paar Fragen offen?!)

grüße

 

[AmunRa]

Kannst du mal so ein File irgendwo hochladen?

bzw zippen un hier im Form anhängen fals man das als neuer User darf

 

[Semox]

Mich fordert das Thema heraus. Das ist ne kleine Competition...

Ich code parallel auch ein Progrämmchen, was das können soll was Du willst. Wie heißt das Format denn um das es geht? Oder welches Gerät gibt die Daten aus? Ein CT, MRT oder etwas anderes? Und sind die binären Daten tatsächlich die Zahlen, die Du geschrieben hast, oder irgendwelche wilden ASCII Symbole, wenn Du es auf der Shell anzeigen läßt?

Bitte leg mal so eine ("anonymisierte?") File irgendwo ab, damit ich die mal durch meinen Rechner pusten kann.

Hier ist schonmal ein bißchen Code zum warmwerden mit dem man was anstellen kann. Eine Kopie einer Datei wird zumindest angelegt... Der Filter muß nun gebaut werden.

/*
 *	@author: Semo
 *      date: 2011-03-24
 *	version: 0.0.1a ;-)
 *	License: GPLv2	
 */

import java.io.*;

public class SuckImageryStuff {

	public static void stripMetaStuff(String dataproc) {

		try {
			File extractMe = new File(dataproc);
			FileInputStream fis = new FileInputStream(extractMe);
			FileOutputStream fos = new  FileOutputStream(dataproc + ".blob");
			
			int size = -1;
			int largeness = fis.available();
			byte[] bbuf = new byte[largeness];
			
			while((size = fis.read(bbuf)) != -1){

				//TODO Strip Meta-Content
				//Instead 0 --> pointer where Meta-Stuff ends

				fos.write(bbuf, 0, size);	
				fos.flush();
			}
			fis.close();
			fos.close();			
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("Fail.");
		} finally {
			System.out.println("Success.");
		}
	}


	public static void main (String[] args) {
		if (args.length < 1) {
			System.out.println("Error: Not enough Arguments.");
			System.out.println("Usage: java SuckImageryStuff FILE");
			System.exit(0);
		}
		System.out.println("Hi there. I will try to process your image now.");
		String image = args[0];
		stripMetaStuff(image);
		System.out.println("Process completed. Have a great day!");
	}

}

Viele Grüße,
Semo

 

[starcom]

bin nur grad nicht daheim, ich meld mich sonntag oder montag direkt wieder mit dem aktuellen stand

vielen dank

 

[starcom]

So, sorry für das späte melden


aktueller Stand ist folgender Quellcode :

	public static void fileReader() throws Exception {

		BufferedReader in = new BufferedReader(new FileReader("myFile.file"));
		String line = in.readLine();
		while (!line.equals("DATA")) {

			if (line.indexOf("name") == 0) {
				metainfo[0] = line.split("\\t")[1];
			}
			if (line.indexOf("birth") == 0) {
				metainfo[1] = line.split("\\t")[1];
			}
			if (line.indexOf("xxx") == 0) {
				metainfo[2] = line.split("\\t")[1];
			}
			if (line.indexOf("xxx") == 0) {
				metainfo[3] = line.split("\\t")[1];
			}
			if (line.indexOf("xxx") == 0) {
				metainfo[4] = line.split("\\t")[1];
			}
			if (line.indexOf("image") == 0) {
				metainfo[5] = line.split("\\t")[1];
			}
			line = in.readLine();
		}
		int xDim = Integer.parseInt(in.readLine());
		int yDim = Integer.parseInt(in.readLine());
		int zDim = Integer.parseInt(in.readLine());
		Short[][][] pictureData = new Short[xDim][yDim][zDim];

		for (int z = 0; z < zDim; z++) {
			for (int y = 0; y < yDim; y++) {
				line = in.readLine();
				String[] splitString = line.split(" ");

				for (int x = 0; x < splitString.length; x++) {
					if (splitString.length > 1) {
						short shortString = Short.parseShort(splitString[x]);
						pictureData[x][y][z] = shortString;

					}
				}
                                line = in.readLine(); // eingefügt damit Leerzeilen übersprungen werden!
			}
		}
		System.out.println("letzte Zeile als Test : ");
		for (int x = 0; x < xDim; x++) {
			System.out.print(pictureData[x][yDim - 1][zDim - 1]);
			System.out.print(" ");
		}

	}

dabei geben xDim, yDim die x und y Größe des Bildes, und z die Anzahl der Bilder wieder
(Bilder werden durch Leerzeilen getrennt).

Problem dabei ist - die Kontrolle über System.out.println zeigt mir, dass zDim-1 Zeilen fehlen
(dürfe so ziemlich den Leerzeilen entsprechen, die jeweils nach jedem "Block" für ein Bild auftauchen). (z = Anzahl der Blöcke)


EDIT : problem gelöst und oben editiert.. ab jetzt gehts ans schreiben

grüße