- * Farben bestehen entweder aus einem Grauwert (zwischen 0 und - * 255) oder einem Rot-, Grün- und Blauanteil (jeweils zwischen - * 0 und 255). + * Farben bestehen entweder aus einem Grauwert (zwischen 0 und 255) oder einem + * Rot-, Grün- und Blauanteil (jeweils zwischen 0 und 255). *
- * Eine Farbe hat außerdem einen Transparenzwert zwischen 0 - * (unsichtbar) und 255 (deckend). + * Eine Farbe hat außerdem einen Transparenzwert zwischen 0 (unsichtbar) und 255 + * (deckend). */ public class Color { - //@formatter:off /** * Die Farbe Schwarz (Grauwert 0). @@ -124,12 +122,12 @@ public class Color { /** * Erstellt eine Farbe. Die Parameter red, green und - * blue geben die Rot-, Grün- und Blauanteile der Farbe. Die Werte - * liegen zwischen 0 und 255. + * blue geben die Rot-, Grün- und Blauanteile der Farbe. Die + * Werte liegen zwischen 0 und 255. * - * @param red Rotwert zwischen 0 und 255. + * @param red Rotwert zwischen 0 und 255. * @param green Grünwert zwischen 0 und 255. - * @param blue Blauwert zwischen 0 und 255. + * @param blue Blauwert zwischen 0 und 255. */ public Color( int red, int green, int blue ) { this(red, green, blue, 255); @@ -137,16 +135,14 @@ public class Color { /** * Erstellt eine Farbe. Die Parameter red, green und - * blue geben die Rot-, Grün- und Blauanteile der Farbe. Die Werte - * liegen zwischen 0 und 255. + * blue geben die Rot-, Grün- und Blauanteile der Farbe. Die + * Werte liegen zwischen 0 und 255. * alpha gibt den den Transparentwert an (auch zwischen - * 0 und 255), wobei - * 0 komplett durchsichtig ist und 255 komplett - * deckend. + * 0 und 255), wobei 0 komplett durchsichtig ist und 255 komplett deckend. * - * @param red Rotwert zwischen 0 und 255. + * @param red Rotwert zwischen 0 und 255. * @param green Grünwert zwischen 0 und 255. - * @param blue Blauwert zwischen 0 und 255. + * @param blue Blauwert zwischen 0 und 255. * @param alpha Transparentwert zwischen 0 und 255. */ public Color( int red, int green, int blue, int alpha ) { @@ -184,10 +180,11 @@ public class Color { /** * Interner Konstruktor für die Initialisierung einer Farbe mit einem * RGBA-Wert. - * + *
* Da der Konstruktor {@link #Color(int)} schon besetzt ist, muss hier der - * Parameter {@code isRGBA} auf {@code true} gesetzt werden, damit {@code rgba} - * korrekt interpretiert wird. + * Parameter {@code isRGBA} auf {@code true} gesetzt werden, damit + * {@code rgba} korrekt interpretiert wird. + * * @param rgba RGBA-wert der Farbe. * @param isRGBA Sollte immer {@code true} sein. */ @@ -210,12 +207,12 @@ public class Color { return c; } - public static Color getHSBColor(double h, double s, double b) { - return new Color(java.awt.Color.getHSBColor((float)h, (float)s, (float)b)); + public static Color getHSBColor( double h, double s, double b ) { + return new Color(java.awt.Color.getHSBColor((float) h, (float) s, (float) b)); } - public static Color getHSLColor(double h, double s, double l) { - int rgb = Color.HSLtoRGB(new float[]{(float)h, (float)s, (float)l}); + public static Color getHSLColor( double h, double s, double l ) { + int rgb = Color.HSLtoRGB(new float[]{(float) h, (float) s, (float) l}); return Color.getRGBColor(rgb); } @@ -235,9 +232,9 @@ public class Color { } /** - * Erzeugt eine Farbe aus einem hexadezimalen Code. Der Hexcode kann - * sechs- oder achtstellig sein (wenn ein Transparentwert vorhanden ist). - * Dem Code kann ein {@code #} Zeichen vorangestellt sein. + * Erzeugt eine Farbe aus einem hexadezimalen Code. Der Hexcode kann sechs- + * oder achtstellig sein (wenn ein Transparentwert vorhanden ist). Dem Code + * kann ein {@code #} Zeichen vorangestellt sein. * * @param hexcode * @return @@ -336,10 +333,11 @@ public class Color { /** * Konvertiert eine Farbe mit Komponenten im HSL-Farbraum in den * RGB-Farbraum. - * + *
* Die Farbkomponenten werden als Float-Array übergeben. Im Index 0 steht * der h-Wert im Bereich 0 bis 360, Index 1 und 2 enthalten den s- und * l-Wert im Bereich von 0 bis 1. + * * @param hsl Die Farbkomponenten im HSL-Farbraum. * @param alpha Ein Transparenzwert im Bereich 0 bis 255. * @return Der RGBA-Wert der Farbe. @@ -392,6 +390,7 @@ public class Color { /** * Erzeugt eine Kopie dieser Farbe. + * * @return Ein neues Farbobjekt. */ public Color copy() { @@ -400,10 +399,11 @@ public class Color { /** * Gibt den RGBA-Wert dieser Farbe zurück. - * - * Eine Farbe wird als 32-Bit Integer gespeichert. Bits 24-31 enthalten - * den Transparenzwert, 16-23 den Rotwert, 8-15 den Grünwert und 0-7 den + *
+ * Eine Farbe wird als 32-Bit Integer gespeichert. Bits 24-31 enthalten den + * Transparenzwert, 16-23 den Rotwert, 8-15 den Grünwert und 0-7 den * Blauwert der Farbe. + * * @return Der RGBA-Wert der Farbe. * @see #getRed() * @see #getGreen() @@ -416,6 +416,7 @@ public class Color { /** * Gibt den Rotwert dieser Farbe zurück. + * * @return Der Rotwert der Farbe zwischen 0 und 255. */ public int getRed() { @@ -424,6 +425,7 @@ public class Color { /** * Gibt den Grünwert dieser Farbe zurück. + * * @return Der Grünwert der Farbe zwischen 0 und 255. */ public int getGreen() { @@ -432,6 +434,7 @@ public class Color { /** * Gibt den Blauwert dieser Farbe zurück. + * * @return Der Blauwert der Farbe zwischen 0 und 255. */ public int getBlue() { @@ -440,6 +443,7 @@ public class Color { /** * Gibt den Transparenzwert dieser Farbe zurück. + * * @return Der Transparenzwert der Farbe zwischen 0 und 255. */ public int getAlpha() { @@ -448,9 +452,10 @@ public class Color { /** * Erzeugt ein {@link java.awt.Color}-Objekt aus dieser Farbe. + *
+ * Das erzeugte Farbobjekt hat dieselben Rot-, Grün-, Blau- und + * Transparenzwerte wie diese Farbe. * - * Das erzeugte Farbobjekt hat dieselben Rot-, Grün-, Blau- - * und Transparenzwerte wie diese Farbe. * @return Ein Java-Farbobjekt. */ public java.awt.Color getJavaColor() { @@ -468,11 +473,12 @@ public class Color { * @return {@code true}, wenn die Objekte gleich sind, sonst {@code false}. */ public boolean equals( Object obj ) { - return obj instanceof Color && ((Color)obj).getRGBA() == this.rgba; + return obj instanceof Color && ((Color) obj).getRGBA() == this.rgba; } /** * Erzeugt einen Text-String, der diese Farbe beschreibt. + * * @return Eine Textversion der Farbe. */ @Override @@ -482,6 +488,7 @@ public class Color { /** * Berechnet einen Hashcode für dieses Farbobjekt. + * * @return Ein Hashcode für diese Rabe. */ @Override @@ -490,7 +497,8 @@ public class Color { } /** - * Erzeugt eine um 30% hellere Version dieser Farbe. + * Erzeugt eine um 30% hellere Version dieser Farbe. + * * @return Ein Farbobjekt mit einer helleren Farbe. */ public Color brighter() { @@ -499,6 +507,7 @@ public class Color { /** * Erzeugt eine um {@code percent} hellere Version dieser Farbe. + * * @param percent Eine Prozentzahl zwischen 0 und 100. * @return Ein Farbobjekt mit einer helleren Farbe. */ @@ -510,6 +519,7 @@ public class Color { /** * Erzeugt eine um 30% dunklere Version dieser Farbe. + * * @return Ein Farbobjekt mit einer dunkleren Farbe. */ public Color darker() { @@ -518,6 +528,7 @@ public class Color { /** * Erzeugt eine um {@code percent} dunklere Version dieser Farbe. + * * @param percent Eine Prozentzahl zwischen 0 und 100. * @return Ein Farbobjekt mit einer dunkleren Farbe. */ @@ -528,11 +539,12 @@ public class Color { } public Color greyscale() { - return new Color((int)(getRed()*.299 + getGreen()*.587 + getBlue()*0.114)); + return new Color((int) (getRed() * .299 + getGreen() * .587 + getBlue() * 0.114)); } /** * Erzeugt eine zu dieser invertierte Farbe. + * * @return Ein Farbobjekt mit der invertierten Farbe. */ public Color inverted() { @@ -542,6 +554,7 @@ public class Color { /** * Erzeugt die Komplementärfarbe zu dieser. + * * @return Ein Farbobjekt mit der Komplementärfarbe. */ public Color complement() { @@ -554,11 +567,12 @@ public class Color { * Wählt entweder {@link #WHITE weiß} oder {@link #BLACK schwarz} aus, je * nachdem, welche der Farben besser als Textfarbe mit dieser Farbe als * Hintergrund funktioniert (besser lesbar ist). + * * @return Schwarz oder weiß. */ public Color textcolor() { // Basiert auf https://stackoverflow.com/questions/946544/good-text-foreground-color-for-a-given-background-color - if( (getRed()*.299 + getGreen()*.587 + getBlue()*0.114) < 186 ) { + if( (getRed() * .299 + getGreen() * .587 + getBlue() * 0.114) < 186 ) { return WHITE; } else { return BLACK; diff --git a/src/main/java/schule/ngb/zm/Constants.java b/src/main/java/schule/ngb/zm/Constants.java index 561b3aa..a22bb6a 100644 --- a/src/main/java/schule/ngb/zm/Constants.java +++ b/src/main/java/schule/ngb/zm/Constants.java @@ -1,6 +1,7 @@ package schule.ngb.zm; import schule.ngb.zm.util.ImageLoader; +import schule.ngb.zm.util.Noise; import java.awt.Cursor; import java.awt.event.KeyEvent; @@ -8,6 +9,7 @@ import java.awt.event.MouseEvent; import java.awt.image.BufferedImage; import java.util.Random; +@SuppressWarnings( "unused" ) public class Constants { /** @@ -76,162 +78,287 @@ public class Constants { */ public static final int STD_BUFFER = 10; + /** + * Option für durchgezogene Konturen und Linien. + */ public static final Options.StrokeType SOLID = Options.StrokeType.SOLID; + /** + * Option für gestrichelte Konturen und Linien. + */ public static final Options.StrokeType DASHED = Options.StrokeType.DASHED; + /** + * Option für gepunktete Konturen und Linien. + */ public static final Options.StrokeType DOTTED = Options.StrokeType.DOTTED; + /** + * Option für Pfeile mit Strichen als Kopf. + */ public static final Options.ArrowHead LINES = Options.ArrowHead.LINES; + /** + * Option für Pfeile mit gefüllten Köpfen. + */ public static final Options.ArrowHead FILLED = Options.ArrowHead.FILLED; + /** + * Option für den Abschluss eines Pfades oder Bogens, ohne die Enden zu + * verbinden. + */ public static final Options.PathType OPEN = Options.PathType.OPEN; + /** + * Option für den Abschluss eines Pfades oder Bogens durch Verbindung der + * Enden des Bogens mit einer Linie. + */ public static final Options.PathType CLOSED = Options.PathType.CLOSED; + /** + * Option für den Abschluss eines Bogens durch Verbindung der Enden des + * Bogens mit dem Mittelpunkt der zugrundeliegenden Ellipse. Dadurch + * entsteht ein Kreisausschnitt. + */ public static final Options.PathType PIE = Options.PathType.PIE; + /** + * Richtung: Mitte (bzw. keine Richtung) + */ public static final Options.Direction CENTER = Options.Direction.CENTER; + /** + * Richtung: Norden + * + * @see #UP + */ public static final Options.Direction NORTH = Options.Direction.NORTH; + /** + * Richtung: Osten + * + * @see #RIGHT + */ public static final Options.Direction EAST = Options.Direction.EAST; + /** + * Richtung: Süden + * + * @see #DOWN + */ public static final Options.Direction SOUTH = Options.Direction.SOUTH; + /** + * Richtung: Westen + * + * @see #LEFT + */ public static final Options.Direction WEST = Options.Direction.WEST; + /** + * Richtung: Nordosten + * + * @see #UPLEFT + */ public static final Options.Direction NORTHEAST = Options.Direction.NORTHEAST; + /** + * Richtung: Südosten + * + * @see #DOWNLEFT + */ public static final Options.Direction SOUTHEAST = Options.Direction.SOUTHEAST; + /** + * Richtung: Nordwesten + * + * @see #UPRIGHT + */ public static final Options.Direction NORTHWEST = Options.Direction.NORTHWEST; + /** + * Richtung: Südwesten + * + * @see #DOWNRIGHT + */ public static final Options.Direction SOUTHWEST = Options.Direction.SOUTHWEST; + /** + * Richtung: Mitte + * + * @see #CENTER + */ public static final Options.Direction MIDDLE = Options.Direction.MIDDLE; + /** + * Richtung: Oben + * + * @see #NORTH + */ public static final Options.Direction UP = Options.Direction.UP; + /** + * Richtung: Rechts + * + * @see #EAST + */ public static final Options.Direction RIGHT = Options.Direction.RIGHT; + /** + * Richtung: Unten + * + * @see #SOUTH + */ public static final Options.Direction DOWN = Options.Direction.DOWN; + /** + * Richtung: Links + * + * @see #WEST + */ public static final Options.Direction LEFT = Options.Direction.LEFT; /** - * Schwarz + * Richtung: Oben links + * + * @see #NORTHWEST + */ + public static final Options.Direction UPLEFT = Options.Direction.UPLEFT; + + /** + * Richtung: Unten links + * + * @see #SOUTHWEST + */ + public static final Options.Direction DOWNLEFT = Options.Direction.DOWNLEFT; + + /** + * Richtung: Oben rechts + * + * @see #UPRIGHT + */ + public static final Options.Direction UPRIGHT = Options.Direction.UPRIGHT; + + /** + * Richtung: Unten rechts + * + * @see #SOUTHEAST + */ + public static final Options.Direction DOWNRIGHT = Options.Direction.DOWNRIGHT; + + + /** + * Farbe: Schwarz */ public static final Color BLACK = Color.BLACK; /** - * Weiß + * Farbe: Weiß */ public static final Color WHITE = Color.WHITE; /** - * Grau + * Farbe: Grau */ public static final Color GRAY = Color.GRAY; /** - * Dunkelgrau + * Farbe: Dunkelgrau */ public static final Color DARKGRAY = Color.DARKGRAY; /** - * Hellgrau + * Farbe: Hellgrau */ public static final Color LIGHTGRAY = Color.LIGHTGRAY; /** - * Rot + * Farbe: Rot */ public static final Color RED = Color.RED; /** - * Blau + * Farbe: Blau */ public static final Color BLUE = Color.BLUE; /** - * Grün + * Farbe: Grün */ public static final Color GREEN = Color.GREEN; /** - * Gelb + * Farbe: Gelb */ public static final Color YELLOW = Color.YELLOW; /** - * Orange + * Farbe: Orange */ public static final Color ORANGE = Color.ORANGE; /** - * Türkis + * Farbe: Türkis */ public static final Color CYAN = Color.CYAN; /** - * Magenta + * Farbe: Magenta */ public static final Color MAGENTA = Color.MAGENTA; /** - * Pink + * Farbe: Pink */ public static final Color PINK = Color.PINK; /** - * Lila + * Farbe: Lila */ public static final Color PURPLE = Color.PURPLE; /** - * Braun + * Farbe: Braun */ public static final Color BROWN = Color.BROWN; /** * Standardfarbe für den Hintergrund. */ - public static final Color STD_BACKGROUND = new Color(200, 200, 200); + public static Color DEFAULT_BACKGROUND = new Color(200, 200, 200); /** - * Konstante zur Prüfung, ob ein Mausknopf gedrückt wurde. + * Konstante zur Prüfung, ob kein Mausknopf gedrückt wurde. */ - public static final int NOBUTTON = MouseEvent.NOBUTTON; + public static final int NOMOUSE = MouseEvent.NOBUTTON; /** * Konstante zur Prüfung, ob Mausknopf 1 (links) gedrückt wurde. */ - public static final int BUTTON1 = MouseEvent.BUTTON1; + public static final int MOUSE1 = MouseEvent.BUTTON1; /** * Konstante zur Prüfung, ob Mausknopf 2 (rechts) gedrückt wurde. */ - public static final int BUTTON2 = MouseEvent.BUTTON2; + public static final int MOUSE2 = MouseEvent.BUTTON2; /** * Konstante zur Prüfung, ob Mausknopf 3 (mittig) gedrückt wurde. */ - public static final int BUTTON3 = MouseEvent.BUTTON3; + public static final int MOUSE3 = MouseEvent.BUTTON3; /** - * Konstante für die Kreiszahl Pi. + * Konstante für die Kreiszahl Pi (entspricht 180 Grad). */ public static final double PI = Math.PI; /** - * Konstante für die Hälfte der Kreiszahl Pi. + * Konstante für die Hälfte der Kreiszahl Pi (entspricht 90 Grad). */ public static final double HALF_PI = Math.PI / 2.0; /** - * Konstante für ein Viertel der Kreiszahl Pi. + * Konstante für ein Viertel der Kreiszahl Pi (entspricht 45 Grad). */ public static final double QUARTER_PI = Math.PI / 4.0; @@ -240,8 +367,7 @@ public class Constants { */ public static final double TWO_PI = Math.PI * 2.0; - - /** + /* * Globale Variablen, die von allen Klassen genutzt werden dürfen. Änderungen * wirken sich auf die aktuelle Zeichenmaschine aus und sollten nur von der * Zeichenmaschine selbst vorgenommen werden. @@ -268,70 +394,86 @@ public class Constants { public static double delta = 0.0; /** - * Die aktuelle {@code x}-Koordinate der Maus. + * Die aktuelle {@code x}-Koordinate der Maus. (Wird einmal pro Frame + * aktualisiert.) */ public static double mouseX = 0.0; /** - * Die aktuelle {@code y}-Koordinate der Maus. + * Die aktuelle {@code y}-Koordinate der Maus. (Wird einmal pro Frame + * aktualisiert.) */ public static double mouseY = 0.0; /** - * Die letzte {@code x}-Koordinate der Maus (wird einmal pro Frame + * Die letzte {@code x}-Koordinate der Maus. (Wird einmal pro Frame * aktualisiert). */ public static double pmouseX = 0.0; /** - * Die letzte {@code y}-Koordinate der Maus (wird einmal pro Frame - * aktualisiert). + * Die letzte {@code y}-Koordinate der Maus. (Wird einmal pro Frame + * aktualisiert.) */ public static double pmouseY = 0.0; /** - * Die aktuelle (current) {@code x}-Koordinate der Maus - * (wird bei jeder Mausbewegung aktualisiert). + * Die aktuelle (current) {@code x}-Koordinate der Maus. (Wird bei + * jeder Mausbewegung aktualisiert). */ public static double cmouseX = 0.0; /** - * Die aktuelle (current) {@code y}-Koordinate der Maus - * (wird bei jeder Mausbewegung aktualisiert). + * Die aktuelle (current) {@code y}-Koordinate der Maus. (Wird bei + * jeder Mausbewegung aktualisiert). */ public static double cmouseY = 0.0; /** - * Gibt an, ob ein Mausknopf derzeit gedrückt ist. + * Gibt an, ob derzeit ein Mausknopf gedrückt ist. */ public static boolean mousePressed = false; /** * Der aktuell gedrückte Mausknopf. Die Mausknöpfe werden durch die - * Konstanten {@link #NOBUTTON}, {@link #BUTTON1}, {@link #BUTTON2} und - * {@link #BUTTON3} angegeben. (Sie stimmen mit den Konstanten in - * {@link MouseEvent} überein. - * - * @see MouseEvent + * Konstanten {@link #NOMOUSE}, {@link #MOUSE1}, {@link #MOUSE2} und + * {@link #MOUSE3} angegeben. */ - public static int mouseButton = NOBUTTON; + public static int mouseButton = NOMOUSE; /** * Das zuletzt ausgelöste {@code MouseEvent}. */ public static MouseEvent mouseEvent; - // Mauszeiger + /** + * Mauszeiger: Pfeil + */ public static final int ARROW = Cursor.DEFAULT_CURSOR; + /** + * Mauszeiger: Fadenkreuz + */ public static final int CROSS = Cursor.CROSSHAIR_CURSOR; + /** + * Mauszeiger: Hand + */ public static final int HAND = Cursor.HAND_CURSOR; + /** + * Mauszeiger: Bewegungspfeile + */ public static final int MOVE = Cursor.MOVE_CURSOR; + /** + * Mauszeiger: Textzeiger + */ public static final int TEXT = Cursor.TEXT_CURSOR; + /** + * Mauszeiger: Ladezeiger + */ public static final int WAIT = Cursor.WAIT_CURSOR; /** @@ -340,14 +482,16 @@ public class Constants { public static boolean keyPressed = false; /** - * Das Zeichen der zuletzt gedrückten Taste. + * Das Text-Zeichen der zuletzt gedrückten Taste. Für Tasten ohne + * zugeordnetes Zeichen ist das Zeichen leer. */ public static char key = ' '; /** * Der Tastencode der zuletzt gedrückten Taste. Die Keycodes können in der - * Klasse {@link KeyEvent} nachgesehen werden. (Zum Beispiel - * {@link KeyEvent#VK_ENTER}.) + * Klasse {@link KeyEvent} nachgesehen werden. Die Keycodes für die + * wichtigsten Tasten sind als Konstanten mit dem Prefix {@code KEY_} + * vorhanden. (Zum Beispiel {@link #KEY_A}.) */ public static int keyCode = 0; @@ -359,12 +503,12 @@ public class Constants { /** * Die Höhe der Zeichenleinwand. */ - public static int width; + public static int canvasWidth; /** * Die Breite der Zeichenleinwand. */ - public static int height; + public static int canvasHeight; /** * Die Breite des Bildschirms, auf dem das Zeichenfenster geöffnet wurde. @@ -387,8 +531,11 @@ public class Constants { /** * Erstellt eine graue Farbe. Der Parameter {@code gray} gibt einen Grauwert - * zwischen 0 und 255 an, wobei - * 0 schwarz und 255 weiß ist. + * zwischen 0 und 255 an, wobei 0 schwarz und 255 weiß ist. + * + *
+ * Color iron_grey = color(94);
+ *
+ * Color iron_grey_50 = color(94, 50);
+ *
+ * Color arctic_blue = color(149, 214, 220);
+ *
+ * Color arctic_blue_50 = color(149, 214, 220, 50);
+ *
+ * Color fillColor = randomColor();
+ *
+ * Color fillColor = randomNiceColor();
+ *
+ * Color arctic_blue = colorHsl(185, 32, 86);
+ *
+ * Color arctic_blue = colorHsl(185, 50, 72);
+ *
+ * double minimum = min(1.0, 5.1, 3.2); // 1.0
+ *
+ * double maximum = max(1.0, 5.1, 3.2); // 5.1
+ *
+ * double summe = sum(1.0, 2.0, 3.2); // 6.2
+ *
+ * double summe = sum(1.0, 2.2, 3.1); // 2.1
+ *
+ * double positiv = abs(-3.2); // 3.2
+ *
+ * double vorzeichen = sign(-3.2); // -1.0
+ *
+ * double gerundet = sign(3.2); // 3.0
+ *
+ * double abgerundet = sign(3.2); // 3.0
+ *
+ * double aufgerundet = sign(3.2); // 4.0
+ *
+ * double wurzel = sqrt(16); // 4.0
+ *
+ * double hoch4 = sqrt(8, 4); // 4096.0
+ *
+ * double radian = radians(360); // 6.28318530717959
+ *
+ * double grad = radians(HALF_PI); // 90.0
+ *
+ * double sinus = sin(0.0); // 0.0
+ *
+ * double kosinus = cos(0.0); // 1.0
+ *
+ * double sinus = tan(1.0); // 1.5574077246549
+ *
+ * double beschraenkt1 = limit(2.1, 0.0, 3.0); // 2.1
+ * double beschraenkt2 = limit(4.1, 0.0, 3.0); // 1.0
+ *
+ * double beschraenkt1 = limit(2, 0, 3); // 2
+ * double beschraenkt2 = limit(4, 0, 3); // 3
+ * * from - t * (from + to) *+ *
+ * In der Regel liegt {@code t} im Intervall {@code [0, 1]}. Für + * {@code t = 0} ist das Ergebnis {@code from} und für {@code t = 1} ist das + * Ergebnis {@code to}. {@code t} kann aber auch Werte außerhalb des + * Intervalls annehmen. Für {@code t = 2} ist das Ergebnis beispielsweise + * {@code 2*to}; + * + *
+ * double interpoliert = interpolate(100.0, 500.0, 0.5); // 300.0
+ * double interpoliert = interpolate(100.0, 500.0, 1.0); // 500.0
+ * double interpoliert = interpolate(100.0, 500.0, 1.5); // 750.0
+ *
+ * double interpoliert = interpolate(100.0, 500.0, 0.5); // 300.0
+ * double interpoliert = interpolate(100.0, 500.0, 1.0); // 500.0
+ * double interpoliert = interpolate(100.0, 500.0, 1.5); // 500.0
+ * + * Für {@code value = fromMin} wird {@code toMin} zurückgegeben. Für + * {@code value = fromMax} ist das Ergebnis {@code toMax}. Befindet sich + * {@code value} genau mittig zwischen {@code fromMin} und {@code fromMax}, + * dann ist das Ergebnis genau {@code interpolate(toMin, toMax, 0.5)}. + *
+ * Mit {@code map()} lassen sich Werte eines Originalintervalls auf ein + * Zielintervalls transponieren. Dies ist beispielsweise hilfreich, um aus + * der Mausbewegung die relative Position auf der Zeichenfläche zu + * bestimmen: + * + *
+ * double relativeMouseX = map(mouseX, 0.0, canvasWidth, 0.0, 1.0);
+ *
+ * int bin = binary(10); // "1010"
+ *
+ * int dezimal = romBinary("1010"); // 10
+ *
+ * int hexa = hex(255); // "FF"
+ *
+ * int dezimal = romHex("FF"); // 255
+ * + * Die Implementierung basiert auf dem von Ken perlin entwickelten Algorithmus + * und wurde von Matthew A. Johnston für Java implementiert. + *
+ * Original KOmmentar: + *
+ * This is Ken Perlin's implementation of Perlin Noise but modified to be more + * OOP. + *+ * + * @author Ken Perlin, Matthew A. Johnston (WarmWaffles) + */ +public class Noise { + + private Random rand; + + private static final int P = 8; + + private static final int B = 1 << P; + + private static final int M = B - 1; + + private static final int NP = 8; + + private static final int N = 1 << NP; + + private int[] p; + + private double[][] g2; + + private double[] g1; + + private static double[][] points; + + + public Noise() { + this(System.nanoTime()); + } + + public Noise( long seed ) { + this(new Random(seed)); + } + + public Noise( Random rand ) { + p = new int[B + B + 2]; + g2 = new double[B + B + 2][2]; + g1 = new double[B + B + 2]; + + points = new double[32][3]; + + this.rand = rand; + init(); + } + + /** + * A stub function that calls {@link #init()} + * + * @param seed + */ + public void setSeed( int seed ) { + this.rand = new Random(seed); + init(); + } + + public void setRandom( Random rand ) { + this.rand = rand; + init(); + } + + public double noise( double x, double y, double z ) { + int bx, by, bz, b0, b1, b00, b10, b01, b11; + double rx0, rx1, ry0, ry1, rz, sx, sy, sz, a, b, c, d, u, v, q[]; + + bx = (int) Math.IEEEremainder(Math.floor(x), B); + if( bx < 0 ) + bx += B; + + rx0 = x - Math.floor(x); + rx1 = rx0 - 1; + + by = (int) Math.IEEEremainder(Math.floor(y), B); + if( by < 0 ) + by += B; + + ry0 = y - Math.floor(y); + ry1 = ry0 - 1; + + bz = (int) Math.IEEEremainder(Math.floor(z), B); + if( bz < 0 ) + bz += B; + + rz = z - Math.floor(z); + + /* + if (bx < 0 || bx >= B + B + 2) + System.out.println(bx); + */ + b0 = p[bx]; + + bx++; + + b1 = p[bx]; + + b00 = p[b0 + by]; + b10 = p[b1 + by]; + + by++; + + b01 = p[b0 + by]; + b11 = p[b1 + by]; + + sx = s_curve(rx0); + sy = s_curve(ry0); + sz = s_curve(rz); + + q = G(b00 + bz); + u = rx0 * q[0] + ry0 * q[1] + rz * q[2]; + q = G(b10 + bz); + v = rx1 * q[0] + ry0 * q[1] + rz * q[2]; + a = lerp(sx, u, v); + q = G(b01 + bz); + u = rx0 * q[0] + ry1 * q[1] + rz * q[2]; + q = G(b11 + bz); + v = rx1 * q[0] + ry1 * q[1] + rz * q[2]; + b = lerp(sx, u, v); + c = lerp(sy, a, b); + + bz++; + rz--; + + q = G(b00 + bz); + u = rx0 * q[0] + ry0 * q[1] + rz * q[2]; + q = G(b10 + bz); + v = rx1 * q[0] + ry0 * q[1] + rz * q[2]; + a = lerp(sx, u, v); + q = G(b01 + bz); + u = rx0 * q[0] + ry1 * q[1] + rz * q[2]; + q = G(b11 + bz); + v = rx1 * q[0] + ry1 * q[1] + rz * q[2]; + b = lerp(sx, u, v); + d = lerp(sy, a, b); + + return lerp(sz, c, d); + } + + public double noise( double x, double y ) { + int bx0, bx1, by0, by1, b00, b10, b01, b11; + double rx0, rx1, ry0, ry1, sx, sy, a, b, t, u, v, q[]; + int i, j; + + t = x + N; + bx0 = ((int) t) & M; + bx1 = (bx0 + 1) & M; + rx0 = t - (int) t; + rx1 = rx0 - 1; + + t = y + N; + by0 = ((int) t) & M; + by1 = (by0 + 1) & M; + ry0 = t - (int) t; + ry1 = ry0 - 1; + + i = p[bx0]; + j = p[bx1]; + + b00 = p[i + by0]; + b10 = p[j + by0]; + b01 = p[i + by1]; + b11 = p[j + by1]; + + sx = s_curve(rx0); + sy = s_curve(ry0); + + q = g2[b00]; + u = rx0 * q[0] + ry0 * q[1]; + q = g2[b10]; + v = rx1 * q[0] + ry0 * q[1]; + a = lerp(sx, u, v); + + q = g2[b01]; + u = rx0 * q[0] + ry1 * q[1]; + q = g2[b11]; + v = rx1 * q[0] + ry1 * q[1]; + b = lerp(sx, u, v); + + return lerp(sy, a, b); + } + + public double noise( double x ) { + + int bx0, bx1; + double rx0, rx1, sx, t, u, v; + t = x + N; + bx0 = ((int) t) & M; + bx1 = (bx0 + 1) & M; + rx0 = t - (int) t; + rx1 = rx0 - 1; + + sx = s_curve(rx0); + u = rx0 * g1[p[bx0]]; + v = rx1 * g1[p[bx1]]; + + return lerp(sx, u, v); + } + + // ======================================================================== + // PRIVATE + // ======================================================================== + private void normalize2( double v[] ) { + double s; + s = Math.sqrt(v[0] * v[0] + v[1] * v[1]); + v[0] = v[0] / s; + v[1] = v[1] / s; + } + + private double[] G( int i ) { + return points[i % 32]; + } + + private double s_curve( double t ) { + return t * t * (3 - t - t); + } + + private double lerp( double t, double a, double b ) { + return a + t * (b - a); + } + + private final void init() { + int i, j, k; + double u, v, w, U, V, W, Hi, Lo; + + for( i = 0; i < B; i++ ) { + p[i] = i; + g1[i] = 2 * rand.nextDouble() - 1; + + do { + u = 2 * rand.nextDouble() - 1; + v = 2 * rand.nextDouble() - 1; + } while( u * u + v * v > 1 || + Math.abs(u) > 2.5 * Math.abs(v) || + Math.abs(v) > 2.5 * Math.abs(u) || + Math.abs(Math.abs(u) - Math.abs(v)) < .4 ); + + g2[i][0] = u; + g2[i][1] = v; + + normalize2(g2[i]); + + do { + u = 2 * rand.nextDouble() - 1; + v = 2 * rand.nextDouble() - 1; + w = 2 * rand.nextDouble() - 1; + U = Math.abs(u); + V = Math.abs(v); + W = Math.abs(w); + Lo = Math.min(U, Math.min(V, W)); + Hi = Math.max(U, Math.max(V, W)); + } while( u * u + v * v + w * w > 1 + || Hi > 4 * Lo + || Math.min(Math.abs(U - V), + Math.min(Math.abs(U - W), Math.abs(V - W))) < .2 ); + } + + while( --i > 0 ) { + k = p[i]; + j = (int) (rand.nextLong() & M); + p[i] = p[j]; + p[j] = k; + } + for( i = 0; i < B + 2; i++ ) { + p[B + i] = p[i]; + g1[B + i] = g1[i]; + for( j = 0; j < 2; j++ ) + g2[B + i][j] = g2[i][j]; + } + + points[3][0] = points[3][1] = points[3][2] = Math.sqrt(1. / 3); + double r2 = Math.sqrt(1. / 2); + double s = Math.sqrt(2 + r2 + r2); + + for( i = 0; i < 3; i++ ) + for( j = 0; j < 3; j++ ) + points[i][j] = (i == j ? 1 + r2 + r2 : r2) / s; + + + for( i = 0; i <= 1; i++ ) { + for( j = 0; j <= 1; j++ ) { + for( k = 0; k <= 1; k++ ) { + int n = i + j * 2 + k * 4; + if( n > 0 ) { + for( int m = 0; m < 4; m++ ) { + points[4 * n + m][0] = (i == 0 ? 1 : -1) * points[m][0]; + points[4 * n + m][1] = (j == 0 ? 1 : -1) * points[m][1]; + points[4 * n + m][2] = (k == 0 ? 1 : -1) * points[m][2]; + } + } + } + } + } + } + +} diff --git a/src/main/java/schule/ngb/zm/util/Validator.java b/src/main/java/schule/ngb/zm/util/Validator.java index 50067b9..cb28143 100644 --- a/src/main/java/schule/ngb/zm/util/Validator.java +++ b/src/main/java/schule/ngb/zm/util/Validator.java @@ -136,8 +136,27 @@ public class Validator { } */ + + public static final