✔ hex to ascii (und später als image)

F

fReAkgoesTutorials

Grünschnabel
Guten Morgen miteinander :)

Ich hänge an einem extrem kniffligen Problem, dass es so im Internet nicht zu lösen gibt und wo ich wirklich nen guten Rat gebrauchen könnte.
Das ganze drum herum erspare ich und komme direkt zum Punkt:

der Firefox-Cache liefert mir zu jedem Bild, dass ich im Internet aufgerufen habe, die dazugehörige Hex-Tabelle. D.h. Wenn ich diese Hextabelle in einen Hex-editor schmeiße und diese Datei dann also *.jpg speichere, erscheint das bild.

Das ganze soll java für mich machen :).

Java: 
StringBuilder sb = new StringBuilder();
		for (String a : tbytes ) {
			  int c = Integer.parseInt(a,16);
			  char chr = (char)c;
			  sb.append(chr);
		}
Ich habe natürlich längst gelöst, wie ich hex in ascii umwandle.
Mein Problem ist aber, dass das Firefox-Bild, dass ich aus dem Cache geholt habe, scheinbar zeichen enthält, die die Ascii-Umwandlung von java nicht hinbekommt. So kommen an viele Stellen ein "?" anstelle des Zeichens, dass ich brauche.

"ƒ„…†‡ˆ‰Š’“”•–—˜™š" <-- diese sind in der Tabelle, die Firefox-Cache zu bildern liefert, enthalten. Und wenn ich diese Tabelle in einen Hexeditor schmeiße, gibt er sie mir auch korrekt nachher aus.
Nur java kriegt das nicht gebacken! Lösungsvorschläge?

Das Hauptproblem scheint auch allgemein darin zu liegen, dass ASCII generell ja nur 127 Zeichen enthält. Hinzu kommt dann aus irgendeinem grund eine ascii-Sondertabelle.

Erst, wenn ich im Internet nach "Ansi Codetabell" google, kriege ich eine Tabelle mit Zahlen bis 255, die auch die von mir benötigten Sonderzeichen enthalten. Aber Kann java die überhaupt verarbeiten bzw. abspeichern?
 
Hi,
mein Vorschlag wäre das Ganze auf Byte-Ebene zu machen und nicht auf String-Ebene. D.h. du nimmst die Hex-Tabelle und wandelst diese in einen Binärcode und nicht in einen ASCII-Code um. Dann kannst du die Bytes auch direkt wieder schreiben. Hier ein Beispiel zum schreiben eines Byte[] zu einem Image.

Gruß

Fabio
 
Hi.

So wie ich das verstehe liefert dir der Firefox Cache die Bilder direkt als Bytes. Da mußt du überhaupt nichts mehr umwandeln, sondern die Daten einfach 1:1 auf die Platte durchschreiben.

Ansonsten zeig mal wie du die Daten von Firefox bekommst.

Gruß
 
6bxqogc

So kriege ich die Daten von Firefox. Sind also keine bytes, sondern hex-Werte. Ich krieg einfach den Schritt von hex->bild nich gebacken. Ich habe einfach gedacht, ich wandle die hex-werte in die Ascii-zeichen um und schreibe sie in eine Datei. Die Datei wird dann letztendlich als bild repräsentiert

@Fabio
Ich kann mir gerade nicht vorstellen, wie das funktionieren kann. Ich wandle also die hexa-werte in binärwerte (8bit werte also) um und kann daraus ein Bild erzeugen? Ist das korrekt?
 
Dass die Umrechnung klappt, ist selbstredend. Dass der Rechner nur in 1 und 0 spricht (strom da/strom nicht da), auch selbstredend. Aber diese Funktionen von deinem Link passen da irgendwie nicht rein. Ich kriege nicht mal ansatzweise eine Idee, wo ich dort die bits reinklatsche und dann noch ein Bild bekomme.

Wichtige Info nebenbei: Die Größe des Bildes ist in den Bildinformationen enthalten d.h. sie werden nicht von mir vorgegeben.
Die oben verwendeten Klassen benötigen immer eine fixe fest vorgegebene Größe, weswegen das wohl nicht funktionieren wird :/...

Andere Ideen?

@deeothroat
Java: 
	protected void saveImage(String imageUrl, String destinationFile) throws IOException {
		LinkedList<String> bytes = new LinkedList<String>();
		String[] tbytes = new String[16];
		selenium.open(imageUrl);
		elmnt = driver.findElement(By.xpath("/html/body/pre"));
		String convert = elmnt.getText();
		String textfile = "C:\\text.txt";
		File f = new File(textfile);
		if(!f.exists()) {
			f.createNewFile();
		}
		try {
			BufferedWriter out = new BufferedWriter(new FileWriter(textfile));
			out.write(convert);
			out.close();
			BufferedReader in = new BufferedReader(new FileReader(textfile));
			
			String zeile = "";
			while ((zeile = in.readLine()) != null) {
				tbytes = zeile.substring(11,73).split("  ");
				for(String tbyte : tbytes) {
					bytes.add(tbyte);
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		tbytes = new String[bytes.size()];
		for(int i = 0; i<bytes.size(); i++) {
			tbytes[i] = bytes.get(i).trim();
			
		}
		
		StringBuilder sb = new StringBuilder();
		for (String a : tbytes ) {
			  int c = Integer.parseInt(a,16);
			  char chr = (char)c;
			  sb.append(chr);
		}
		
		try {
			File f1 = new File("C:\\bild.jpg");
			if(!f1.exists()) {
				f1.createNewFile();
			}
			PrintStream ps = new PrintStream("C:\\bild.jpg");
			ps.print(sb.toString());
			ps.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

Wollte nicht gleich komplett euch mit Code zubomben, weils schon viel ist und für außenstehende nicht immer sofort ersichtlich.

Hier passiert eigentlich nur folgendes:
Ich rufe die Seite auf, hole mir per xpath den HTML-Content im feld "pre", speichere diesen zwischen in eine Textdatei.

Danach rufe ich die Textdatei wieder auf und hole mir zeile für zeile immer die zeichen zwischen 11 und 73 (also die 16-Hexawerte).

Das ganze wird gesplittet und jeder einzelne Hexa-doppel-wert wird in eine LinkedList eingebaut und danach noch in ein String-Array geschrieben.

Am ende des liedes wird ein Stringbuilder erzeugt, der für jeden String die oben schon beschriebene Funktion aufruft, also den doppelten Hexawert parst und umwandelt und anhängt.

EDIT: standen 2-3 unwichtige Sachen im Code, habe ihn mal gekürzt
 
Zuletzt bearbeitet:
deepthroat hat gesagt.:
Das ist bereits eine Interpretation / Darstellung der Daten.
Zum Vergrößern anklicken....
Da muss ich deepthroat Recht geben. Die Daten sind schon in Hex-Code umgewandelt wurden.
Als ich mir mal einen Proxyserver geschrieben habe, hab ich auch alle Daten auf Byte-Ebene empfangen und verarbeitet.
deepthroat hat gesagt.:
Wie bekommst du denn die Daten? Oder rufst du einfach Firefox auf, kopierst dir die Daten ins Clipboard? Zeig doch mal deinen Code.
Zum Vergrößern anklicken....
Das wäre in der Tat noch eine hilfreiche Information.
 
Ich habs gelöst! Folgendes ist mit dem obigen hexcode notwendig:

1. Alle Hexa-zeichen aneinanderhängen
Java: 
StringBuilder sb = new StringBuilder();
		for (String a : tbytes ) {
			/*
			  int c = Integer.parseInt(a,16);
			  char chr = (char)c;
			  sb.append(chr);
			  */
			sb.append(a);
		}
2. die hex-zeichen in bytes konvertieren:
Java: 
	public static byte[] hexToBytes(char[] hex) {
	 	int length = hex.length / 2;
	 	byte[] raw = new byte[length];
	 	for (int i = 0; i < length; i++) {
	 		int high = Character.digit(hex[i * 2], 16);
	 		int low = Character.digit(hex[i * 2 + 1], 16);
	 		int value = (high << 4) | low;
	 		if (value > 127)
	 			value -= 256;
	 		raw[i] = (byte) value;
	 	}
	  return raw;
	}
3. die Datei mithilfe von Bytes aufbauen :)
Java: 
	public static boolean erstelleDatei(byte[] datei, String pfad)
	{
		FileOutputStream outStream;
		if(datei.length <= 0)
			return false;
		try {
			outStream = new FileOutputStream(pfad);
			outStream.write(datei,0,datei.length);
			outStream.close();
		} catch (FileNotFoundException e) {
                        e.printStackTrace();
			return false;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

Danke trotzdem für euer Bemühen. Gerade die Aussage mit den "zu Bytes konvertieren" hat den richtigen Denkanstoß mit sich gebracht :)
Einen schönen Abend noch und Grüße,

fReAk
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück