# BufferedImage Invertieren



## headnut (31. Aug 2011)

Guten Tag

Ich stehe wieder an einem Problem an. Ich müsste von einem Bild alle Farben Invertieren können.

Follgendes eigentlich einfaches Beipiel fand ich:


```
public BufferedImage invert(BufferedImage image) {
 
    	int w = image.getWidth(), h = image.getHeight();
    	
    	BufferedImage bearbeiten = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
    	
    	for (int x = 0; x < w; x++) {
    		for (int y = 0; y < h; y++) {
    			int neu = 255 + 256*255 + 256*256*255 - image.getRGB(x, y);
    			
    			bearbeiten.setRGB(x, y, neu);
    			
    			
    		}
    	}
    	return bearbeiten;
    }
```

Jedoch verändert dies nichts am Bild :-(


----------



## SlaterB (31. Aug 2011)

wie stellst du denn fest, ob sich etwas am Bild ändert?
vermutlich meinst du anderen nicht geposteten Code drumherum, 
und wer kann schon sicher sagen, dass der Fehler nicht dort liegt?


----------



## headnut (31. Aug 2011)

Ich habe bereits kontraständerung, helligkeitsänderung und Gammaverstellung die funktioniert!

Nun habe ich die Invertierung noch reingesetzt und das Bild nicht invertiert! sonst würde es dies anzeigen!


----------



## r.w. (31. Aug 2011)

headnut hat gesagt.:


> Jedoch verändert dies nichts am Bild :-(



Die Funktion verändert nicht das übergebene Bild, 
sondern liefert ein invertiertes Bild zurück.

Der Aufruf müsste also ähnlich wie der folgende Code-Ausschnitt lauten:

```
...
         BufferedImage bi = ImageIO.read(new File("dein.jpg"));
         BufferedImage destImage = invert(bi);
...
```

Bei funktioniert sie so.

VG ROlf


----------



## headnut (31. Aug 2011)

Tatsächlich bei mir funktiert sie auch...

Dann muss ich anders weitig schauen, werd mich wahrscheinlich nochma melden

Danke schonmal


----------



## headnut (31. Aug 2011)

Ich komme nicht weiter, werde jetzt mal grob den Code posten:

Hier lade ich das Bild von der Festplatte:


```
public void loadImage() throws IOException {
    	
		speicherbares = ImageIO.read(scannerBild);
        MediaTracker mt1 = new MediaTracker(this);
        mt1.addImage(speicherbares, 1);
        try {
            mt1.waitForAll();
        } catch (Exception e) {
            System.out.println("Exception while loading.");
        }
 
        if (speicherbares.getWidth(this) == -1) {
            System.out.println("No jpg file");
            System.exit(0);
        }
        
        w = speicherbares.getWidth(this);
        h = speicherbares.getHeight(this);
        
        System.out.println("w: " + w + ", " + h);
        
        mt1 = null;
    }
```

Hier werden die BufferedImages erzeugt um mit dem Bild arbeiten zu können:


```
public void createBufferedImages() {
    	
    	biSrc = new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
    	
        big = biSrc.createGraphics();
        big.drawImage(speicherbares, 0, 0, this);

        biDest = new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
        bi = biSrc;
        
    }
```

Das Bild biDest übergebe ich danach meiner Methode und am schluss wird ein rescale durchgeführt und das Bild sollte invertiert angezeigt werden. Nach der gleichen Methode mach ich dies bereits mit einer Gammaverstellung und dort gehts!


```
public BufferedImage invert(BufferedImage image) {
 
    	int w = image.getWidth(), h = image.getHeight();
    	
    	BufferedImage bearbeiten = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
    	
    	for (int x = 0; x < w; x++) {
    		for (int y = 0; y < h; y++) {
    			int neu = 255 + 256*255 + 256*256*255 - image.getRGB(x, y);
    			
    			bearbeiten.setRGB(x, y, neu);

    		}
    	}
    	return bearbeiten;
    }
```

Danke nochmal


----------



## SlaterB (31. Aug 2011)

mit 99 Postings hast du noch nicht den überall stehenden dicken roten Hinweise [ JAVA ]-Tags (statt [ CODE ]-Tags) gesehen 
oder willst du es allen anderen bewußt schwerer machen?

dein restliches Posting ist auch eine Kunst aus Wiederholung und nichts-sagendem (neutrale Kritik), 

der Lade-Code oder die Erzeugung von mehreren BufferedImages bringt nichts, außer mich an einem alten Thread dazu zu erinnern,
die so absolut naheliegende Gelegenheit, die Codestelle mit dem Aufruf der invert()-Methode zu posten, läßt du ungenutzt verstreichen,
zum zweiten Mal erwähnst du du auch dass andere Dinge gehen, ohne wieder dazu irgendwas brauchbares wie Code zu posten um anderen die Möglichkeit zu geben zu erkennen wie du 'normalerweise' vorgehst und dann Abweichungen festzustellen

edit:
wahrscheinlich ist es nach wie vor ein Problem der Zuweisung, vielleicht hast du von r.w. bisschen was übernommen, 
änderst aber z.B. nur eine lokale Variable in einer Zwischenebene, während eines der Klassenattribute weiter auf das alte ungeänderte Bild zeigt


----------



## Michael... (31. Aug 2011)

headnut hat gesagt.:


> Das Bild biDest übergebe ich danach meiner Methode und am schluss wird ein rescale durchgeführt und das Bild sollte invertiert angezeigt werden.


Schwer zu sagen anhand des geposten Codes, aber zunächst schaut es so aus, dass biDest ein "leeres" Bild ist - zumindest ist hier nirgends zu sehen wie es befüllt wird.


----------



## r.w. (31. Aug 2011)

Der interessanteste Code-Teil fehlt leider.
Nämlich der Aufruf von invert() und eventuell noch einer der funktionierenden Methoden.


----------



## headnut (31. Aug 2011)

Zuerst mal, tut mir leid, ich habe wirklich 100 positings gebraucht um den grossen roten Hinweis zu sehen, tut mir echt leid!

Das buffereImage biDest ist tatsächlich leer, nur begreif ich nicht ganz wiso, ich poste jetzt mal meinen Code, auf die gefahr hin einen nächsten ZS zu bekommen

Meine Fragen nun: 

- Die biDest und biSrc werden erstellt und benötigt um Helligkeit und Kontrast zu ändern, ist das als Puffer gedacht oder wiso ist dort nicht das korrekte bild drin?




```
class DisplayPanel extends JPanel {
	
	//Image displayImage = null;
	BufferedImage speicherbares, biSrc, biDest, bi, temp;
    Graphics2D big;
    RescaleOp rescale;
    RescaleOp rescale2;
    float kontrastFaktor; //1.0f;
    float helligkeitOffset; //10;
    float gammaFaktor; //1.0f;
    boolean helligkeitNegi, kontrastPosi, gammaButton;
    int w;
    int h;
    
	// Pfad zum Desktop
	static String DB = "C:/Dokumente und Einstellungen/scanset.bachmann/DB";
	// Bild nach dem Scannen
	File scannerBild = new File(DB + "/Kamera/image.jpg");
	// Bild nach der Berabeitung vor dem Auswerten
	static File nachBearbeiten = new File(DB + "/Kamera Bild/imageB.bmp");

    DisplayPanel() throws IOException {
        setBackground(Color.black); 
        loadImage();
        
        setSize(speicherbares.getWidth(this),
                speicherbares.getWidth(this));
        createBufferedImages();
    }
    
	public void setPreferredSize(int i, int j) {
		setSize(i, j);
		
	}

	public void loadImage() throws IOException {
    	
		speicherbares = ImageIO.read(scannerBild);
        MediaTracker mt1 = new MediaTracker(this);
        mt1.addImage(speicherbares, 1);
        try {
            mt1.waitForAll();
        } catch (Exception e) {
            System.out.println("Exception while loading.");
        }
 
        if (speicherbares.getWidth(this) == -1) {
            System.out.println("No jpg file");          
        }
        
        w = speicherbares.getWidth(this);
        h = speicherbares.getHeight(this);
        
        System.out.println("w: " + w + ", " + h);
        
        mt1 = null;
    }
	
	public void wertUebergabe(float helligkeit, float kontrast, float gamma) {
		helligkeitOffset = helligkeit;
		kontrastFaktor = kontrast;
		gammaFaktor = gamma;
	}

    public void createBufferedImages() {
   	
    	biSrc = new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
    	
        big = biSrc.createGraphics();
        big.drawImage(speicherbares, 0, 0, this);

        biDest = new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
        
        bi = biSrc;
        
    }

    public float changeHelligkeit() {
    	if (helligkeitNegi) {
            if (helligkeitOffset < 255.0)
               helligkeitOffset = helligkeitOffset+5.0f;
        }
        else {
            if (helligkeitOffset > -255.0)
               helligkeitOffset = helligkeitOffset-5.0f;
        }
        return Math.round(helligkeitOffset);
    }

    public float changeKontrast() {
    	if (kontrastPosi) {
            if (kontrastFaktor < 2.0)
                kontrastFaktor = kontrastFaktor+0.1f;
        }
        else {
            if (kontrastFaktor > -2.0)
                kontrastFaktor = kontrastFaktor-0.1f;
        }
        return Math.round(kontrastFaktor);
    }
    
    public float changeGamma() {
    	if (gammaButton) {
            if (gammaFaktor < 500.0)
                gammaFaktor = gammaFaktor-0.01f;
        }
        else {
            if (gammaFaktor > -500.0)
                gammaFaktor = gammaFaktor+0.01f;
        }
        return Math.round(gammaFaktor);
    }
    
    public void BildInvertieren(){
    	temp = rescale2();
    	
    	biDest = invert(speicherbares);
    	
    	bi = biDest;
    	
    	System.out.println("Bild inertiren");
    }
    
    public void bildAktual() {
        // aufruf Methode
        temp = rescale2();
        biDest = setGamma(temp, gammaFaktor);
        bi = biDest;
    }
     
    public BufferedImage rescale2() {
    	rescale2 = new RescaleOp(kontrastFaktor, helligkeitOffset, null);
        rescale2.filter(biSrc, biDest);
        return biDest;
       
    }

    public void update(Graphics g) {
        g.clearRect(0, 0, getWidth(), getHeight());
        paintComponent(g);
    }

    public void paintComponent(Graphics g) {
        super.paintComponents(g);
        Graphics2D g2D = (Graphics2D) g;

        g2D.drawImage(bi, 0, 0, this);
    }
    
    public void speichern() throws IOException {
    	
    	BufferedImage output = new BufferedImage(bi.getWidth(), bi.getHeight(), BufferedImage.TYPE_BYTE_INDEXED);
    	output.getGraphics().drawImage(bi, 0, 0, null);
    	
    	ImageIO.write(output, "BMP", nachBearbeiten);
    	
    	speicherbares = null;
    	//output = null;
    	
    	biSrc = null; 
    	biDest = null; 
    	bi = null;
    	temp = null;
    	big = null;
    	
    	System.gc();
    	
    	// Aufruf der Eyesight
    	DatenAustEyeSight.ablauf();
    }
    
    public BufferedImage setGamma(BufferedImage image, double gammaFactor)
    {
        double gammaPotency = 1.0 / gammaFactor;
        int w = image.getWidth(), h = image.getHeight();
 
        for (int x = 0; x < w; x++)
        {
            for (int y = 0; y < h; y++)
            {
                int argb = image.getRGB(x, y);
                int nargb = ((argb >> 24) & 0xFF) << 24; // set alpha
                for (int i = 0; i < 24; i += 8)
                {
                    int value = (int) (Math.pow((argb >> i) & 0xFF, gammaPotency));
                    nargb += (int) ((value > 0xFF) ? (0xFF << i) : (value << i));
                }
                image.setRGB(x, y, nargb);
            }
        }
 
        return image;
    }
    
    public BufferedImage invert(BufferedImage image) {
 
    	int w = image.getWidth(), h = image.getHeight();
    	
    	BufferedImage bearbeiten = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
    	
    	for (int x = 0; x < w; x++) {
    		for (int y = 0; y < h; y++) {
    			int neu = 255 + 256*255 + 256*256*255 - image.getRGB(x, y);
    			
    			bearbeiten.setRGB(x, y, neu);

    		}
    	}
    	return bearbeiten;
    }

}
```


----------



## headnut (31. Aug 2011)

Doppel post wiso auch  immer sorry


----------



## SlaterB (31. Aug 2011)

ein Fehler ist nicht zu erkennen, jedenfalls nicht im geposteten Code,
wie immer vielleicht noch weiter außen drumherum, es ist ja kein vollständiges Programm

hier dagegen ein vollständiges, mit einem direkt im Programm erzeugten Test-Bild, nach 2 sec. wird automatisch invertiert,
funktioniert


```
public class TestGUI
    extends JFrame
{
    public TestGUI()
        throws Exception
    {
        DisplayPanel p = new DisplayPanel();

        add(p);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(500, 300);
        setVisible(true);

        Thread.sleep(2000);
        p.BildInvertieren();
        p.repaint();
    }

    public static void main(String[] args)
        throws Exception
    {
        new TestGUI();
    }
}


class DisplayPanel
    extends JPanel
{

    // Image displayImage = null;
    BufferedImage speicherbares, biSrc, biDest, bi, temp;
    Graphics2D big;
    RescaleOp rescale;
    RescaleOp rescale2;
    float kontrastFaktor; // 1.0f;
    float helligkeitOffset; // 10;
    float gammaFaktor; // 1.0f;
    boolean helligkeitNegi, kontrastPosi, gammaButton;
    int w;
    int h;

    // Pfad zum Desktop
    static String DB = "C:/Dokumente und Einstellungen/scanset.bachmann/DB";
    // Bild nach dem Scannen
    File scannerBild = new File(DB + "/Kamera/image.jpg");
    // Bild nach der Berabeitung vor dem Auswerten
    static File nachBearbeiten = new File(DB + "/Kamera Bild/imageB.bmp");

    DisplayPanel()
        throws IOException
    {
        setBackground(Color.black);
        loadImage();

        setSize(speicherbares.getWidth(this), speicherbares.getWidth(this));
        createBufferedImages();
    }

    public void setPreferredSize(int i, int j)
    {
        setSize(i, j);
    }

    public void loadImage()
        throws IOException
    {
        final BufferedImage a = new BufferedImage(50, 100, BufferedImage.TYPE_INT_RGB);
        for (int i = 0; i < a.getWidth(); i++)
        {
            for (int j = 0; j < a.getHeight(); j++)
            {
                a.setRGB(i, j, (i + j) * 2);
            }
        }
        speicherbares = a;

        // speicherbares = ImageIO.read(scannerBild);
        // MediaTracker mt1 = new MediaTracker(this);
        // mt1.addImage(speicherbares, 1);
        // try
        // {
        // mt1.waitForAll();
        // }
        // catch (Exception e)
        // {
        // System.out.println("Exception while loading.");
        // }
        //
        // if (speicherbares.getWidth(this) == -1)
        // {
        // System.out.println("No jpg file");
        // }

        w = speicherbares.getWidth(this);
        h = speicherbares.getHeight(this);

        System.out.println("w: " + w + ", " + h);

        // mt1 = null;
    }

    public void wertUebergabe(float helligkeit, float kontrast, float gamma)
    {
        helligkeitOffset = helligkeit;
        kontrastFaktor = kontrast;
        gammaFaktor = gamma;
    }

    public void createBufferedImages()
    {

        biSrc = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);

        big = biSrc.createGraphics();
        big.drawImage(speicherbares, 0, 0, this);

        biDest = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);

        bi = biSrc;

    }

    public float changeHelligkeit()
    {
        if (helligkeitNegi)
        {
            if (helligkeitOffset < 255.0) helligkeitOffset = helligkeitOffset + 5.0f;
        }
        else
        {
            if (helligkeitOffset > -255.0) helligkeitOffset = helligkeitOffset - 5.0f;
        }
        return Math.round(helligkeitOffset);
    }

    public float changeKontrast()
    {
        if (kontrastPosi)
        {
            if (kontrastFaktor < 2.0) kontrastFaktor = kontrastFaktor + 0.1f;
        }
        else
        {
            if (kontrastFaktor > -2.0) kontrastFaktor = kontrastFaktor - 0.1f;
        }
        return Math.round(kontrastFaktor);
    }

    public float changeGamma()
    {
        if (gammaButton)
        {
            if (gammaFaktor < 500.0) gammaFaktor = gammaFaktor - 0.01f;
        }
        else
        {
            if (gammaFaktor > -500.0) gammaFaktor = gammaFaktor + 0.01f;
        }
        return Math.round(gammaFaktor);
    }

    public void BildInvertieren()
    {
        temp = rescale2();
        biDest = invert(speicherbares);
        bi = biDest;
        System.out.println("Bild inertiren");
    }

    public void bildAktual()
    {
        // aufruf Methode
        temp = rescale2();
        biDest = setGamma(temp, gammaFaktor);
        bi = biDest;
    }

    public BufferedImage rescale2()
    {
        rescale2 = new RescaleOp(kontrastFaktor, helligkeitOffset, null);
        rescale2.filter(biSrc, biDest);
        return biDest;
    }

    public void update(Graphics g)
    {
        g.clearRect(0, 0, getWidth(), getHeight());
        paintComponent(g);
    }

    public void paintComponent(Graphics g)
    {
        super.paintComponents(g);
        Graphics2D g2D = (Graphics2D)g;

        g2D.drawImage(bi, 0, 0, this);
    }

    public void speichern()
        throws IOException
    {
        BufferedImage output = new BufferedImage(bi.getWidth(), bi.getHeight(), BufferedImage.TYPE_BYTE_INDEXED);
        output.getGraphics().drawImage(bi, 0, 0, null);

        ImageIO.write(output, "BMP", nachBearbeiten);

        speicherbares = null;
        // output = null;

        biSrc = null;
        biDest = null;
        bi = null;
        temp = null;
        big = null;

        System.gc();

        // Aufruf der Eyesight
        // DatenAustEyeSight.ablauf();
    }

    public BufferedImage setGamma(BufferedImage image, double gammaFactor)
    {
        double gammaPotency = 1.0 / gammaFactor;
        int w = image.getWidth(), h = image.getHeight();

        for (int x = 0; x < w; x++)
        {
            for (int y = 0; y < h; y++)
            {
                int argb = image.getRGB(x, y);
                int nargb = ((argb >> 24) & 0xFF) << 24; // set alpha
                for (int i = 0; i < 24; i += 8)
                {
                    int value = (int)(Math.pow((argb >> i) & 0xFF, gammaPotency));
                    nargb += (int)((value > 0xFF) ? (0xFF << i) : (value << i));
                }
                image.setRGB(x, y, nargb);
            }
        }
        return image;
    }

    public BufferedImage invert(BufferedImage image)
    {
        int w = image.getWidth(), h = image.getHeight();
        BufferedImage bearbeiten = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);

        for (int x = 0; x < w; x++)
        {
            for (int y = 0; y < h; y++)
            {
                int neu = 255 + 256 * 255 + 256 * 256 * 255 - image.getRGB(x, y);
                bearbeiten.setRGB(x, y, neu);
            }
        }
        return bearbeiten;
    }
}
```


----------



## Michael... (31. Aug 2011)

wozu die ganzen Referenzvariablen auf BufferedImages? Vermutlich kommt da was durcheinander.
Ausserdem werden hier sinnlos BufferedImages.


----------



## headnut (31. Aug 2011)

Diese braucht es für den Kontrast und die Helligkeit zu verändern.

Ich mach es jetzt so, ich lasse das Teil ohne invertierung raus, und schreibe in Ruhe komplett neu und gebe dann ein Update raus

Das Teil sollte Freitag raus und dies reicht nicht, keine Ahnung wo der Fehler liegt, ich muss mich auf jeden fall mal tief in das ganze einarbeiten. Habe den Software teil von meinem Vorgänger übernommen...

Vielen Dank nochmal


----------

