Swing Buffered Image anzeigen

Bitte aktiviere JavaScript!
Ich möchte für das Programm zum testen ein kleines schwarz weiß Bild binär selbst codieren. Und das dann mit java decodieren und anzeigen, allerdings scheitert es daran, eine binäre Datei anzulegen und sie in java auszulesen und dabei auch nur binäre Zahlen zu erhalten.
Java:
import java.io.*;

public class ToBinary {

    public static void main(String[] args) throws Exception {
        if (args.length != 2) {
            System.err.println("Usage: java ToBinary <input-file> <output-file>");
            System.exit(1);
        }

        try(FileReader reader = new FileReader(args[0]);
                FileOutputStream fos = new FileOutputStream(args[1])) {
            int ch;
            byte b = 0;
            int bit = 0;
            while ((ch = reader.read()) != -1) {
                if (ch == '0' || ch == '1') {
                    b <<= 1;
                    if (ch == '1') {
                        b |= 1;
                    }
                    bit++;
                    if (bit == 8) {
                        bit = 0;
                        fos.write(b);
                    }
                }
            }
        }
    }
}
Dem Teil gibst Du nun eine Textdatei die so aussieht:
Code:
00000000 00000000 00000000
00000000 00011000 00000000
00000000 00111100 00000000
00000000 01111110 00000000
00000000 11011011 00000000
00000001 10011001 10000000
00000001 11011011 10000000
00000000 11011011 00000000
00000000 01111110 00000000
00000000 00111100 00000000
00000000 00011000 00000000
und das schreibt Dir den Spaß dann binär weg.
 
Rheinwerk Computing :: Java ist auch eine Insel - 20.6 Bilder
Da findet sich eigentlich alles. Lesen und schreiben von Bildern, verändern von Bildern über Graphics und auch Manipulation von einzelnen Pixeln.

Reicht das schon oder was fehlt Dir da noch?
Das ist nicht das Problem das funktioniert, ich will nur wissen wie ich die Daten aus einer binären Datei in mein Programm kriege.
Der Code soll so funktionieren.
Die ersten 15 Bit geben die Höhe des Bildes an und die zweiten die Breite des Bildes. Und alle Bits danach ob der Bildpunkt schwarz oder weiß ist, dabei steht eine 1 für weiß und eine 0 für schwarz.
Beispiel:
Höhe 4 Pixel: Breite 8 Pixel: Das Bild selbst. Das Bild würde also so aussehen:
000000000000100 000000000001000 11110000110000111111000011000011
Das "Bild" würde also in etwa so aussehen:

12328
Und diese Binärzahlen würde ich gerne in eine Datei schreiben und mit Java zu einem Bild verarbeiten.
 
Und wie soll ich die selbst bearbeiten? mit 0en und 1 en?
Was willst Du daran denn bearbeiten? Du hast doch eine Textdatei in eine binäre umgewandelt (btw: Du musst 8-Bit-Gruppen auffüllen)

Du schreibst als Text
Code:
00000000 00001000 00000000 00100011 11000011 00001111 11000011 00001100
In der Ausgabedatei werden dem entsprechend die Bytes 0, 8, 0, 35, 195, 15, 195, 12 geschrieben. Wenn Du Dir die Datei mit einem Hex-Editor ansiehst, wirst Du dem entsprechend 00 08 00 23 c3 0f c3 0c sehen.
 
Um das (ggf. für die Nachwelt) nochmal klar zu stellen: wenn Du folgende Eingabedatei verwendest:
Code:
00000000 00001000 00000000 00000100
00001111
00111100
00001111
00111100
Dann kannst Du mit dem Code aus Kommentar #21 daraus eine Binärdatei erstellen. Diese besteht dann aus den Bytes (Angabe hexadezimal) 00 08 00 04 0f 3c 0f 3c. Die ersten beiden Bytes geben die Breite, die nächsten beiden die Höhe des Bildes an. Der Rest sind die Bildinformationen (s/w-Pixel).

Eine solche Datei kannst Du z. B. mit folgender Klasse als BufferedImage einlesen:

Java:
import java.awt.*;
import java.awt.image.*;
import java.io.InputStream;
import java.io.IOException;
import java.util.Hashtable;

public class SimpleImageFormat {
    private static class Reader {
        private InputStream is;
        public Reader(InputStream is) { this.is = is; }

        public BufferedImage read() throws IOException {
            int width = readShort();
            int height = readShort();
            byte[] buf = new byte[width*height];
            is.read(buf);
            return createImage(width, height, buf);
        }

        private BufferedImage createImage(int w, int h, byte[] buf) {
            DataBufferByte db = new DataBufferByte(new byte[][]{buf}, buf.length);
            MultiPixelPackedSampleModel model = new MultiPixelPackedSampleModel(
                    DataBuffer.TYPE_BYTE, w, h, 1);
            WritableRaster raster = Raster.createWritableRaster(model, db, new Point(0,0));
            byte[] cols = {(byte) 0xff, 0};
            IndexColorModel cm = new IndexColorModel(1, 2, cols, cols, cols);
            return new BufferedImage(cm, raster, false, new Hashtable<>());
        }

        private int readShort() throws IOException {
            int msb = is.read();
            int lsb = is.read();
            return (msb << 8) | lsb;
        }
    }

    public BufferedImage read(InputStream is) throws IOException {
        return new Reader(is).read();
    }
}
(Den Writer überlasse ich Dir; natürlich kannst Du die Reader-Klasse auch rausziehen)
 
Ich frage mich gerade, wieso das allgemein irgendwer überhaupt jemals möchte
Im allgemeinen würde ich sagen das, das der Vorläufer des QrCodes ist. Das ist im Grunde eine Gridpane mit schwarz/weißen Flächen. Die Begrenzungspunkte werden mit den ersten zwei Werten berechnet und er Rest nach Bit gesetzt . In Methoden wird dann festgesetzt welche Bits in welcher Länge dann für welchen Wert stehen. Die ersten 8 Bits z.B. ergibt die Kategorie = 128 Kategorien. Kategorien könnte sein HTTP,HTTPS,IP,WWW. ,Port:,usw..........
 
Zuletzt bearbeitet von einem Moderator:
Oder eine Gridpanecelle (mit Transparenten dicken Rand) ist ein Byt mit 4 Balken die jeweils die Farbe weiß und schwarz annehmen.
 
Zuletzt bearbeitet:
sorry eine Randbemerkung zum Thema und deiner Frage......... Verwendung einer Umwandlung eines Binär Textes in farbige Kästchen und wer es braucht. Es schon benutzt. Denke mal anders..z.B. an Abarbeitung von Arztikellisten mit immer den selben Inhalt bis auf Artikelnummer und Preis. oder Geheimübermitlung von Firmendaten mittels Grafik und eigenem Entschlüssler.
 
NB: Für "geheim" nimmt man bekannte Algorithmen mit starken Schlüsseln und keine selbstgebauten Bildchen.
Wobei Daten in einem selbstgebauten Bildchen durchaus sicher sein können, siehe Steganographie.
Aber da zieht dann natürlich Dein Hinweis bezüglich bekannter Algorithmen und das ist nicht mehr die vom TE angeführte reine Konvertierung von Rohdaten in ein Bild ....
 
Java:
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;

public class Bilder {

	public static void longToImg(BufferedImage i, long l) {
		String h = String.format("%64s", Long.toBinaryString(l)).replace(' ', '0');
		System.out.println(h);
		int a = 0;
		int z = 1;
		for (int x = 0; x < i.getWidth(); x++) {
			for (int y = 0; y < i.getHeight(); y++) {
				if (z % 7 == 0) {
					int rgb = i.getRGB(x, y);
					if (h.charAt(a) == '0') {
						if (rgb % 2 != 0) {
							rgb++;
						}
					} else {
						if (rgb % 2 == 0) {
							rgb++;
						}
					}
					i.setRGB(x, y, rgb);
					a++;
					if (a == 64) {
						return;
					}
				}
				z++;
			}
		}
	}

	public static long longFromImg(BufferedImage i) {
		String h = "";
		int a = 0;
		int z = 1;
		for (int x = 0; x < i.getWidth(); x++) {
			for (int y = 0; y < i.getHeight(); y++) {
				if (z % 7 == 0) {
					int rgb = i.getRGB(x, y);
					if (rgb % 2 == 0) {
						h += "0";
					} else {
						h += "1";
					}
					a++;
					if (a == 64) {
						return Long.parseLong(h, 2);
					}
				}
				z++;
			}
		}
		return Long.parseLong(h, 2);
	}

	public static long longFromString(String s) {
		String h = "";
		for (char c : s.toCharArray()) {
			String r = Long.toBinaryString(c);
			if (r.length() < 8) {
				r = String.format("%8s", r).replace(' ', '0');
			} else {
				r = r.substring(r.length() - 8);
			}
			h += r;
		}
		return Long.parseLong(h, 2);
	}

	public static String longToString(long l) {
		String h = String.format("%64s", Long.toBinaryString(l)).replace(' ', '0');
		String s = "";
		for (int i = 0; i < 8; i++) {
			s += (char) Long.parseLong(h.substring(i * 8, i * 8 + 8), 2);
		}
		return s;
	}

	public static void main(String[] args) throws Exception {
		BufferedImage i = ImageIO.read(new File("x.png"));
		longToImg(i, longFromString("        "));
		ImageIO.write(i, "PNG", new File("y.png"));
		Thread.sleep(1000);
		i = ImageIO.read(new File("y.png"));
		System.out.println(longToString(longFromImg(i)));
	}

}

Ihr könnte ja mal schauen welches Wort (8 Buchstaben) sich hinter diesem Bildchen verbirgt (man denke an jedes 7. Ü-Ei....):

1234.png
 
Aber tatsächlich, diese Bildchen sind derzeit ein riesiges Problem in online Spielen, bei denen es die Möglichkeit gibt, Graffitis an Wände zu sprühen, da somit verbotene Symbole oder Texte ausgetauscht werden können... Aufgrunddessen ist das in manchen online Spielen nicht mehr erlaubt.

Jetzt könnten wir darüber philosophieren, welche Meinung ihr dazu habt...
 
Passende Stellenanzeigen aus deiner Region:

Oben