Konvertiere jede Datei in PNG in Java

Question

Ich möchte jede Datei in ein PNG konvertieren und auch den Prozess umkehren, alles in Java.

Ich möchte eine int-RGB-Form für das Bild verwenden und Bytes aus der Datei als Byte im RGB-Integer haben. Dadurch sollte ein Bild erstellt werden.

Ich habe es geschafft, dies zu tun, indem ich nur die Bytes in der roten Farbe gespeichert habe, aber ich kann nicht herausfinden, wie ich auch Grün und Blau verwenden kann.

Das ist der Code, den ich im Moment benutze, der nur Rot verwendet und gut funktioniert:

public static void fileToImage(String sourceFile, String imageFile) throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream(sourceFile));
    int size = ((int) Math.sqrt(dis.available())) + 2;
    BufferedImage image = new BufferedImage(size,size, BufferedImage.TYPE_INT_RGB);
    for (int y = 0; y < size; y++) {
        for (int x = 0; x < size; x++) {
            int red = dis.read(); // Ich verwende nur Rot
            int green = 0; // Standardwert
            int blue = 0; // Standardwert
            int rgb = (0xFF << 24) | ((red & 0xFF) << 16) | ((green & 0xFF) << 8) | (blue & 0xFF);
            image.setRGB(x, y, rgb);
        }
    }
    dis.close();
    ImageIO.write(image, "png", new File(imageFile));
}

public static void imageToFile(String imageFile, String outputFile) throws IOException {
    BufferedImage image = ImageIO.read(new File(imageFile));
    DataOutputStream dos = new DataOutputStream(new FileOutputStream(outputFile));
    for (int y = 0; y < image.getHeight(); y++) {
        for (int x = 0; x < image.getWidth(); x++) {
            int rgb = image.getRGB(x, y);
            int red = (rgb >> 16) & 0xFF;
            int green = (rgb >> 8) & 0xFF;
            int blue = rgb & 0xFF;
            dos.write(red); // Ich verwende nur Rot
        }
    }
    dos.close();
}

EDIT: Okay, ich habe den Code modifiziert, hier ist er:

public static void fileToImage(String sourceFile, String imageFile) throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream(sourceFile));
    int size = ((int) Math.sqrt(dis.available())) + 2;
    BufferedImage image = new BufferedImage(size,size, BufferedImage.TYPE_INT_RGB);
    for (int y = 0; y < size; y++) {
        for (int x = 0; x < size; x++) {
            int red = dis.read();
            int green = dis.read();
            int blue = dis.read();
            int rgb = (0xFF << 24) | ((red & 0xFF) << 16) | ((green & 0xFF) << 8) | (blue & 0xFF);
            image.setRGB(x, y, rgb);
        }
    }
    dis.close();
    ImageIO.write(image, "png", new File(imageFile));
}

public static void imageToFile(String imageFile, String outputFile) throws IOException {
    BufferedImage image = ImageIO.read(new File(imageFile));
    DataOutputStream dos = new DataOutputStream(new FileOutputStream(outputFile));
    for (int y = 0; y < image.getHeight(); y++) {
        for (int x = 0; x < image.getWidth(); x++) {
            int rgb = image.getRGB(x, y);
            int red = (rgb >> 16) & 0xFF;
            int green = (rgb >> 8) & 0xFF;
            int blue = rgb & 0xFF;
            dos.write(red);
            dos.write(green);
            dos.write(blue);
        }
    }
    dos.close();
}

Dies "funktioniert", aber nicht ganz wie erwartet. Es gibt viel schwarzen Raum im erzeugten PNG, weil ich glaube, dass die "Größe" des Bildes falsch ist. Deshalb wird das PNG beim Zurückübersetzen in die Originaldatei viel größer als ursprünglich.

EDIT: Das Problem, das ich jetzt habe, ist folgendes: Wenn ich z.B. eine Textdatei mit folgendem Inhalt in ein PNG umwandle, indem ich die fileToImage-Methode verwende: Hallo Welt! Dann benutze ich imageToFile, um es zurückzuwandeln, ist die Ausgabe: Hallo Welt!SSSSSSSSSSSSSSS (S steht für "Leerzeichen", es gibt 15)

EDIT: Ich kann das immer noch nicht herausfinden. Hier ist, was ich verwende:

private static final int NAN = -1;

private static int readByte(DataInputStream dis) throws IOException {
    int b;
    try {
        b = dis.readByte();
    } catch (EOFException e) {
        b = NAN;
    }
    return b;
}

public static void fileToImage(String sourceFile, String imageFile) throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream(sourceFile));
    int size = ((int) Math.sqrt(dis.available())) + 2;
    BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
    for (int y = 0; y < size; y++) {
        boolean finished = false;
        for (int x = 0; x < size; x++) {
            int alpha = 3;
            int red = readByte(dis);
            int green = readByte(dis);
            int blue = readByte(dis);
            if (red == NAN) {
                alpha--;
                red = 0;
            }
            if (green == NAN) {
                alpha--;
                green = 0;
            }
            if (blue == NAN) {
                alpha--;
                blue = 0;
            }
            int rgb = ((alpha & 0xFF) << 24) | ((red & 0xFF) << 16) | ((green & 0xFF) << 8) | (blue & 0xFF);
            image.setRGB(x, y, rgb);
            if (alpha < 3) {
                finished = true;
                break;
            }
        }
        if (finished) break;
    }
    dis.close();
    ImageIO.write(image, "png", new File(imageFile));
}

public static void imageToFile(String imageFile, String outputFile) throws IOException {
    BufferedImage image = ImageIO.read(new File(imageFile));
    DataOutputStream dos = new DataOutputStream(new FileOutputStream(outputFile));
    for (int y = 0; y < image.getHeight(); y++) {
        boolean finished = false;
        for (int x = 0; x < image.getWidth(); x++) {
            int rgb = image.getRGB(x, y);
            int alpha = (rgb >> 24) & 0xFF;
            int red = (rgb >> 16) & 0xFF;
            int green = (rgb >> 8) & 0xFF;
            int blue = rgb & 0xFF;
            if (alpha == 0) {
                finished = true;
                break;
            }
            if (alpha >= 1) dos.write(red);
            if (alpha >= 2) dos.write(green);
            if (alpha == 3) dos.write(blue);
        }
        if (finished) break;
    }
    dos.close();
}

Answer 1

Ich denke, du musst nur die inneren Schleifen leicht anpassen. Eine kleine Hilfsmethode wird diese Sache einfacher zu benutzen machen, obwohl ich sicher bin, dass meine Skizze ein wenig hässlich ist:

int myReadByte(DataInputStream dis) {
    int b;
    try {
        b = dis.readByte():
    } catch (EOFException e) {
        b = 0;
    }
    return b;
}

Jetzt mit diesem Helfer...

for (int x = 0; x < size; x++) {
        int red = myReadByte(dis);
        int green = myReadByte(dis);
        int blue = myReadByte(dis);
        int rgb = (0xFF << 24) | ((red & 0xFF) << 16) | ((green & 0xFF) << 8) | (blue & 0xFF);
        image.setRGB(x, y, rgb);

und

for (int x = 0; x < image.getWidth(); x++) {
        int rgb = image.getRGB(x, y);
        int red = (rgb >> 16) & 0xFF;
        int green = (rgb >> 8) & 0xFF;
        int blue = rgb & 0xFF;
        dos.write(red);
        dos.write(green);
        dos.write(blue);
    }

Answer 2

Es scheint, dass Ihr Code aufeinander folgende 3 Bytes in einen Pixel umwandelt. Aufgrund dessen erhalten Sie nur 1/3 der Datei mit Farbe und die restlichen 2/3 sind leer.

Um das zu beheben, teilen Sie einfach die Dateigröße durch 3.

int size = ((int) Math.sqrt(dis.available()/3)) + 2;