# RGB-Frabmodell filtern



## disart (3. Nov 2006)

hallo,

hab mal wieder ein problem bei einer java aufgabe.
ich soll ein rgb .gif bild mit bestimmten filter algorithmen bearbeiten.

wie z.b. vertauschen von rot- und blau- anteilen im bild.
das funktioniert auch alles. probleme hab ich bei folgenden aufgaben:
- stellen sie nur dunkle bzw. helle stellen des bilde dar
- können sie das bild etwas aufhellen (unter umständen nur die blau töne)
- versuchen sie eine darstellung in schwarz-weiß (grauwert hab ich geschafft)

so sieht meine methode bis jetzt aus:

```
class TestFilter extends RGBImageFilter {
  
    public int filterRGB(int x, int y, int pixel) {
        int filteredPixel;
        int pixel1;
        int pixel2;
        int pixel3;
        int getauscht;
       
        
        // filtern von grün, blau, rot
  	    //filteredPixel = (pixel & 0xff00ff00); // grün
  	    //filteredPixel = (pixel & 0xff0000ff); // blau
  	    //filteredPixel = (pixel & 0xffff0000); // rot
        
        
        
        // farbe eigener wahl anstreichen
        //filteredPixel = (0xff00ff00); // färbt bild in beliebiger farbe ein
        //filteredPixel = (pixel & 0xffffffff);
        //return filteredPixel;  
        
           
               
        // rot blau vertauschen
   /*   pixel1 = pixel >> 16 & 0xff0000ff;
        pixel2 = pixel << 16 & 0xffff0000;
        filteredPixel = (pixel & 0xff00ff00);
        getauscht = (pixel2 | pixel1 | filteredPixel );
                        
        return getauscht;
    */
        
        
        // bild mit grauwerten
   /*   pixel1 = pixel >> 16 & 0xff0000ff;
        pixel2 = pixel >> 8 & 0xff00ff00;
        filteredPixel = (pixel & 0xffff0000);
        getauscht = (pixel1 | pixel2 | filteredPixel );
        
        return getauscht;
     */   
        
    }
}
```



vielleicht kann mir ja jemand helfen.


----------



## SlaterB (3. Nov 2006)

eine feste Definition für die geforderten Sachen gibts wohl nicht,

mach dir ne Mitte und dann gibt bei höheren Pixeln schwarz, bei niedrigeren weiß zurück,
bzw. gib bei niedrigenen die Original zurück, bei höheren aber einen weißen Wert (oder umgekehrt),
bzw. erhöhe nur den Blau-Anteil um 20% (des verbleibenen Intervalls bis zum Maximalwert)

könntest du den restlichen Code (Einlesen, auf die einzelnen Pixel zugreifen, speichern) noch grob dazuposten?
interessiert mich auch


----------



## disart (3. Nov 2006)

so in der art dachte ich es mir auch, 
die frage ist aber wie ich das machen muss.

hier der komplette code: 
da ich noch änfänger bin, kann ich mit dem ganzen nichts anfangen, für mich ist also nur die unterste klasse interessant.

```
import java.awt.*;
import java.awt.image.*;
import javax.swing.*;

public class photohop {
    public static void main(String[] args) {
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Image srcImage = toolkit.getImage("river.gif");
	
        ImageFilter colorfilter = new TestFilter();
        Image filteredImage = toolkit.createImage(
            new FilteredImageSource(srcImage.getSource(),colorfilter));
        JFrame srcFrame = new DisplayFrame(srcImage,0,0,500,200);
        JFrame filteredFrame = new DisplayFrame(filteredImage,0, 200, 500, 200);
    
        filteredFrame.setBackground(Color.red);  


        Image srcImage2 = toolkit.getImage("farbenkreis_b.gif");
	
        Image filteredImage2 = toolkit.createImage(
            new FilteredImageSource(srcImage2.getSource(),colorfilter));
        JFrame srcFrame2 = new DisplayFrame(srcImage2, 500, 0, 200, 200);
        JFrame filteredFrame2 = new DisplayFrame(filteredImage2, 500, 200, 200, 200);

        filteredFrame2.setBackground(Color.red);              
     }
}

class DisplayFrame extends JFrame  {
    private Image image;
    int x,y,b,h;

    public DisplayFrame(Image image, int x, int y, int b, int h)  {
        this.image = image;
        this.x = x;
        this.y = y;
        this.b = b;
        this.h = h;
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setBounds(x,y,b,h);
        this.setVisible(true);
    }
    
    public void paint(Graphics g) {    
        g.drawImage(image, 0, 0,b, h, this); 
    }
}
    
    

class TestFilter extends RGBImageFilter {
  
    public int filterRGB(int x, int y, int pixel) {
        int filteredPixel;
        int pixel1;
        int pixel2;
        int pixel3;
        int getauscht;
       
        
        // aufgabe a
  	    //filteredPixel = (pixel & 0xff00ff00); // grün
  	    //filteredPixel = (pixel & 0xff0000ff); // blau
  	    //filteredPixel = (pixel & 0xffff0000); // rot
        
        
        
        // aufgabe b
        //filteredPixel = (0xff00ff00); // färbt bild in beliebiger farbe ein
        //filteredPixel = (pixel & 0xffffffff);
        //return filteredPixel;  
        
           
               
        // aufgabe c
   /*   pixel1 = pixel >> 16 & 0xff0000ff;
        pixel2 = pixel << 16 & 0xffff0000;
        filteredPixel = (pixel & 0xff00ff00);
        getauscht = (pixel2 | pixel1 | filteredPixel );
                        
        return getauscht;
    */
        
        
        // aufgabe g
   /*   pixel1 = pixel >> 16 & 0xff0000ff;
        pixel2 = pixel >> 8 & 0xff00ff00;
        filteredPixel = (pixel & 0xffff0000);
        getauscht = (pixel1 | pixel2 | filteredPixel );
        
        return getauscht;
     */   
        
    }
}
```


----------



## disart (3. Nov 2006)

wie muss ich denn den code umschreiben bzw. dazuschreiben, dass die ,wie oben angegebenen, filter funktioniert?


----------



## SlaterB (3. Nov 2006)

danke,

-------

fang doch mal mit schwarz weiß an,
du brauchst also die Mittelfarbe,
wenn du nicht weißr welche das ist, dann probiere ein bisschen,
male ein 100x100 Array mit Farbwerten die langsam ansteigen,

versuche es am Anfang evtl nur mit einem einfarbigen Bild, z.B. nur mit dem Blau-Anteil

hast denn diesen komplizierten << und >> Code selber geschrieben?
der erscheint mir ja viel schwieriger..


----------



## disart (3. Nov 2006)

nee, war alles vorgegeben, hab nur die filteralgorithmen eingebaut.
versteh den code auch gar nicht, soweit sind wir in java noch nicht. 
wir sind im moment bei bit operationen, und um diese zu üben, sollen wir eben einige filter algorithmen einbaun.
d.h. ich muss mich, um die aufgabe zu lösen, auf einfache dinge beschränken, wie etwa das bitweise verschieben.
deswegen kann ich leider auch nichts mit deiner antwort anfangen.


----------



## SlaterB (3. Nov 2006)

nun ja wenn du nicht weißt, was die einzelnen Pixel in deinem Bild sind,
dann kommst du natürlich nicht voran,


mein Tipp ist immer noch: 
fange z.B. mit Blau an:
//filteredPixel = (pixel & 0xff0000ff); // blau 

male dir ein Bild mit verschiedenen Blautönen,
z.B.
0xff000050
0xff0000A0
0xff000007

usw. und lerne langsam aber sicher, was denn blau eigentlich ist,
wenn du auch damit wieder nix anfangen kannst,
ja wie soll man dir denn dann sonst helfen?

ohne ein Minimum an graphischen und Bitschiebe-Kenntnissen kann man an so eine Aufgabe nicht rangehen,
da kannst du ja gleich nach einem Programm für Word fragen


----------



## disart (3. Nov 2006)

achso, 
ne da haben wir uns falsch verstanden,

das weiß ich schon,
0xff0000ff steht zum beispiel für reines blau, also als rgb wert r=0, g=0 und b=255
und wenn ich jetzt will, dass das programm mir nur z.b. helle stellen ausgibt, würd ich sagen,
dass java bei der hälfte also bei 0xff000077 anfangen soll die pixel auszugeben und eben bei 0xff0000ff aufhören, 
und bei den dunklen eben umgekehrt.
die frage is, wie sag ich java das?
habs mit ner if anweisung probiert und dann mit nem größer oder kleiner zeichen, funktioniert aber nicht.


----------



## SlaterB (3. Nov 2006)

'funktioniert aber nicht' ist kein korrektes Vorgehen,
nenne Fehlermeldungen 
oder Beispiel mit gewünschtem Ausgang und davon abweichendem tatsächlichen Ausgang

ich selber habe davon auch nicht viel mehr Ahnung, würde da aber strukturiert vorgehen,
z.B. bekomme ich mit

```
int color1 = 0xff000050;
		int color2 = 0xff000090;
		int mitte = 0xff000080;

		String info;
		info =
			"ist color1  " + color1 + " größer als die Mitte: " + mitte + "?: ";
		System.out.println(info + (color1 > mitte));
		info =
			"ist color2  " + color2 + " größer als die Mitte: " + mitte + "?: ";
		System.out.println(info + (color2 > mitte));
```
sofort sowohl ein true als auch ein false
(80 ist wohl eher die Mitte) 


bei diesen Bits ist das allerdings allgemein recht schwierig, 
wer weiß wie Java die interpretiert, 
nachher sind alle ungeraden Zahlen helle Farben und alle geraden Zahlen dunkle,
weil ein bestimmten Bit als Vorzeichen gilt

deshalb: testen testen testen, von selber geht da nix
evtl. muss man am Ende auf Bitebene prüfen, z.B. schauen ob das höchste Bit gesetzt ist:



```
if ((color && 0x00000080) > 0) {
		} else {
		}
```

dafür wäre es also (ich wiederhole es nochmal) wichtig,
sich bestimmte Beispielfarben (helle, dunkle, mittlere) anzuschauen,
welche int-Repräsentationen haben sie,
auch mal in Binärschreibweise anschauen (010011011)
um das System zu erkennen,
viele System.out.println benutzen (habe in deinem Code noch kein einziges gesehen!)

das fällt alles nicht vom Himmel


----------



## disart (3. Nov 2006)

natürlich hab ich getestet und getestet, aber es kam einfach nix richtiges dabei raus.
system.out.println findest du bei mir deswegen nicht, weil ich ja den code online gestellt habe, der funktioniert.
außerdem braucht man da kein system.out, weil der befehl 
	
	
	
	





```
return filteredPixel;
```
mir das gefilterte bild ausgibt und ich gleich am bild sehen kann, ob sich was getan hat.

aber du hast mir trotzdem sehr geholfen, danke schön.

so funktionierts:


```
if ( pixel <= 0xff777777)
        {filteredPixel = ((pixel & 0xffffffff));}
    
       else
        {filteredPixel = ((pixel & 0xff000000));}
        return filteredPixel;
```
eine simple if else anweisung,
manchmal steht man einfach auf dem schlauch.


----------

