5. Images (JIMI)

Images (JIMI)

  • S

    Das hier ist vielleicht etwas für die FAQ 🙂
    Das Programm enthält eine Klasse MyImages, mit deren Hilfe man Images be- und verarbeiten kann. Hier die Methoden im Überblick:

    • convertIntoAnImage (Wandelt Pixeldaten in ein Image um)
    • convertToRGB (Wandelt Pixeldaten in Rot-Grün-Blau-Farben um)
    • getDataOfImage (liefert die Pixeldaten eines Images
    • negativFilter (überzieht das Image mit einem Negativfilter)
    • grayFilter (überzieht das Image mit einem Graufilter)
    • saveImage (Speichert ein Image auf der Festplatte)

    Zum Ausführen des Programms benötigt ihr die JIMI-API von sun! Auf www.java.sun.com könnt ihr sie downloaden.

    Und hier ist der Sourcecode:

    import java.awt.Toolkit;
import java.awt.Image;
import java.awt.image.*;

import com.sun.jimi.core.*;
import com.sun.jimi.core.filters.*;
import com.sun.jimi.core.raster.*;

////////////////////////////////////////////////////////////////////////////////
//  Main-Klasse
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Hauptklasse soll die verschiedenen Methoden der MyImages-Klasse testen
 */
public class Main
{
////////////////////////////////////////////////////////////////////////////////
//  Konstruktor
////////////////////////////////////////////////////////////////////////////////
/**
 * Der macht heute mal nix :)
 */
public Main()
{}

////////////////////////////////////////////////////////////////////////////////
//  main-Methode
////////////////////////////////////////////////////////////////////////////////
/**
 * Die main-Methode führt sämtliche Funktionen des von der Klasse MyImages
 * erzeugten, Objekts aus.
 * @param args Es müssen keine Werte übergeben werden
 */
public static void main(String[] args)
{
  MyImages image = new MyImages();
  // Bilddaten werden eingelesen
  image.getDataOfImage("meinFahrrad.jpg");
  // Graufilter über das eingelesene Bild benutzen
  image.grayFilter();
  // Negativfilter über das eingelesene Bild benutzen
  image.negativFilter();
  // Das neu erstellte Bild auf der Festplatte sichern
  image.saveMyImage("meinNeuesFahrrad.jpg");

  // - Daten des Bildes holen
  // - Die RGB-Werte ermittlen
  // - Aus den erhaltenen Pixeln wieder ein Bild erstellen
  image.convertIntoAnImage(
                            image.convertToRGB(
                                      image.getDataOfImage( "meinFahrrad.jpg")),
                                                            image.getWidth(),
                                                            image.getHeight());
  // Neu erstelltes Bild abspeichern
  image.saveMyImage("meinNeuesAltesFahrrad.jpg");

  // unschöner Abbruch aus dem Programm
  // (Grund: Jimi.getImage() in Klasse MyImages, Funktion getDataOfImage())
  System.exit(0);
}

}//class

////////////////////////////////////////////////////////////////////////////////
//  MyImages
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Klasse MyImages stellt uns Funktionen zur Verfügung, mit deren Hilfe
 * ein Image in ein int[] convertiert werden kann. Weiter kann aus dem int[]
 * wieder ein Image erzeugt werden. Ein GrauFilter kann über das Image gezogen
 * und die RGB Werte können ermittelt werden.
 * <b>Wichtig:</b> Die Klasse benutzt die JIMI-API von sun! Falls die
 * Bibliothek nicht installiert sein sollte, kann man sie von www.java.sun.com 
 * downloaden.
 */
class MyImages
{
////////////////////////////////////////////////////////////////////////////////
//  Private Klassenattribute
////////////////////////////////////////////////////////////////////////////////
/**
 * Das zu bearbeitende Image
 */
private Image image;
/**
 * Die Breite des Image
 */
private int width;
/**
 * Die Höhe des Image
 */
private int height;

////////////////////////////////////////////////////////////////////////////////
//  Konstruktor
////////////////////////////////////////////////////////////////////////////////
/**
 * Der macht leider nix :)
 */
public MyImages()
{}

////////////////////////////////////////////////////////////////////////////////
//  getImage
////////////////////////////////////////////////////////////////////////////////
/**
 * @return liefert das Image zurück
 */
public Image getImage()
{
  return image;
}

////////////////////////////////////////////////////////////////////////////////
//  getHeight
////////////////////////////////////////////////////////////////////////////////
/**
 * @return liefert die Höhe des Images zurück
 */
public int getHeight()
{
  return height;
}

////////////////////////////////////////////////////////////////////////////////
//  getWidth
////////////////////////////////////////////////////////////////////////////////
/**
 * @return liefert die Breite des Images zurück
 */
public int getWidth()
{
  return width;
}

////////////////////////////////////////////////////////////////////////////////
//  saveImage
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Funktion legt das Image als Bild auf der Festplatte ab
 * @param image Das zu speichernde Image
 * @param filename Der gewünschte Dateiname
 * @return true wenn Speicherung erfolgreich war, sonst false
 */
public boolean saveImage(Image image, String filename)
{
  try{
    Jimi.putImage(image, filename);
    return true;
  }
  catch(JimiException jimie)
  {
    System.out.println("Probleme beim Speichern: " + jimie.getMessage());
    return false;
  }
}

////////////////////////////////////////////////////////////////////////////////
// grayFilter
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Methode legt über das <code>image</code> einen Graufilter
 */
public void grayFilter()
{
  Gray filter = new Gray();
  image = Toolkit.getDefaultToolkit().createImage(
                            new FilteredImageSource(image.getSource(), filter));
}

////////////////////////////////////////////////////////////////////////////////
// negativFilter
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Methode legt über das <code>image</code> einen Negativfilter
 */
public void negativFilter()
{
  // Eine lokale Klasse wird erzeugt. Sie erbt RGBImageFilter.
  class NegativFilter extends RGBImageFilter
  {
  // Der Konstruktor der nix macht :)
  public NegativFilter() {}
  // Der Pixel, sowie dessen Position wird übergeben. Anschließend wird sein
  // Negativwert zurückgegeben
  public int filterRGB(int x, int y, int rgb)
  {
    return  (0xFF000000 | (0xFFFFFFFF - rgb));
  }
  }//class

  image = Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(
                                       image.getSource(), new NegativFilter()));
}

////////////////////////////////////////////////////////////////////////////////
//  makeRaster
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Funktion rastert <code>image</code> und gibt das gerasterte Image zurück
 * @return Gibt ein JimiRasterImage zurück
 */
private JimiRasterImage makeRaster()
{
  JimiRasterImage jri = null;
  try{
    jri = Jimi.createRasterImage(image.getSource());
  }
  catch(JimiException je)
  {
    System.out.println(je.getMessage());
  }
  return jri;
}

////////////////////////////////////////////////////////////////////////////////
//  getDataOfSource
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Funktion gibt die Pixel des Images zurück
 * @param string Dateiname des Image
 * @return Das Image in Pixeln
 */
public int[] getDataOfImage(String string)
{
  image = Jimi.getImage(string);
  JimiRasterImage jri = makeRaster();

  // Falls das in 'string' angegebene Bild nicht exisitiert wird jri mit null
  // initialisiert. Deshalb wird hier, damit keine NullPointerExceptions
  //auftreten aus der Funktion gesprungen.
  if(jri == null)
    return null;

  width = jri.getWidth();
  height = jri.getHeight();

  // Einzelne Pixel werden gelesen und in das int-Array gespeichert.
  int[] pixs = new int[width * height];
  for(int y = 0; y < height; y++)
  {
    for(int x = 0; x < width; x++)
    {
      try{
        pixs[y * width + x] = jri.getPixelRGB(x,y);
      }
      catch(ImageAccessException iae)
      {
        System.out.println(iae.getMessage());
      }
    }
  }
  return pixs;
}

////////////////////////////////////////////////////////////////////////////////
//  convertToRGB
////////////////////////////////////////////////////////////////////////////////
/**
 * Diese Funktion wandelt die Daten eines Images in RGB-Werte um und gibt diese
 * anschließend zurück
 * @param data Die Werte eines Images
 * @return Die RGB-Werte des Images
 */
public int[] convertToRGB(int[] data)
{
  int[] pixs = new int[data.length * 3];
  int red, green, blue;
  for(int i = 0; i < (pixs.length / 3); i++)
  {
    red = (data[i] >> 16) & 0xff;
    green = (data[i] >> 8) & 0xff;
    blue = (data[i]) & 0xff;
    pixs[i * 3 + 0] = red;
    pixs[i * 3 + 1] = green;
    pixs[i * 3 + 2] = blue;
  }
  return pixs;
}

////////////////////////////////////////////////////////////////////////////////
//  convertIntoAnImage
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Funktion wandelt die Pixelwerte eines Images wieder in ein Image um.
 * @param pixs Die Pixelwerte eines Images
 * @param width Die Breite des Images
 * @param height Die Höhe des Images
 * @return Das generierte Image
 */
public Image convertIntoAnImage(int[] pixs, int width, int height)
{
  DataBufferInt dataBuffer = new DataBufferInt(pixs, width * height);
  ColorModel colorModel = ColorModel.getRGBdefault();
  int[] bandmasks = {0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000};
  WritableRaster raster = Raster.createPackedRaster(dataBuffer, width, height,
                                                        width, bandmasks, null);
  BufferedImage bufferImage = new BufferedImage(colorModel, raster,
                                       colorModel.isAlphaPremultiplied(), null);
  return (Image)bufferImage;
}

////////////////////////////////////////////////////////////////////////////////
//  saveMyImage
////////////////////////////////////////////////////////////////////////////////
/**
 * Die Methode speichert <code>image</code> auf die Festplatte
 * @param filename Der gewünschte Dateiname
 */
public void saveMyImage(String filename)
{
  saveImage(image, filename);
}

}//class

    Viele Grüße
    Stefan

    [ Dieser Beitrag wurde am 17.05.2002 um 02:22 Uhr von Ste.fun editiert. ]

    0
  • C

    Schöne Lösung. Dass man die Applikation per System.exit(...); verlassen muss ist meiner Meinung nach kein Nachteil 🙂

    Für die FAQ warte ich noch - vielleicht kommen ja noch weitere Ideen etc. 😉

    0
Anmelden zum Antworten