Nabend,

ich habe es nun schon eine Weile selbst versucht, aber ich komme einfach nicht drauf .. Ich habe ein Graustufenbild als BufferedImage. Aus diesem Bild ziehe ich mit folgendem Code:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

Raster r = src.getRaster();                 int width = r.getWidth(), height = r.getHeight();                 int size = width*height;                 int pixels[] = r.getPixels(0, 0, width, height, (int[])null);                 int length = pixels.length;                 // Negativwerte berechnen         for (int i=0; i<length; i++) {                         int p = pixels[i];                 pixels[i] = 255 - p;                       }

.. ein Array heraus, welches die Farbwerte des gesamten Bildes als int werte abspeichert und daraus die Negativwerte berechnet. Nun habe ich aber das Problem, das ich nicht weiß, wie man daraus wieder ein BufferedImage macht ..

Kann mir vielleicht wer helfen ? Es muss auf jeden Fall ein BufferedImage sein, weil ich die Schnittstelle BufferedImageOp laut Aufgabenstellung implementieren muss ..

Vielen Dank,
Stefan

Nun gut habs jetzt doch alleine hinbekommen ... siehe Code ..

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

public BufferedImage filter(BufferedImage src, BufferedImage dest) {             Raster r = src.getRaster();                 int width = r.getWidth(), height = r.getHeight();                 int size = width*height;                 int pixels[] = r.getPixels(0, 0, width, height, (int[])null);                 int length = pixels.length;             byte pixelsAsByte[] = new byte[pixels.length];                 // Statistische Parameter berechnen         for (int i=0; i<length; i++) {                         int p = pixels[i];                 pixels[i] = 255 - p;                         pixelsAsByte[i] = (byte) pixels[i];                         }                BufferedImage fBufferedImage =                new BufferedImage (width, height, BufferedImage.TYPE_BYTE_GRAY);                WritableRaster wr = fBufferedImage.getRaster();                wr.setDataElements(0,0, width, height, pixelsAsByte);                return fBufferedImage;   }

Hallo!

Schau dir doch mal MemoryImageSource an... damit kannst du die Pixelwerte direkt über ein Array Manipulieren ohne immer ein BufferedImage erzeugen zu müssen.

Hier mal ein Beispiel was exemplarisch verdeutlicht wie ich mir das vorstelle:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115

/**  *  */ package de.tutorials;   import java.awt.Graphics; import java.awt.Image; import java.awt.image.BufferStrategy; import java.awt.image.MemoryImageSource;   import javax.swing.JFrame;   /**  * @author Administrator  *  */ public class BufferedImageExample extends JFrame {       private final int WIDTH = 160;       private final int HEIGHT = 120;       private BufferStrategy strategy;       private MemoryImageSource mis;       private Image img;       private int pix[] = new int[WIDTH * HEIGHT];       private Thread runner = new Thread() {         public void run() {               init();             int idx, dx, dy = dx = idx = 0;               int red;             int blue;               while (true) {                   Graphics g = strategy.getDrawGraphics();                   idx = 0;                 dy += 2;                 dx += 2;                   for (int y = 0; y < HEIGHT; y++) {                       for (int x = 0; x < WIDTH; x++) {                           red = (int) (180 + 180                                 * Math.sin((x + dx)                                         / (37 + 15 * Math.sin((y + dy) / 74)))                                 * Math.sin((y + dy)                                         / (31 + 11 * Math.sin((x + dx) / 37))));                         blue = (int) (180 + 180                                 * Math.cos((x + dx)                                         / (37 + 15 * Math.cos((y + dy) / 74)))                                 * Math.cos((y + dy)                                         / (31 + 11 * Math.cos((x + dx) / 37))));                           pix[idx++] = (16 << 24) | (red << 16) | blue;                       }                 }                   mis.newPixels(0, 0, WIDTH, HEIGHT);                   g.drawImage(img, 0, 0, null);                 g.dispose();                   strategy.show();                   try {                     sleep(10L);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         }           private void init() {             int idx = 0;             for (int y = 0; y < HEIGHT; y++) {                 int red = (y * 255) / (HEIGHT - 1);                 for (int x = 0; x < WIDTH; x++) {                     int blue = (x * 255) / (WIDTH - 1);                     pix[idx++] = (255 << 24) | (red << 16) | blue;                 }             }             mis = new MemoryImageSource(WIDTH, HEIGHT, pix, 0, WIDTH);             mis.setAnimated(true);             img = createImage(mis);         }     };       public BufferedImageExample() {         super("BufferedImageExample");         setDefaultCloseOperation(EXIT_ON_CLOSE);         setSize(WIDTH, HEIGHT);         setVisible(true);         createBufferStrategy(2);         strategy = getBufferStrategy();         runner.start();     }       /**      * @param args      */     public static void main(String[] args) {         new BufferedImageExample();     }   }

Ich gebe zu den Code kann man nicht gerade als "optimal" Bezeichnen aber der Effekt ist ganz nett

--Mit ner LookUp Table geht's ein wenig flotter

Gruß Tom

Danke schön, ich schau mir das heute abend mal genauer an ..

Gruß Stefan