From 2ad3bb7199b345b11901373b32dae8243073cec0 Mon Sep 17 00:00:00 2001 From: algobytewise Date: Sat, 24 Apr 2021 11:55:27 +0530 Subject: [PATCH] Add algorithm for the Mandelbrot set (#2155) * Add Euler method (from master) trying to avoid to prettier-error by making the commit from the master-branch * delete file * Add algorithm for the Mandelbrot set * remove unnecessary import * fix comments * Changed variable name * add package --- Others/Mandelbrot.java | 192 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 192 insertions(+) create mode 100644 Others/Mandelbrot.java diff --git a/Others/Mandelbrot.java b/Others/Mandelbrot.java new file mode 100644 index 000000000..940245fba --- /dev/null +++ b/Others/Mandelbrot.java @@ -0,0 +1,192 @@ +package Others; + +import java.awt.*; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import javax.imageio.ImageIO; + +/** + * The Mandelbrot set is the set of complex numbers "c" for which the series "z_(n+1) = z_n * z_n + + * c" does not diverge, i.e. remains bounded. Thus, a complex number "c" is a member of the + * Mandelbrot set if, when starting with "z_0 = 0" and applying the iteration repeatedly, the + * absolute value of "z_n" remains bounded for all "n > 0". Complex numbers can be written as "a + + * b*i": "a" is the real component, usually drawn on the x-axis, and "b*i" is the imaginary + * component, usually drawn on the y-axis. Most visualizations of the Mandelbrot set use a + * color-coding to indicate after how many steps in the series the numbers outside the set cross the + * divergence threshold. Images of the Mandelbrot set exhibit an elaborate and infinitely + * complicated boundary that reveals progressively ever-finer recursive detail at increasing + * magnifications, making the boundary of the Mandelbrot set a fractal curve. (description adapted + * from https://en.wikipedia.org/wiki/Mandelbrot_set ) (see also + * https://en.wikipedia.org/wiki/Plotting_algorithms_for_the_Mandelbrot_set ) + */ +public class Mandelbrot { + + public static void main(String[] args) { + // Test black and white + BufferedImage blackAndWhiteImage = getImage(800, 600, -0.6, 0, 3.2, 50, false); + + // Pixel outside the Mandelbrot set should be white. + assert blackAndWhiteImage.getRGB(0, 0) == new Color(255, 255, 255).getRGB(); + + // Pixel inside the Mandelbrot set should be black. + assert blackAndWhiteImage.getRGB(400, 300) == new Color(0, 0, 0).getRGB(); + + // Test color-coding + BufferedImage coloredImage = getImage(800, 600, -0.6, 0, 3.2, 50, true); + + // Pixel distant to the Mandelbrot set should be red. + assert coloredImage.getRGB(0, 0) == new Color(255, 0, 0).getRGB(); + + // Pixel inside the Mandelbrot set should be black. + assert coloredImage.getRGB(400, 300) == new Color(0, 0, 0).getRGB(); + + // Save image + try { + ImageIO.write(coloredImage, "png", new File("Mandelbrot.png")); + } catch (IOException e) { + e.printStackTrace(); + } + } + + /** + * Method to generate the image of the Mandelbrot set. Two types of coordinates are used: + * image-coordinates that refer to the pixels and figure-coordinates that refer to the complex + * numbers inside and outside the Mandelbrot set. The figure-coordinates in the arguments of this + * method determine which section of the Mandelbrot set is viewed. The main area of the Mandelbrot + * set is roughly between "-1.5 < x < 0.5" and "-1 < y < 1" in the figure-coordinates. + * + * @param imageWidth The width of the rendered image. + * @param imageHeight The height of the rendered image. + * @param figureCenterX The x-coordinate of the center of the figure. + * @param figureCenterY The y-coordinate of the center of the figure. + * @param figureWidth The width of the figure. + * @param maxStep Maximum number of steps to check for divergent behavior. + * @param useDistanceColorCoding Render in color or black and white. + * @return The image of the rendered Mandelbrot set. + */ + public static BufferedImage getImage( + int imageWidth, + int imageHeight, + double figureCenterX, + double figureCenterY, + double figureWidth, + int maxStep, + boolean useDistanceColorCoding) { + if (imageWidth <= 0) { + throw new IllegalArgumentException("imageWidth should be greater than zero"); + } + + if (imageHeight <= 0) { + throw new IllegalArgumentException("imageHeight should be greater than zero"); + } + + if (maxStep <= 0) { + throw new IllegalArgumentException("maxStep should be greater than zero"); + } + + BufferedImage image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB); + double figureHeight = figureWidth / imageWidth * imageHeight; + + // loop through the image-coordinates + for (int imageX = 0; imageX < imageWidth; imageX++) { + for (int imageY = 0; imageY < imageHeight; imageY++) { + // determine the figure-coordinates based on the image-coordinates + double figureX = figureCenterX + ((double) imageX / imageWidth - 0.5) * figureWidth; + double figureY = figureCenterY + ((double) imageY / imageHeight - 0.5) * figureHeight; + + double distance = getDistance(figureX, figureY, maxStep); + + // color the corresponding pixel based on the selected coloring-function + image.setRGB( + imageX, + imageY, + useDistanceColorCoding + ? colorCodedColorMap(distance).getRGB() + : blackAndWhiteColorMap(distance).getRGB()); + } + } + + return image; + } + + /** + * Black and white color-coding that ignores the relative distance. The Mandelbrot set is black, + * everything else is white. + * + * @param distance Distance until divergence threshold + * @return The color corresponding to the distance. + */ + private static Color blackAndWhiteColorMap(double distance) { + return distance >= 1 ? new Color(0, 0, 0) : new Color(255, 255, 255); + } + + /** + * Color-coding taking the relative distance into account. The Mandelbrot set is black. + * + * @param distance Distance until divergence threshold. + * @return The color corresponding to the distance. + */ + private static Color colorCodedColorMap(double distance) { + if (distance >= 1) { + return new Color(0, 0, 0); + } else { + // simplified transformation of HSV to RGB + // distance determines hue + double hue = 360 * distance; + double saturation = 1; + double val = 255; + int hi = (int) (Math.floor(hue / 60)) % 6; + double f = hue / 60 - Math.floor(hue / 60); + + int v = (int) val; + int p = 0; + int q = (int) (val * (1 - f * saturation)); + int t = (int) (val * (1 - (1 - f) * saturation)); + + switch (hi) { + case 0: + return new Color(v, t, p); + case 1: + return new Color(q, v, p); + case 2: + return new Color(p, v, t); + case 3: + return new Color(p, q, v); + case 4: + return new Color(t, p, v); + default: + return new Color(v, p, q); + } + } + } + + /** + * Return the relative distance (ratio of steps taken to maxStep) after which the complex number + * constituted by this x-y-pair diverges. Members of the Mandelbrot set do not diverge so their + * distance is 1. + * + * @param figureX The x-coordinate within the figure. + * @param figureX The y-coordinate within the figure. + * @param maxStep Maximum number of steps to check for divergent behavior. + * @return The relative distance as the ratio of steps taken to maxStep. + */ + private static double getDistance(double figureX, double figureY, int maxStep) { + double a = figureX; + double b = figureY; + int currentStep = 0; + for (int step = 0; step < maxStep; step++) { + currentStep = step; + double aNew = a * a - b * b + figureX; + b = 2 * a * b + figureY; + a = aNew; + + // divergence happens for all complex number with an absolute value + // greater than 4 (= divergence threshold) + if (a * a + b * b > 4) { + break; + } + } + return (double) currentStep / (maxStep - 1); + } +}