748 lines
29 KiB
Java
748 lines
29 KiB
Java
package io.gitlab.jfronny.ImgJava.util;
|
|
|
|
import javax.imageio.ImageIO;
|
|
import java.awt.*;
|
|
import java.awt.image.BufferedImage;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
|
|
/**
|
|
* Bildklasse fuer die Simulation von Processing-Befehlen
|
|
* <p>
|
|
* 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.
|
|
*
|
|
* @author Thomas Schaller (ZPG Informatik Klasse 9)
|
|
* @version 1.2 from 06.12.2019
|
|
*/
|
|
//TODO arrays to proper classes
|
|
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;
|
|
private Graphics2D g;
|
|
|
|
// 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;
|
|
|
|
// aktueller Font
|
|
private Font textfont = null;
|
|
|
|
// muss ein Bildanzeiger benachrichtigt werden
|
|
private ImageObserver 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 file Dateiname des Bildes
|
|
*/
|
|
public Picture(Path file) throws IOException {
|
|
load(file);
|
|
}
|
|
|
|
/**
|
|
* Erzeugt ein Bild aus einer Ressource im images/ Ordner
|
|
*
|
|
* @param resourceName Name der Ressource
|
|
*/
|
|
public Picture(String resourceName) throws IOException {
|
|
loadResource("images/" + resourceName);
|
|
}
|
|
|
|
/**
|
|
* 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.background = Color.decode("0x" + background);
|
|
this.pencolor = new Color(0, 0, 0);
|
|
this.stroke = 1;
|
|
this.fillcolor = null;
|
|
makeImage(width, height);
|
|
}
|
|
|
|
private void makeImage(int width, int height) {
|
|
this.image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
|
|
g = createGraphics();
|
|
g.setColor(this.background);
|
|
g.fillRect(0, 0, width - 1, height - 1);
|
|
}
|
|
|
|
private Graphics2D createGraphics() {
|
|
Graphics2D g = image.createGraphics();
|
|
// Antialiasing
|
|
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
|
|
// Rendering
|
|
g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
|
|
// Text
|
|
g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
|
// Color
|
|
g.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
|
|
return g;
|
|
}
|
|
|
|
/**
|
|
* Legt fest, wer das Bild anzeigt.
|
|
* Diese ermoeglicht die Benachrichtung des Observers, wenn sich das Bild aendert.
|
|
*
|
|
* @param observer Anzeiger des Bildes
|
|
*/
|
|
public Picture setObserver(ImageObserver observer) {
|
|
this.observer = observer;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Direktes Abfragen des Bildes (fuer interne Zwecke)
|
|
*
|
|
* @return Bild, das gerade gespeichert ist.
|
|
*/
|
|
public BufferedImage getImage() {
|
|
return image;
|
|
}
|
|
|
|
/**
|
|
* Direktes Setzen des Bildes (fuer interne Zwecke)
|
|
*
|
|
* @param b Bild, das gespeichert werden soll.
|
|
*/
|
|
public Picture setImage(BufferedImage b) {
|
|
image = b;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture size(int width, int height) {
|
|
makeImage(width, height);
|
|
|
|
g.setColor(background);
|
|
g.fillRect(0, 0, width - 1, height - 1);
|
|
if (observer != null) observer.resize();
|
|
return 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();
|
|
}
|
|
|
|
/**
|
|
* 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 Picture setAutoRefresh(boolean autoRefresh) {
|
|
this.autorefresh = autoRefresh;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Auch die anzeigenden Klasse wird zum Neuzeichnen aufgefordert.
|
|
*/
|
|
public Picture repaint() {
|
|
return repaint(false);
|
|
}
|
|
|
|
/**
|
|
* Ein repaint() (das Neuzeichnen) kann manuell erzwungen werden.
|
|
*/
|
|
public Picture repaint(boolean force) {
|
|
if (observer != null && (force || autorefresh)) {
|
|
observer.repaint(this);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// ----------------------------------------- Zeichenfunktionen -----------------------------------------------
|
|
|
|
/**
|
|
* Loescht den Inhalt des Bildes.
|
|
* Der Hintergrund wird mit der Hintergrundfarbe neu gefuellt.
|
|
*/
|
|
|
|
public Picture clear() {
|
|
makeImage(image.getWidth(), image.getHeight());
|
|
|
|
g.setColor(background);
|
|
g.fillRect(0, 0, image.getWidth() - 1, image.getHeight() - 1);
|
|
return 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 Picture 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;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture rectMode(int mode) {
|
|
rectMode = mode;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture ellipseMode(int mode) {
|
|
ellipseMode = mode;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture line(int x1, int y1, int x2, int y2) {
|
|
if (stroke > 0) {
|
|
g.setColor(pencolor);
|
|
g.setStroke(new BasicStroke((float) stroke));
|
|
// if(antialiasing) antialise();
|
|
g.drawLine(x1, y1, x2, y2);
|
|
}
|
|
return 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 Picture rect(int a, int b, int c, int d) {
|
|
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]);
|
|
}
|
|
return 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 Picture ellipse(int a, int b, int c, int d) {
|
|
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));
|
|
// if(antialiasing) antialise();
|
|
g.drawOval(coord[0], coord[1], coord[2], coord[3]);
|
|
}
|
|
return 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 Picture triangle(int x1, int y1, int x2, int y2, int x3, int y3) {
|
|
int[] px = {x1, x2, x3};
|
|
int[] py = {y1, y2, y3};
|
|
return 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 Picture 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);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture polygon(int[] x, int[] y) {
|
|
if (fillcolor != null) {
|
|
g.setColor(fillcolor);
|
|
g.fillPolygon(x, y, y.length);
|
|
}
|
|
if (pencolor != null) {
|
|
g.setColor(pencolor);
|
|
g.setStroke(new BasicStroke((float) stroke));
|
|
// if(antialiasing) antialise();
|
|
g.drawPolygon(x, y, x.length);
|
|
}
|
|
return 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 Picture point(int x, int y) {
|
|
ellipse(x, y, 1, 1);
|
|
return this;
|
|
}
|
|
|
|
// ----------------------------------------- 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 Picture text(String s, int x, int y) {
|
|
if (pencolor != null) {
|
|
if (fillcolor == null)
|
|
g.setColor(Color.black);
|
|
else
|
|
g.setColor(fillcolor);
|
|
g.setStroke(new BasicStroke((float) stroke));
|
|
g.setFont(textfont);
|
|
// if(antialiasing)g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
|
g.drawString(s, x, y);
|
|
}
|
|
return 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 Picture textFont(Font font) {
|
|
this.textfont = font;
|
|
return this;
|
|
}
|
|
|
|
// ----------------------------------------- Farbfestlegungen -----------------------------------------------
|
|
|
|
|
|
/**
|
|
* 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 Picture stroke(String pencolor) {
|
|
this.pencolor = Color.decode("0x" + pencolor);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture stroke(int pencolor) {
|
|
this.pencolor = new Color(pencolor);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture stroke(int r, int g, int b) {
|
|
this.pencolor = new Color(r, g, b);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Legt fest, dass keine Linien oder Raender um Formen gezeichnet werden soll.
|
|
*/
|
|
public Picture noStroke() {
|
|
this.pencolor = null;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture strokeWeight(double width) {
|
|
this.stroke = width;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture fill(String fillcolor) {
|
|
this.fillcolor = Color.decode("0x" + fillcolor);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture fill(int fillcolor) {
|
|
this.fillcolor = new Color(fillcolor);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture fill(int r, int g, int b) {
|
|
this.fillcolor = new Color(r, g, b);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Legt fest, dass die Formen nicht gefuellt werden sollen.
|
|
*/
|
|
public Picture noFill() {
|
|
this.fillcolor = null;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 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 Picture background(int c) {
|
|
if (c < 256) {
|
|
this.background = new Color(c, c, c);
|
|
} else {
|
|
this.background = new Color(c);
|
|
}
|
|
return 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 Picture background(int r, int g, int b) {
|
|
this.background = new Color(r, g, b);
|
|
return 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 hex String Farbe in Hexadezimalangabe
|
|
*/
|
|
public Picture background(String hex) {
|
|
this.background = Color.decode("0x" + hex);
|
|
return this.clear();
|
|
}
|
|
|
|
// ----------------------------------------- Dateioperationen -----------------------------------------------
|
|
|
|
/**
|
|
* Laedt ein Bild aus dem Dateisystem.
|
|
* Laedt ein Bild von einem Datentraeger und setzt Stiftfarbe und Fuellfarbe auf Standardwerte zurueck.
|
|
*
|
|
* @param file Dateipfad
|
|
*/
|
|
public Picture load(String file) throws IOException {
|
|
return load(Files.newInputStream(Paths.get(".").toAbsolutePath().normalize().resolve(file)));
|
|
}
|
|
|
|
/**
|
|
* Laedt ein Bild aus dem Dateisystem.
|
|
* Laedt ein Bild von einem Datentraeger und setzt Stiftfarbe und Fuellfarbe auf Standardwerte zurueck.
|
|
*
|
|
* @param file Dateipfad
|
|
*/
|
|
public Picture load(Path file) throws IOException {
|
|
return load(Files.newInputStream(file));
|
|
}
|
|
|
|
/**
|
|
* Laedt ein Bild aus dem Dateisystem.
|
|
* Laedt ein Bild von einem Datentraeger und setzt Stiftfarbe und Fuellfarbe auf Standardwerte zurueck.
|
|
*
|
|
* @param stream Bildquelle
|
|
*/
|
|
public Picture load(InputStream stream) throws IOException {
|
|
this.image = ImageIO.read(stream);
|
|
this.g = createGraphics();
|
|
this.background = Color.decode("0xD0D0D0");
|
|
this.pencolor = new Color(0, 0, 0);
|
|
this.fillcolor = null;
|
|
this.stroke = 1;
|
|
if (observer != null) observer.resize();
|
|
return this.repaint();
|
|
}
|
|
|
|
/**
|
|
* Laedt ein Bild aus einer Ressource.
|
|
*
|
|
* @param resource Ressourcenpfad
|
|
*/
|
|
public Picture loadResource(String resource) throws IOException {
|
|
return load(Thread.currentThread().getContextClassLoader().getResourceAsStream(resource));
|
|
}
|
|
|
|
/**
|
|
* 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 file Neuer Dateipfad
|
|
*/
|
|
public Picture save(Path file) throws IOException {
|
|
String[] fn = file.getFileName().toString().split("\\.");
|
|
if (fn.length == 0) {
|
|
return save(file.resolve("unnamed.png"));
|
|
}
|
|
else if (fn.length < 2) {
|
|
return save(file.getParent().resolve(fn[0] + ".png"));
|
|
}
|
|
else {
|
|
ImageIO.write(image, fn[fn.length - 1].toUpperCase(), Files.newOutputStream(file));
|
|
return this;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Speichert ein Bild.
|
|
* Speichert ein Bild auf einem Datentraeger. Der Pfad ist relativ zum aktuellen.
|
|
* Standardmaessig wird die Dateiendung .png ergaenzt, wenn keine angegeben ist.
|
|
*
|
|
* @param file Neuer Dateipfad
|
|
*/
|
|
public Picture save(String file) throws IOException {
|
|
return save(Paths.get(".").toAbsolutePath().normalize().resolve(file));
|
|
}
|
|
|
|
// ----------------------------------------- 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 java.awt.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 Picture setPixelArray(Color[][] pixel) {
|
|
size(pixel.length, pixel[0].length);
|
|
|
|
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();
|
|
return this;
|
|
}
|
|
}
|