Bilder speichern

[Kerberus]

Ich speichere Bilder mit dem Packet javax.imageio.
Leider habe ich festgestellt, dass wenn ich ein Bild speichere, dass ich dann Bildverluste habe. Gibt es eine Möglichkeit Bilder zu speichern ohne, dass ich nur den geringsten Qualitätsverlust habe? Dies wäre sehr wichtig für micht, da ich Grafiken erstellen muss, die auf den Pixel genau sind. Kennt jemand eine Möglichkeit, dies zu realisieren?

 

[Beni]

Der write-Methode von ImageIO kannst du als Format "png" übergeben. Das PNG ("Portable Network Graphics" oder so ähnlich) wird komprimiert, aber ohne Datenverlust.

 

[Kerberus]

Nun, ich wende die Methode write() an:

File file = new File(title);
ImageIO.write(buffImage, "png", file);

Allerdings, wenn ich zum Beispiel auf einem 4*4 Pixel grossen Bild zeichne, einen schwarzen, ein Pixel breiten Strich, dann einen ein Pixel breiten weissen, dann wieder einen schwarzen und wieder einen weissen, so erhalte ich immer ein Bild, das grau ist. Ist das normal?
(Es ist wichtig, dass ich ein Pixel genaue Graphiken zeichnen kann, ohne, dass mir Java die Farben vermischst.)

 

[Beni]

Das Problem hatte ich noch nie.

Kannst du mal einen Codeteil posten, der das Problem herstellt? Würde das ganz gerne mal ausprobieren, und bin zu faul selbst ein Beispiel zu schreiben (das dann möglicherweise doch richtig funktioniert).

 

[Kerberus]

Also, meine erste Klasse, der ImageExporter, definiert eigentlich einige Funktionen, die ich später für mein Programm brauche. Die Klasse Test soll nur die Funktionalität von ImageExporter überprüfen.

ImageExporter:

import java.awt.image.*;
import java.awt.*;
import java.io.*;
import javax.imageio.*;

public class ImageExporter
{
    public ImageExporter()
    {
    }

    public boolean export(BufferedImage buffImage, String title)
    {
        
        title = title + ".png";
        
        try
        {
            File file = new File(title);
            ImageIO.write(buffImage, "png", file);
        }
        catch(IOException e)
        {
            return false;
        }
        
        return true;
    }      
    
    public BufferedImage advancedScale(BufferedImage buffImage, int scale_x, int scale_y, int type_of_scale)
    {
        BufferedImage internBufferedImage = new BufferedImage(scale_x, scale_y, BufferedImage.TYPE_INT_RGB);
        
        Image internScaleImage = buffImage.getScaledInstance(scale_x, scale_y, type_of_scale);
        
        Graphics2D internGraphics2D = internBufferedImage.createGraphics();
        
        internGraphics2D.drawImage(internScaleImage,0,0,new Frame());
        internGraphics2D.dispose();
        
        return internBufferedImage;
    }
    
    public BufferedImage createDiffractionPattern(BufferedImage buffImage, int anzahl_in_x, int anzahl_in_y, int scale_x, int scale_y, int type_of_scale)
    {
        BufferedImage pattern = new BufferedImage((anzahl_in_x * scale_x), (anzahl_in_y * scale_y), BufferedImage.TYPE_INT_RGB);
        
        BufferedImage scaledVersion = this.advancedScale(buffImage, scale_x, scale_y, type_of_scale);
        
        Graphics2D d = pattern.createGraphics();
        
        for(int x = 0; x < (anzahl_in_x * scale_x); x = x + scale_x)
        {
            for(int y = 0; y < (anzahl_in_y * scale_y); y = y + scale_y)
            {
                d.drawImage(scaledVersion, x, y, new Frame());
            }
        }
        
        d.dispose();
        
        return pattern;
    }
}

Test:

import java.awt.image.*;
import java.awt.geom.*;
import java.awt.*;
import java.io.*;

public class Test
{
    public static void main(String[] args)
    {
        BufferedImage img = new BufferedImage(4, 4, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = img.createGraphics();
        
        g.setColor(new Color(255,255,255));
        g.fillRect(0,0,4,4);
        
        g.setColor(new Color(0,0,0));
        g.fillRect(0,0,1,4);
        g.fillRect(3,0,1,4);
        
        g.dispose();
 
        ImageExporter exporter = new ImageExporter();
        
        BufferedImage pattern = exporter.createDiffractionPattern(img, 8, 8, 1, 1, Image.SCALE_SMOOTH);
        
        boolean erfolgt = exporter.export(pattern, "test");
        
        if(erfolgt)
        {
            System.out.println("Export abgeschlossen");
        }
        else
        {
            System.out.println("Fehler");
        }
    }
}

Die Methode createDiffractionPattern parketiert eine Fläche, respektive erstellt diese. Später drucke ich diese dann aus und verwende sie in einem physikalischen Experiment.

(Ich schreibe dieses Programm als Teil meiner Maturarbeit. Ich habe nun schon einige Testläufe mit dem Code gemacht und nie die erwünschten Ergebnisse erzielt und weiss einfach nicht, wo sich der Fehler befinden könnte. Hoffentlich entdeckst du ihn, sonst hab ich ein kleines Problem ;-) )

Wünsche noch einen schönen Abend.
Sir MacKerberus

 

[Beni]

Das Bild wird richtig gespeichert, es wird aber grau gezeichnet.

        BufferedImage pattern = exporter.createDiffractionPattern(img, 80, 80, 3, 3, Image.SCALE_SMOOTH);
       
        JFrame frame = new JFrame();
        JLabel label = new JLabel();
        label.setIcon( new ImageIcon( pattern ) );
        frame.getContentPane().add( label );
        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        frame.setBounds( 200, 200, 200, 200 );
        frame.setVisible( true );

Diese Zeile ist interessant, je grösser man den 3. und den 4. Parameter macht, desto mehr sieht man von den Linien. Insbesondere müssen die Werte offenbar >= 3 sein.

exporter.createDiffractionPattern(img, 80, 80, 3, 3, Image.SCALE_SMOOTH);

Beni



P.S. jedes mal ein neues Frame zu erstellen ist ein bisschen übertrieben.

d.drawImage(scaledVersion, x, y, new Frame());

Viel Ressourcenschonender ist diese Version:

        Graphics2D d = pattern.createGraphics();
       
        ImageObserver obs = new ImageObserver(){
			public boolean imageUpdate( Image img, int infoflags, int x, int y,
					int width, int height ) {
				return false;
			}
        };
        
        for(int x = 0; x < (anzahl_in_x * scale_x); x = x + scale_x)
        {
            for(int y = 0; y < (anzahl_in_y * scale_y); y = y + scale_y)
            {
                d.drawImage(scaledVersion, x, y, obs);
            }
        }

 

[Kerberus]

Danke, für diese Version.
Könnte es sein, dass die Formate png und jpg eine Art Unschärfe besitzen?

Gibt es eigentlich auch eine Möglichkeit im .tif Format zu speichern. Soweit ich weiss ist das so ziemlich das einzige das keine Komprimierung hat, sofern man diese nicht wünscht.

Könnte mir nur noch vorstellen, dass ScaleSmooth diesen Fehler auslöst. Werde den Code mal abändern. Mal sehen, was dabei rauskommt.

 

[Beni]

Könnte es sein, dass die Formate png und jpg eine Art Unschärfe besitzen?

jpg: ja
png: nein

tif: musst du ausprobieren, sollte aber auch gehen.

 

[Kerberus]

Ich stosse immer wieder auf verblüfende Sachen.
Habe mir mal Jimi gesogen und "installiert". Damit sollte ich nun theoretisch Bilder in praktisch allen Formaten speichern können. Wenn ich nun ein Bild öffne, das ich mit Photoshop erstellt habe und das eine Auflösung von 300 DPI besitzt, und es dann wieder speichere, zum Beispiel als JPG, so hat das Bild danach eine Auflösung von 72 DPI.

 

[Kerberus]

@Beni: Habe nun meinen ImageExporter neu geschrieben unter der Verwendung von Jimi. Nun treten keine Fehler mehr auf und es ist auch egal, wie weit ich runter skaliere.
Das mit der Unschärfe konnte ich auch lösen. Ist mehr ein mathematisches als technisches Problem.