/*
Source file: FraktaleMengeAusgabe.java
Author: Markus Bautsch
Licence: public domain
Date: 3 November 2022
Version: 1.1 / using method java.awt.Graphics.drawImage
Revision: 27 May 2023
Version: 2.1 (implementing key listener, PNG file compression, variable complex values)
Programming language: Java
*/
/*
Graphische Ausgabe von Julia- und Mandelbrot-Mengen.
Mandelbrot-Mengen werden mit dem konstanten komplexwertigen Parameter c = (0, 0) gekennzeichnet.
*/
public final class FraktaleMengeAusgabe extends javax.swing.JFrame implements java.awt.event.KeyListener
{
// serialVersionUID fuer die Serialisation, die in der Klasse javax.swing.JFrame implementiert ist.
private final static long serialVersionUID = 1;
// Klassenkonstanten
private final static int offset = 10;
private final static int offsetTop = 30;
// Instanzkonstanten
private KomplexeZahl c;
private boolean isMandelbrot;
private double minX;
private double maxX;
private double minY;
private double maxY;
final private int pixelZahlX;
final private int pixelZahlY;
private double shiftFactor = 0.05; // Zum Zoomen und Verschieben des Bildes
// Instanzvariablen
private int keyCode;
private java.awt.image.BufferedImage bufferedImage;
private java.awt.image.WritableRaster imageRaster;
/* Konstruktor fuer die Initialisierung von Instanzen der Klasse FraktaleMengeAusgabe.
* @param c: Komplexwertiger Koeffizient der quadratischen Polynome
* @param minX: Kleinster x-Wert der rechteckigen Darstellung der fraktalen Menge
* @param maxX: Groesster x-Wert der rechteckigen Darstellung der fraktalen Menge
* @param minY: Kleinster y-Wert der rechteckigen Darstellung der fraktalen Menge
* @param maxY: Groesster y-Wert der rechteckigen Darstellung der fraktalen Menge
* @param bildhoehe: Die Anzahl der Bildpunkte in der Bildhoehe
* @param shiftFactor: Anteil des verschobenen oder gezoomten Bildausschnitts
*/
public FraktaleMengeAusgabe (KomplexeZahl c,
double minX, double maxX, double minY, double maxY, int bildhoehe,
double shiftFactor)
{
super ("Fraktale Menge");
this.setComplexParameter (c);
this.minX = minX;
this.maxX = maxX;
this.minY = minY;
this.maxY = maxY;
this.pixelZahlY = bildhoehe;
this.pixelZahlX = (int) (bildhoehe / (maxY - minY) * (maxX - minX));
this.shiftFactor = shiftFactor;
this.keyCode = 0;
this.bufferedImage = new java.awt.image.BufferedImage (this.pixelZahlX, this.pixelZahlY, java.awt.image.BufferedImage.TYPE_INT_RGB);
this.imageRaster = bufferedImage.getWritableTile (0, 0);
this.setDefaultCloseOperation (javax.swing.WindowConstants.EXIT_ON_CLOSE);
this.addKeyListener (this);
}
// Methode setName fuer die Bestimmung des aktuellen Titels der Instanz von FraktaleMengeAusgabe.
private void setName ()
{
java.lang.String fractalSetName;
if (this.isMandelbrot)
{
fractalSetName = "Mandelbrot-Menge";
}
else
{
fractalSetName = "Julia-Menge" + "_c.re_" + this.c.re + "_c.im_" + this.c.im;
}
fractalSetName = fractalSetName + "_re_" + this.minX + "_" + this.maxX + "_im_" + this.minY + "_" + this.maxY;
this.setTitle (fractalSetName);
}
// Methode saveFile für das Speichern einer fraktalen Graphik in einer graphischen PNG-Datei
public void saveFile ()
{
final java.lang.String fileExtension = "png";
java.util.Iterator <javax.imageio.ImageWriter> iter = javax.imageio.ImageIO.getImageWritersByFormatName (fileExtension);
javax.imageio.ImageWriter imageWriter = (javax.imageio.ImageWriter) iter.next ();
javax.imageio.ImageWriteParam imageWriteParam = imageWriter.getDefaultWriteParam ();
imageWriteParam.setCompressionMode (javax.imageio.ImageWriteParam.MODE_DEFAULT); // for compressed file
try
{
java.lang.String fileName = this.getTitle () + "." + fileExtension;
javax.imageio.stream.FileImageOutputStream fileImageOutputStream = new javax.imageio.stream.FileImageOutputStream (new java.io.File (fileName));
imageWriter.setOutput (fileImageOutputStream);
javax.imageio.IIOImage iIOimg = new javax.imageio.IIOImage ((java.awt.image.RenderedImage) bufferedImage, null, null);
java.lang.System.out.println ("Save " + fileName);
imageWriter.write (null, iIOimg, imageWriteParam);
}
catch (java.lang.Exception exception)
{
exception.printStackTrace ();
}
}
/*
* Bestimmt die Farbe eines darzustellenden Punktes aus der Zahl der durchgefuehrten Iterationen in der Polynomfolge
* @param zahlZurFarbbestimmung: Zahl der durchgefuehrten Iterationen, für die eine Farbbestimmung durchgeführt werden aoll
* @return: Farbe vom Datentyp java.awt.Color
*/
private static int [] bestimmeAusgabefarbe (int zahlZurFarbbestimmung)
{
final int hell = 255;
final int schwellfaktor1 = 8;
final int schwellfaktor2 = 16;
final int schwelle1 = hell / schwellfaktor1;
final int schwelle2 = hell / schwellfaktor2;
int helligkeit = hell * zahlZurFarbbestimmung / FraktaleMenge.maximaleAnzahlDerIterationen; // liegt im Intervall [0 .. HELL]
int [] farbe = {0, 0, 0}; // Vorgabe = schwarz fuer Hintergrund, wenn Polynomfolge als nicht divergent angesehen wird
if (zahlZurFarbbestimmung < FraktaleMenge.maximaleAnzahlDerIterationen)
{
if (helligkeit > schwelle1) // Polynomfolge divergiert langsam
{
farbe [0] = hell; // rot
farbe [1] = hell; // gruen
}
else if (helligkeit > schwelle2) // Polynomfolge divergiert schneller
{
farbe [0] = schwellfaktor1 * helligkeit; // rot
farbe [1] = helligkeit; // gruen
}
else // Polynomfolge divergiert schnell
{
farbe [0] = schwellfaktor2 * helligkeit; // rot
farbe [1] = helligkeit; // gruen
}
farbe [2] = helligkeit; // blau
}
return farbe;
}
/*
* Zeichnet einen farbigen Punkt in das Bild
* @param frame: Frame von Datentyp FraktaleMengeAusgabe
* @param z: Variable z des Polynoms
* @param c: Variable c des Polynoms
* @param xWert Der X-Wert an dem der Punkt gemalt werden soll
* @param yWert Der Y-Wert an dem der Punkt gemalt werden soll
*/
private static void zeichnePunkt (FraktaleMengeAusgabe frame, KomplexeZahl z, KomplexeZahl c, int xWert, int yWert)
{
int zahlZurFarbbestimmung = FraktaleMenge.iterationszahlBisSchranke (z, c);
int [] farbe = bestimmeAusgabefarbe (zahlZurFarbbestimmung);
frame.imageRaster.setPixel (xWert, yWert, farbe);
}
/*
* Berechnet den Skalierungsfaktor auf einer Koordinatenachse
* @param min: Der minimale Wert auf der Koordinatenachse
* @param max: Der maximale Wert auf der Koordinatenachse
* @param pixelZahl: Die gewuenschte Anzahl der Pixel auf der Koordinatenachse
* @return: Skalierungsfaktor auf der Koordinatenachse
*/
private static double berechneSkalierungsfaktor (double min, double max, long pixelZahl)
{
double skalierungsfaktor = (max - min) / pixelZahl;
return skalierungsfaktor;
}
/*
* Transformiert eine x-Koordinate aus der Pixel-Ebene in die mathematische Ebene
* @param minX: Der minimale x-Wert in der mathematischen Ebene
* @param skalierungsfaktorX: Skalierungsfaktor von der Pixel-Ebene in die mathematische Ebene in x-Richtung
* @param pixelKoordinateX: Die x-Koordinate in der Pixel-Ebene
* @return: Die x-Koordinate in der mathematischen Ebene
*/
private static double koordinatentransformationX (double minX, double skalierungsfaktorX, long pixelKoordinateX)
{
double xKoordinate = minX + (pixelKoordinateX * skalierungsfaktorX);
return xKoordinate;
}
/*
* Transformiert eine y-Koordinate aus der Pixel-Ebene in die mathematische Ebene
* @param maxY: Der maximale y-Wert auf der mathematischen Ebene
* @param skalierungsfaktorY: Skalierungsfaktor von der Pixel-Ebene in die mathematische Ebene in y-Richtung
* @param pixelKoordinateY: Die y-Koordinate in der Pixel-Ebene
* @return: Die y-Koordinate in der mathematischen Ebene
*/
private static double koordinatentransformationY (double maxY, double skalierungsfaktorY, long pixelKoordinateY)
{
double yKoordinate = maxY - (pixelKoordinateY * skalierungsfaktorY);
return yKoordinate;
}
/*
* Zeichnet eine fraktale Menge (Julia-Menge oder Mandelbrot-Menge)
* @param fraktakeMenge: fraktale Menge
* @param graphics: Graphikelement
*/
private static void fraktaleMenge (FraktaleMengeAusgabe fraktaleMenge)
{
final double skalierungX = berechneSkalierungsfaktor (fraktaleMenge.minX, fraktaleMenge.maxX, fraktaleMenge.pixelZahlX);
final double skalierungY = berechneSkalierungsfaktor (fraktaleMenge.minY, fraktaleMenge.maxY, fraktaleMenge.pixelZahlY);
KomplexeZahl c = fraktaleMenge.c; // Parameter c der fraktalen Menge
KomplexeZahl z = new KomplexeZahl (0,0); // Parameter z der fraktalen Menge
int ix; // Zaehler für Spalten in x-Richtung nach rechts
int iy; // Zaehler für Zeilen in y-Richtung nach unten
iy = 0; // oben starten
while (iy < fraktaleMenge.pixelZahlY)
{
ix = 0; // links starten
while (ix < fraktaleMenge.pixelZahlX)
{
double re = koordinatentransformationX (fraktaleMenge.minX, skalierungX, ix);
double im = koordinatentransformationY (fraktaleMenge.maxY, skalierungY, iy);
if (fraktaleMenge.isMandelbrot) // Mandelbrot-Menge
{
z.re = 0; // Realteil von z0 ist immer gleich 0
z.im = 0; // Imaginaerteil von z0 ist immer gleich 0
c.re = re; // Realteil von c ist immer gleich der x-Koordinate
c.im = im; // Imaginaerteil von c ist immer gleich der y-Koordinate
}
else // Julia-Menge
{
z.re = re; // Realteil von z ist immer gleich der x-Koordinate
z.im = im; // Imaginaerteil von z ist immer gleich der y-Koordinate
}
zeichnePunkt (fraktaleMenge, z, c, ix, iy);
ix++;
}
iy++;
}
}
/*
* Zeichnet eine fraktale Menge
* @param graphics Graphisches Element
*/
public void paint (java.awt.Graphics graphics)
{
// Rahmengröße, Hintergrund und das Layout werden gesetzt.
this.setName ();
fraktaleMenge (this);
graphics.drawImage (bufferedImage, offset, offset + offsetTop, null);
}
// Methode init fuer die Initialisierung der graphischen Ausgabe einer Instanz von FraktaleMengeAusgabe.
public void init ()
{
// Rahmengroesse, Hintergrund und das Layout werden gesetzt
this.setSize (this.pixelZahlX, this.pixelZahlY);
this.setBackground (java.awt.Color.WHITE);
java.awt.image.BufferedImage bufferedImage = new java.awt.image.BufferedImage (this.pixelZahlX, this.pixelZahlY, java.awt.image.BufferedImage.TYPE_INT_RGB);
java.awt.Graphics2D graphics2D = bufferedImage.createGraphics ();
this.setVisible (true);
this.setAlwaysOnTop (true);
this.paint (graphics2D);
}
@Override
public void keyPressed (java.awt.event.KeyEvent event)
{
this.keyCode = event.getKeyCode ();
}
@Override
public void keyReleased(java.awt.event.KeyEvent event)
{
}
@Override
public void keyTyped (java.awt.event.KeyEvent event)
{
}
public int getKeyCode ()
{
int returnKeyCode = this.keyCode;
this.keyCode = 0;
return returnKeyCode;
}
public double getMinX ()
{
return this.minX;
}
public double getMaxX ()
{
return this.maxX;
}
public double getMinY ()
{
return this.minY;
}
public double getMaxY ()
{
return this.maxY;
}
public void setBorders (double minX, double maxX, double minY, double maxY)
{
this.minX = minX;
this.maxX = maxX;
this.minY = minY;
this.maxY = maxY;
}
public KomplexeZahl getComplexParameter ()
{
KomplexeZahl c = this.c;
return c;
}
public void setComplexParameter (KomplexeZahl c)
{
this.c = c;
this.isMandelbrot = (KomplexeZahl.betragsquadrat (c) == 0);
}
private double getXShift ()
{
double minX = this.getMinX ();
double maxX = this.getMaxX ();
double shiftX = (maxX - minX) * shiftFactor;
return shiftX;
}
private double getYShift ()
{
double minY = this.getMinY ();
double maxY = this.getMaxY ();
double shiftY = (maxY - minY) * shiftFactor;
return shiftY;
}
public double getShiftFactor ()
{
double shiftFactor = this.shiftFactor;
return shiftFactor;
}
public void setShiftFactor (double shiftFactor)
{
this.shiftFactor = shiftFactor;
}
public void center ()
{
double minX = this.getMinX ();
double maxX = this.getMaxX ();
double deltaX2 = (maxX - minX) / 2;
double minY = this.getMinY ();
double maxY = this.getMaxY ();
double deltaY2 = (maxY - minY) / 2;
this.setBorders (-deltaX2, deltaX2, -deltaY2, deltaY2);
}
public void zoomIn ()
{
double shiftX = getXShift ();
double minX = this.getMinX () + shiftX;
double maxX = this.getMaxX () - shiftX;
double shiftY = getYShift ();
double minY = this.getMinY () + shiftY;
double maxY = this.getMaxY () - shiftY;
this.setBorders (minX, maxX, minY, maxY);
}
public void zoomOut ()
{
double shiftX = getXShift ();
double minX = this.getMinX () - shiftX;
double maxX = this.getMaxX () + shiftX;
double shiftY = getYShift ();
double minY = this.getMinY () - shiftY;
double maxY = this.getMaxY () + shiftY;
this.setBorders (minX, maxX, minY, maxY);
}
public void shiftRight ()
{
double shiftX = getXShift ();
double minX = this.getMinX () + shiftX;
double maxX = this.getMaxX () + shiftX;
double minY = this.getMinY ();
double maxY = this.getMaxY ();
this.setBorders (minX, maxX, minY, maxY);
}
public void shiftLeft ()
{
double shiftX = getXShift ();
double minX = this.getMinX () - shiftX;
double maxX = this.getMaxX () - shiftX;
double minY = this.getMinY ();
double maxY = this.getMaxY ();
this.setBorders (minX, maxX, minY, maxY);
}
public void shiftUp ()
{
double minX = this.getMinX ();
double maxX = this.getMaxX ();
double shiftY = getYShift ();
double minY = this.getMinY () + shiftY;
double maxY = this.getMaxY () + shiftY;
this.setBorders (minX, maxX, minY, maxY);
}
public void shiftDown ()
{
double minX = this.getMinX ();
double maxX = this.getMaxX ();
double shiftY = getYShift ();
double minY = this.getMinY () - shiftY;
double maxY = this.getMaxY () - shiftY;
this.setBorders (minX, maxX, minY, maxY);
}
}
