package imp; import java.awt.image.*; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.BasicStroke; import java.util.Vector; import javax.imageio.*; import java.io.*; import java.awt.*; import javax.swing.*; import java.util.Random; import java.awt.geom.AffineTransform; /** * * Bildklasse fuer die Simulation von Processing-Befehlen * * Diese Klasse stellt ein BufferedImage bereit, in das mit Processing-Befehlen gezeichnet * werden kann. * Zusaetzlich kann ein Bildanzeiger ueber jede Aenderung des Bildes informiert werden, * um "Zurueck"-Befehle zu ermoeglichen. Der Bildanzeiger ist entweder eine normale Java * ScrollPane oder ein Actor aus Greenfoot. * Die Dokumentation der einzelnen Zeichenmethoden ist der Processing-Reference * (https://processing.org/reference/ steht unter CC-Lizenz: https://creativecommons.org/) * entnommen und mit Deepl.com ins Deutsche uebersetzt. * * @version 1.0 from 23.01.2019 * @author Thomas Schaller (ZPG Informatik Klasse 9) */ public class Picture{ // Einstellungmoeglichkeiten fuer das Zeichnen von Rechtecken und Ellipsen // RADIUS = Mittelpunkt+Radius wird gegeben, CENTER = Mittelpunkt und Breite/Hoehe wird gegeben, // CORNER = Linke obere Ecke + Breite/Hoehe, CORNERS = Linke obere und rechte untere Ecke public static final int RADIUS = 1; public static final int CENTER = 2; public static final int CORNER = 3; public static final int CORNERS = 4; // gespeichertes Bild, private BufferedImage image; // aktuelle Farbeinstellungen private Color background; private Color pencolor; private Color fillcolor; // aktuelle Stiftdicke private double stroke; // aktueller Koordinatenmodus von Rechtecken und Ellipsen private int ellipseMode = CENTER; private int rectMode = CORNER; private int textMode = CORNER; // aktueller Font private Font textfont = null; // muss ein Bildanzeiger benachrichtigt werden private PictureViewer observer = null; private boolean autorefresh = true; /** * Erzeugt ein Bild mit Standardgroesse 500x400 */ public Picture() { this(500,400); } /** * Erzeugt ein Bild der angegeben Groesse * @param width Breite des Bildes * @param height Hoehe des Bildes */ public Picture(int width, int height) { this(width,height, "D0D0D0"); } /** * Erzeugt ein Bild aus einer Datei * @param filename Dateiname des Bildes */ public Picture(String filename) { load(filename); } /** * Erzeugt ein Bild der angegebenen Groesse mit festgelegtem Hintergrund * @param width Breite des Bildes * @param height Hoehe des Bildes * @param background Farbe des Hintergrunds */ public Picture(int width, int height, String background) { this.image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); this.background = decode(background); this.pencolor = new Color(0,0,0); this.stroke = 1; this.fillcolor = null; Graphics2D g = (Graphics2D) this.image.getGraphics(); g.setColor(this.background); g.fillRect(0,0,width-1, height-1); } public void showInFrame() { new PictureViewer(this); } /** * Legt fest, wer das Bild anzeigt. * Diese ermoeglicht die Benachrichtung des Observers, wenn sich das Bild aendert. * @param observer Anzeiger des Bildes */ public void setObserver(PictureViewer observer) { this.observer= observer; } public PictureViewer getObserver() { return observer; } /** * Direktes Setzen des Bildes (fuer interne Zwecke) * @param b Bild, das gespeichert werden soll. */ public void setImage(BufferedImage b) { image = b; } /** * Direktes Abfragen des Bildes (fuer interne Zwecke) * @return Bild, das gerade gespeichert ist. */ public BufferedImage getImage() { return image; } /** * Definiert die Dimension der Breite und Hoehe des Anzeigefensters in Pixeleinheiten. * Die eingebauten Variablen Breite und Hoehe werden durch die an diese Funktion uebergebenen Parameter festgelegt. So weist beispielsweise * der Befehl size(640, 480) der Variablen Breite 640 und der Variablen Hoehe 480 zu. * @param width Breite des Bildes * @param height Hoehe des Bildes */ public void size(int width, int height){ pushImage(); this.image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); Graphics2D g = (Graphics2D) this.image.getGraphics(); g.setColor(background); g.fillRect(0,0,width-1, height-1); repaint(); } /** * Liefert die Breite des Bildes zurueck. * @return Breite des Bildes */ public int getWidth() { return image.getWidth(); } /** * Liefert die Hoehe des Bildes zurueck. * @return Hoehe des Bildes */ public int getHeight() { return image.getHeight(); } /** * Erzeugt eine Kopie des Bildes und uebergibt sie an den Observer (falls existent), damit dieser die Versionen speichern kann */ private void pushImage() { if(observer != null) { observer.pushImage(); } } /** * Legt fest, ob nach jedem Zeichenbefehl automatisch das Bild auch in * der Oberflaeche aktualisiert wird. Die Einstellung "false" beschleunigt * das Zeichnen aufwaendiger Bilder und verhindert "Flackern". * Das Neuzeichnen kann durch die Methode "refresh" gezielt ausgeloest werden. * @param autorefresh true = nach jedem Zeichenbefehl die Anzeige aktualisieren, false= nur durch die Methode refresh neu zeichnen */ public void setAutoRefresh(boolean autoRefresh) { this.autorefresh = autoRefresh; } /** * Auch die anzeigenden Klasse wird zum Neuzeichnen aufgefordert. */ private void repaint() { if(observer != null && autorefresh) { observer.repaint(); } } /** * Ein repaint() (das Neuzeichnen) kann manuell erzwungen werden. */ public void forceRepaint() { if(observer != null) { observer.repaint(); } } // ----------------------------------------- Zeichenfunktionen ----------------------------------------------- /** * Loescht den Inhalt des Bildes. * Der Hintergrund wird mit der Hintergrundfarbe neu gefuellt. */ public void clear(){ pushImage(); image = new BufferedImage(image.getWidth(), image.getHeight(), image.getType()); Graphics2D g = (Graphics2D) this.image.getGraphics(); g.setColor(background); g.fillRect(0,0,image.getWidth()-1, image.getHeight()-1); repaint(); } /** * Konvertiert die in einem bestimmten Modus gegebenen Koordinaten in die Java-uebliche Links_Oben_Breite_Hoehe Version * Die Aenderungen werden direkt im Array vorgenommen * @param coord Array mit vier Koordinateneintraegen im gegebenen Modus * @param mode Modus der Koordinaten (CORNER, CORNERS, RADIUS oder CENTER) */ private void convert(int[] coord, int mode) { switch(mode) { case CORNER: break; case CORNERS: coord[2] -= coord[0]; coord[3] -= coord[1]; break; case RADIUS: coord[2] *= 2; coord[3] *=2; case CENTER: coord[0] -= coord[2]/2; coord[1] -= coord[3]/2; } } /** * Aendert den Koordinaten-Modus beim Zeichnen von Rechtecken. * Aendert die Position, von der aus Rechtecke gezeichnet werden, indem es die Art und Weise aendert, wie Parameter, die an rect() uebergeben werden, interpretiert werden. * Der Standardmodus ist rectMode(Bild.CORNER), der die ersten beiden Parameter von rect() als die linke obere Ecke der Form interpretiert, * waehrend der dritte und vierte Parameter seine Breite und Hoehe sind. * rectMode(Bild.CORNERS) interpretiert die ersten beiden Parameter von rect() als die Position einer Ecke * und die dritten und vierten Parameter als die Position der gegenueberliegenden Ecke. * rectMode(Bild.CENTER) interpretiert die ersten beiden Parameter von rect() als Mittelpunkt der Form, * waehrend der dritte und vierte Parameter seine Breite und Hoehe sind. * rectMode(RADIUS) verwendet auch die ersten beiden Parameter von rect() als Mittelpunkt der Form, * verwendet aber den dritten und vierten Parameter, um die Haelfte der Breite und Hoehe der Formen festzulegen. * @param mode Modus der Koordinateninterpretation (CORNER, CORNERS, CENTER oder RADIUS) */ public void rectMode(int mode) { rectMode = mode; } /** * Aendert den Koordinaten-Modus beim Zeichnen von Kreisen/Ellipsen. * Aendert die Position, von der aus Kreise/Ellipsen gezeichnet werden, indem es die Art und Weise aendert, wie Parameter, die an ellipse() uebergeben werden, interpretiert werden. * Der Standardmodus ist ellipseMode(Bild.CENTER), der die ersten beiden Parameter von ellipse() als Mittelpunkt der Form interpretiert, * waehrend der dritte und vierte Parameter seine Breite und Hoehe sind. * ellipseMode(Bild.CORNER) interpretiert die ersten beiden Parameter von ellipse() als die Position einer Ecke * und die dritten und vierten Parameter als Breite und Hoehe der Form. * ellipseMode(Bild.CORNERS) interpretiert die ersten beiden Parameter von ellipse() als die Position einer Ecke * und die dritten und vierten Parameter als die Position der gegenueberliegenden Ecke. * ellipseMode(RADIUS) verwendet auch die ersten beiden Parameter von ellipse() als Mittelpunkt der Form, * verwendet aber den dritten und vierten Parameter, um die Haelfte der Breite und Hoehe der Formen festzulegen. * @param mode Modus der Koordinateninterpretation (CORNER, CORNERS, CENTER oder RADIUS) */ public void ellipseMode(int mode) { ellipseMode = mode; } /** * Aendert den Koordinaten-Modus beim Zeichnen von Texten. * Aendert die Position, an der Texte gezeichnet werden, indem es die Art und Weise aendert, wie Parameter, die an text() uebergeben werden, interpretiert werden. * Der Standardmodus ist textMode(Bild.CORNER), der die Koordinaten von text() als * linke untere Ecke des Textes interpretiert. * textMode(Bild.CENTER) interpretiert sie als Koordinaten des Mittelpunktes des Textes.. * @param mode Modus der Koordinateninterpretation (CORNER, CENTER) */ public void textMode(int mode) { textMode = mode; } /** * Zeichnet eine Linie (einen direkten Weg zwischen zwei Punkten) auf den Bildschirm. * Um eine Linie einzufaerben, verwenden Sie die {@link #stroke(int, int, int) stroke()} Funktion. Eine Zeile kann nicht gefuellt werden, daher hat die Funktion fill() keinen * Einfluss auf die Farbe einer Zeile. Linien werden standardmaessig mit einer Breite von einem Pixel gezeichnet, dies kann jedoch mit der Funktion * {@link #strokeWeight(double) strokeWeight()} geaendert werden. * @param x1 x-Koordinate des 1. Punktes * @param y1 y-Koordinate des 1. Punktes * @param x2 x-Koordinate des 2. Punktes * @param y2 y-Koordinate des 2. Punktes */ public void line(int x1, int y1, int x2, int y2) { pushImage(); Graphics2D g = (Graphics2D) image.getGraphics(); if (stroke > 0) { g.setColor(pencolor); g.setStroke(new BasicStroke((float) stroke)); g.drawLine(x1, y1, x2, y2); } repaint(); } /** * Zeichnet ein Rechteck auf das Bild. * Standardmaessig legen die ersten beiden Parameter die Position der linken oberen Ecke fest, der dritte die Breite und der vierte die Hoehe. * Die Art und Weise, wie diese Parameter interpretiert werden, kann jedoch mit der Funktion {@link #rectMode(int) rectMode()} geaendert werden. * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()} die Rahmenfarbe. * @param a meist die x-Koordinate der linken oberen Ecke (kann durch rectMode() geaendert werden). * @param b meist die y-Koordinate der linken oberen Ecke (kann durch rectMode() geaendert werden). * @param c meist die Breite des Rechtecks (kann durch rectMode() geaendert werden). * @param d meist die Hoehe des Rechtecks (kann durch rectMode() geaendert werden). * */ public void rect(int a, int b, int c, int d) { pushImage(); Graphics2D g = (Graphics2D) image.getGraphics(); int[] coord = {a,b,c,d}; convert(coord, rectMode); if(fillcolor != null) { g.setColor(fillcolor); g.fillRect(coord[0], coord[1], coord[2], coord[3]); } if(pencolor != null) { g.setColor(pencolor); g.setStroke(new BasicStroke((float) stroke)); g.drawRect(coord[0], coord[1], coord[2], coord[3]); } repaint(); } /** * Zeichnet eine Ellipse/Kreis auf das Bild. * Standardmaessig legen die ersten beiden Parameter die Position des Mittelpunkts fest, der dritte die Breite und der vierte die Hoehe. * Die Art und Weise, wie diese Parameter interpretiert werden, kann jedoch mit der Funktion {@link #ellipseMode(int) ellipseMode()} geaendert werden. * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()} die Rahmenfarbe. * @param a meist die x-Koordinate des Mittelpunkts (kann durch ellipseMode() geaendert werden). * @param b meist die y-Koordinate des Mittelpunkts (kann durch ellipseMode() geaendert werden). * @param c meist die Breite des Rechtecks (kann durch ellipseMode() geaendert werden). * @param d meist die Hoehe des Rechtecks (kann durch ellipseMode() geaendert werden). * */ public void ellipse(int a, int b, int c, int d) { pushImage(); Graphics2D g = (Graphics2D) image.getGraphics(); int[] coord = {a,b,c,d}; convert(coord, ellipseMode); if(fillcolor != null) { g.setColor(fillcolor); g.fillOval(coord[0], coord[1], coord[2], coord[3]); } if(pencolor != null) { g.setColor(pencolor); g.setStroke(new BasicStroke((float) stroke)); g.drawOval(coord[0], coord[1], coord[2], coord[3]); } repaint(); } /** * Zeichnet ein Dreieck auf das Bild. * Ein Dreieck ist eine Ebene, die durch die Verbindung von drei Punkten entsteht. Die ersten beiden Argumente spezifizieren den * ersten Punkt, die mittleren beiden Argumente spezifizieren den zweiten Punkt und die letzten beiden Argumente spezifizieren den dritten Punkt. * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()} die Rahmenfarbe. * @param x1 meist die x-Koordinate des 1. Punkts. * @param y1 meist die y-Koordinate des 1. Punkts. * @param x2 meist die x-Koordinate des 2. Punkts. * @param y2 meist die y-Koordinate des 2. Punkts. * @param x3 meist die x-Koordinate des 3. Punkts. * @param y3 meist die y-Koordinate des 3. Punkts. */ public void triangle(int x1, int y1, int x2, int y2, int x3, int y3) { int px[] = {x1, x2, x3}; int py[] = {y1, y2, y3}; polygon(px, py); } /** * Zeichnet ein Viereck auf das Bild. * Ein Viereck ist ein vierseitiges Polygon. Es ist aehnlich wie ein Rechteck, aber die Winkel zwischen seinen Kanten * sind nicht auf neunzig Grad beschraenkt. Das erste Paar von Parametern (x1,y1) setzt den ersten Scheitelpunkt und die nachfolgenden * Paare sollten im Uhrzeigersinn oder gegen den Uhrzeigersinn um die definierte Form herum verlaufen. * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()} die Rahmenfarbe. * @param x1 meist die x-Koordinate des 1. Punkts. * @param y1 meist die y-Koordinate des 1. Punkts. * @param x2 meist die x-Koordinate des 2. Punkts. * @param y2 meist die y-Koordinate des 2. Punkts. * @param x3 meist die x-Koordinate des 3. Punkts. * @param y3 meist die y-Koordinate des 3. Punkts. * @param x4 meist die x-Koordinate des 3. Punkts. * @param y4 meist die y-Koordinate des 3. Punkts. */ public void quad(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) { int px[] = {x1, x2, x3, x4}; int py[] = {y1, y2, y3, y4}; polygon(px, py); } /** * Zeichnet ein Polygon auf das Bild. * Gleich lange Listen von x und y-Koordinaten bestimmen die Eckpunkte des Polygons. * Durch den Befehl {@link #fill(int,int,int) fill()} /{@link #noFill() noFill()} kann die Fuellfarbe des Rechtecks gewaehlt werden, durch {@link #stroke(int, int, int) stroke()}/{@link #noStroke() noStroke()} die Rahmenfarbe. * @param x Liste der x-Koordinaten der Punkte. * @param y Liste der y-Koordinaten der Punkte. */ public void polygon(int[] x, int[] y) { pushImage(); Graphics2D g = (Graphics2D) image.getGraphics(); if(fillcolor != null) { g.setColor(fillcolor); g.fillPolygon(x,y, y.length); } if(pencolor != null) { g.setColor(pencolor); g.setStroke(new BasicStroke((float) stroke)); g.drawPolygon(x, y, x.length); } repaint(); } /** * Zeichnet einen Punkt, d.h. einen Kreis in der Dimension eines Pixels. * Der erste Parameter ist der x-Wert fuer den Punkt, der zweite Wert ist der y-Wert fuer den Punkt. * @param x x-Koordinate des Punktes * @param y y-Koordinate des Punktes */ public void point(int x, int y) { ellipse(x,y,1, 1); } // ----------------------------------------- Schriftdarstellung ----------------------------------------------- /** * Gibt einen Text an den gegebenen Koordinaten aus * Zur Ausgabe des Textes wird der ausgewaehlte Font verwendet. Dieser muss vorher mit {@link #textFont(Font) textFont() } festgelegt. * @param s Text, der angezeigt werden soll * @param x x-Koordinate des Textanfangs * @param y y-Koordinate der Grundlinie des Textes. */ public void text(String s, int x, int y) { pushImage(); Graphics2D g = (Graphics2D) image.getGraphics(); if(pencolor != null) { g.setColor(fillcolor); g.setStroke(new BasicStroke((float) stroke)); g.setFont(textfont); if(textMode == CORNER) { g.drawString(s, x, y); } else { // textMode == CENTER int dx = g.getFontMetrics().stringWidth(s)/2; int dy = g.getFontMetrics().getAscent()/2; g.drawString(s, x-dx, y+dy); } } repaint(); } /** * Legt die Schriftart fuer Textausgaben fest. * Jeder uebliche Java-Font kann verwendet werden. Er kann mit z.B. Font f = new Font( "Arial", Font.PLAIN, 14 ); definiert werden. * @param font ein Font-Objekt */ public void textFont(Font font) { this.textfont = font; } // ----------------------------------------- Farbfestlegungen ----------------------------------------------- /** * Hilfsfunktion zur Interpretation von Farben */ private Color decode(String color) { try{ return new Color( Integer.valueOf( color.substring( 0, 2 ), 16 ), Integer.valueOf( color.substring( 2, 4 ), 16 ), Integer.valueOf( color.substring( 4, 6 ), 16 ) ); } catch (Exception e) { System.out.println("Falscher Farbcode:"+color); e.printStackTrace(); return Color.BLACK; } } /** * Hilfsfunktion zur Interpretation von Farben */ private Color decode(int color) { try{ if(color >=0 && color < 256) { return new Color(color,color,color); } else { int r = color / 0x010000 % 0xFF; int g = color / 0x000100 % 0xFF; int b = color % 0xFF; // System.out.println(""+r+","+g+","+b); return new Color(r, g, b ); } } catch (Exception e) { System.out.println("Falscher Farbcode:"+color); e.printStackTrace(); return Color.BLACK; } } /** * Legt die Farbe fest, mit der Linien und Raender um Formen gezeichnet werden. * Diese Farbe wird hexadezimal in Form der RGB angegeben: z.B. "CCFFAA" oder "004E23". Die Syntax verwendet sechs Ziffern - je zwei fuer die roten, gruenen und blauen Komponenten, * um eine Farbe anzugeben (genau wie Farben typischerweise in HTML und CSS angegeben werden). * @param pencolor Stiftfarbe in Hexadezimaldarstellung */ public void stroke(String pencolor) { this.pencolor = decode(pencolor); } /** * Legt die Farbe fest, mit der Linien und Raender um Formen gezeichnet werden. * Diese Farbe wird entweder als Graustufe (0-255) oder als 3-Byte RGB-Wert angegeben * @param pencolor Stiftfarbe (0-255: Graustufe zwischen 0 schwarz und 255 weiss, sonst: c wird als 3-Byte RGB-Wert interpretiert) */ public void stroke(int pencolor) { this.pencolor=decode(pencolor); } /** * Legt die Farbe fest, mit der Linien und Raender um Formen gezeichnet werden. * Diese Farbe wird komponentenweise als RGB-Wert angegeben * @param r Rotanteil (0-255) der Stiftfarbe * @param g Gruenanteil (0-255) der Stiftfarbe * @param b Blauanteil (0-255) der Stiftfarbe */ public void stroke(int r, int g, int b) { this.pencolor = new Color(r,g,b); } /** * Legt fest, dass keine Linien oder Raender um Formen gezeichnet werden soll. */ public void noStroke() { this.pencolor = null; } /** * Legt die Breite des Strichs fuer Linien, Punkte und den Rand um Formen fest. * Alle Breiten werden in Pixeleinheiten angegeben. * @param width Breite in Pixel */ public void strokeWeight(double width) { this.stroke = width; } /** * Legt die Farbe fest, mit der Formen gefuellt werden. * Diese Farbe wird hexadezimal in Form der RGB angegeben: z.B. "CCFFAA" oder "004E23". Die Syntax verwendet sechs Ziffern - je zwei fuer die roten, gruenen und blauen Komponenten, * um eine Farbe anzugeben (genau wie Farben typischerweise in HTML und CSS angegeben werden). * @param fillcolor Fuellfarbe in Hexadezimaldarstellung */ public void fill(String fillcolor) { this.fillcolor = decode(fillcolor); } /** * Legt die Farbe fest, mit der Formen gefuellt werden. * Diese Farbe wird entweder als Graustufe (0-255) oder als 3-Byte RGB-Wert angegeben. * @param fillcolor Fuellfarbe (0-255: Graustufe zwischen 0 schwarz und 255 weiss, sonst: c wird als 3-Byte RGB-Wert interpretiert) */ public void fill(int fillcolor) { this.fillcolor=decode(fillcolor); } /** * Legt die Farbe fest, mit der Formen gefuellt werden. * Diese Farbe wird komponentenweise als RGB-Wert angegeben. * @param r Rotanteil (0-255) der Fuellfarbe * @param g Gruenanteil (0-255) der Fuellfarbe * @param b Blauanteil (0-255) der Fuellfarbe */ public void fill(int r, int g, int b) { this.fillcolor = new Color(r,g,b); } /** Legt fest, dass die Formen nicht gefuellt werden sollen. */ public void noFill() { this.fillcolor = null; } /** * Die Funktion background() setzt die Farbe, die fuer den Hintergrund des Bildes verwendet wird. Der Standardhintergrund ist hellgrau. * Es ist nicht moeglich, den Alpha-Parameter Transparenz mit Hintergrundfarben auf der Hauptzeichnungsoberflaeche zu verwenden. * @param c Farbe fuer den Hintergrund (0-255: Graustufe zwischen 0 schwarz und 255 weiss, sonst: c wird als 3-Byte RGB-Wert interpretiert) */ public void background(int c) { if(c < 256) { this.background=new Color(c,c,c); } else { int r = c / 0x010000; int g = c / 0x000100 % 0xFF; int b = c % 0xFF; this.background= new Color(r, g, b ); } this.clear(); } /** * Die Funktion background() setzt die Farbe, die fuer den Hintergrund des Bildes verwendet wird. Der Standardhintergrund ist hellgrau. * Es ist nicht moeglich, den Alpha-Parameter Transparenz mit Hintergrundfarben auf der Hauptzeichnungsoberflaeche zu verwenden. * @param r Rotanteil (0-255) der Hintergrundfarbe * @param g Gruenanteil (0-255) der Hintergrundfarbe * @param b Blauanteil (0-255) der Hintergrundfarbe */ public void background(int r, int g, int b) { this.background=new Color(r,g,b); this.clear(); } // ----------------------------------------- Dateioperationen ----------------------------------------------- /** * Laedt ein Bild aus dem Dateisystem. * Laedt ein Bild von einem Datentraeger und setzt Stiftfarbe und Fuellfarbe auf Standardwerte zurueck. * @param filename Dateiname des Bildes */ public void load(String filename) { try{ this.image = ImageIO.read(new File(filename)); this.background = decode("D0D0D0"); this.pencolor = new Color(0,0,0); this.fillcolor = null; this.stroke = 1; this.repaint(); } catch(Exception e) { System.out.println("Fehler beim Einlesen der Bilddatei"); } } /** * Speichert ein Bild. * Speichert ein Bild auf einem Datentraeger. Zulaessig sind die Dateiformate PNG und GIF. Die Dateiendung legt den Typ fest. * Standardmaessig wird die Dateiendung .png ergaenzt, wenn keine angegeben ist. * @param filename Dateiname des Bildes */ public void save(String filename) { try{ String[] fn = filename.split("\\."); if (fn.length== 1) { ImageIO.write(image, "PNG", new File(filename+".png")); } else { if (fn.length == 2 && (fn[1].toUpperCase().equals("PNG") || fn[1].toUpperCase().equals("GIF"))){ ImageIO.write(image, fn[1], new File(filename)); }else { System.out.println("Unbekanntes Bildformat"); } } } catch(Exception e) { System.out.println("Fehler beim Speichern"); } } // ----------------------------------------- Sonstiges ----------------------------------------------- /** * Liefert das Bild als zweidimensionales Pixel-Array. * @return zweidimensionales Array von Color-Objekten, die den Pixeln des Bildes entsprechen. */ public Color[][] getPixelArray() { Color[][] pixel = new Color[image.getWidth()][image.getHeight()]; for(int x=0; x < image.getWidth(); x++){ for(int y=0; y < image.getHeight(); y++) { pixel[x][y] = new Color(image.getRGB(x,y)); } } return pixel; } /** * Setzt das Bild neu auf Basis des Pixel-Arrays. * Die Groesse des Bildes wird nicht automatisch an das Array angepasst. * @param pixel zweidimensionales Array von Color-Objekten */ public void setPixelArray(Color[][] pixel) { size(pixel.length,pixel[0].length); Graphics2D g = (Graphics2D) image.getGraphics(); for(int x=0; x < image.getWidth(); x++){ for(int y=0; y < image.getHeight(); y++) { g.setColor(pixel[x][y]); g.fillRect(x, y, 1, 1); } } repaint(); } /** * Hilfsfunktion zum Verzoegern der Ausgabe * @param millis Wartezeit in Millisekunden */ public void delay(int millis) { try{ Thread.sleep(millis); } catch(Exception e) { System.out.println("Fehler beim Verzoegern der Ausgabe"); } } }