Mandelbrot

[ronald deux]

import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.swing.JFrame;
 
public class Mandelbrot extends JFrame {
 
    private final int MAX_ITER = 570;
    private final double ZOOM = 150;
    private BufferedImage I;
    private double zx, zy, cX, cY, tmp;
 
    public Mandelbrot() {
        super("Mandelbrot Set");
        setBounds(100, 100, 800, 600);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        I = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
        for (int x = 0; x < getWidth(); x++) {
            for (int y = 0; y < getHeight(); x++) {
                zx = zy = 0;
                cX = (x - 400) / ZOOM;
                cY = (y - 300) / ZOOM;
                int iter = 0;
                while (zx * zx + zy * zy < 4 && iter < MAX_ITER) {
                	
                	tmp = zx;
                    zx = zx * zx - zy * zy + cX;
                    zy = 2.0 * zy * tmp + cY;
                    iter++;
                }
                I.setRGB(x, y, iter | (iter << 8));
            }
        }
    }
 
    @Override
    public void paint(Graphics g) {
        g.drawImage(I, 0, 0, this);
    }
 
    public static void main(String[] args) {
        new Mandelbrot().setVisible(true);
    }
}

I have slightly modified this code found in rosetta code
it does not work
Thank you for your help

[Tim Cooke]

You're going to need to be more specific than "it does not work".

What are you expecting it to do?

What does it actually do?

What steps to resolve it have you tried out?

[ronald deux]

what interests me is to make a mandelbrot with several colors
I think line 31 is wrong

[Paul Clapham]

Okay; that answers the first of Tim's three bullet points. Would you like to try answering the second point?

[Mike Simmons]

Those bullet points are really useful for (a) organizing your own thinking, and then (b) convincing others to help you.  But jumping past that... line 31 is the one that throws the exception.  That doesn't necessarily mean it's the problem.  Take a close look at line 19.

[ronald deux]

ok i found the error
I thought I had made a mistake compared to another mandelbrot

[Campbell Ritchie]

Well done finding the error; what was it?

[ronald deux]

x ++ instead of y ++
line 19

[ronald deux]

if (iter < MAX_ITER) setColor(x,y,Color.BLACK);
            	
            	else if (iter > 9*MAX_ITER/10) setColor(x,y,Color.DARK_GRAY);
            	else if (iter > 8*MAX_ITER/10) setColor(x,y,Color.GRAY);
            	else if (iter > 7*MAX_ITER/10) setColor(x,y,Color.MAGENTA);
            	else if (iter > 6*MAX_ITER/10) setColor(x,y,Color.CYAN);
            	else if (iter > 5*MAX_ITER/10) setColor(x,y,Color.BLUE);
            	else if (iter > 4*MAX_ITER/10) setColor(x,y,Color.GREEN);
            	else if (iter > 3*MAX_ITER/10) setColor(x,y,Color.YELLOW);
            	else if (iter > 2*MAX_ITER/10) setColor(x,y,Color.ORANGE);
            	else if (iter > 1*MAX_ITER/10) setColor(x,y,Color.RED);
            	else setColor(x,y,Color.WHITE);

I want to add this piece of code
I replace setcolor with I.setRGB at each iteration
I think
and then ???
have any suggestions?

[Piet Souris]

An alternative is to have a Map<Integer, Color>, so that you can replace all the ifs with just the line:

setColor(map.get(iter);

Of course you have to make that Map in the first place. To save on work, you might use a formula to derive the color from the value of iter.
For instance (using the red color)

for (int i = 0; i < 256; i++) map.put(i, new Color(i, 0, 0));

[Tim Moores]

A long time ago I wrote a Mandelbrot applet where I special-cased the exponents 2 and 3 in order to reduce the number of multiplications, by using these formulas:

(re + im)^2 = re^2 + 2*re*im + im^2
(re + im)^3 = re^3 + 3*re^2*im + 3*re*im^2 + im^3

This would reduce the number of multiplications from 4 to 2 for exponent 2, and from 8 to 6 for exponent 3, if memory serves. That brings back memories :-) I have no idea if that would make much of a difference these days.

[Piet Souris]

Them good old days!

I remember that we got PCs at the office, was it early 90's or late 80's? The first thing we put on these things were Mandelbrots, with QBasic. But the processors were 486SX, so that took quite a while.

@OP
You start your calculations with an (x, y) for which x < -2 (actually -400 / 150). Since points with |p| > 2 will have an iter of 0 you might as well not calculate them. So, if your zoom = 150, you can limit your panel to a width and height of 600.

Also nice is to map an iter-value of 1* to a fully transparent color. If you save your BufferedImage, you can paint it later in any text, without worrying about the ugly outer parts.

* since you start with evaluating (0, 0) when iter = 0

[ronald deux]

I do not know how to do
I don't really understand where you are coming from

[Piet Souris]

Okay, never mind then.

[ronald deux]

 Map<Integer, Color> map = new HashMap<Integer, Color>();
                
                for (int i = 0; i < 256; i++) {
                	map.put(i, new Color(i, 0, 0));

I made this piece of code,
I try to make a mandelbrot with several colors
Thank you for your help

[Piet Souris]

hi  Ronald,

that is the right idea, yes. I just made a demo (to rehearse long forgotten methods), that is a bit more luxuous than what you showed in your opening post.
There are three things to set: a Point2D that indicates the topleft point of the rectangle for which the Mandelbrot must be calculated, likewise a bottomright point, and lastly the width of the panel. That's all needed to get you a nice Mandelbrot.

I opted for a complete random colormap, but I outcommented a more structured one, for you to try.

I used a javaFX Point2D to indicate a point, because such a Point has the nice method 'distance', and that limits many of those horrible looking squares.
To zoom in on a part, just give the points topLeft and bottomRight a much smaller rectangle.

Experiment, and have fun!

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import javafx.geometry.Point2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

/**
 *
 * @author Piet
 */
public class RonaldDeux {
    
    // ************ member fields *********************************
    Point2D topLeft = new Point2D(-2, 1.5);
    Point2D bottomRight = new Point2D(1, -1.5);

    double xLeft = topLeft.getX();
    double yTop = topLeft.getY();
    double xRight = bottomRight.getX();
    double yBottom = bottomRight.getY();
    
    int panelWidth = 600;
    int panelHeight = (int) (panelWidth * (yTop - yBottom) / (xRight - xLeft));
    
    int MAX_ITER = 64;
    
    Map<Integer, Integer> colormap = new HashMap<>();
    BufferedImage buf;
    
    //******** main **********************************************
    public static void main(String... args) {
        SwingUtilities.invokeLater(RonaldDeux::new);
    }
    
    //******** constructor **************************************
    public RonaldDeux() {
        createColormap();
        createBufferedImage();
        
        var panel = new JPanel() {
            @Override
            public Dimension getPreferredSize() {
                return new Dimension(panelWidth, panelHeight);
            }
            @Override
            protected void paintComponent(Graphics g) {
                g.drawImage(buf, 0, 0, null);
            }
        };
        
        var frame = new JFrame("Mandelbrot");
        frame.setContentPane(panel);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
    
    //******** private methods **********************************
    private static Point2D square(Point2D p) {
        var a = p.getX();
        var b = p.getY();
        return new Point2D(a * a - b * b, 2 * a * b);
    }
    
    private void createColormap() {
        Random r = new Random();
        for (int i = 0; i <= MAX_ITER; i++) {
            Color c = new Color(r.nextInt(256), r.nextInt(256), r.nextInt(256));
            colormap.put(i, c.getRGB());
        }
//        colormap.put(0, new Color(0, 0, 0, 0).getRGB());   // fully transparent
//        double alpha = 254. / (MAX_ITER - 2);
//        double beta = 1 - alpha;
//        for (int i = 1; i < MAX_ITER; i++) {
//            float val = (float) (1 - (double) i / MAX_ITER);
//            colormap.put(i, new Color(val, 0, 0).getRGB());
//        }
//        colormap.put(MAX_ITER,Color.YELLOW.getRGB());
    }
    
    private void createBufferedImage() {
        buf = new BufferedImage(panelWidth, panelHeight, BufferedImage.TYPE_INT_ARGB);
        for (int x = 0; x < buf.getWidth(); x++) {
            double cx = (xRight - xLeft) / panelWidth * x + xLeft;
            for (int y = 0; y < panelHeight; y++) {
                double cy = (yBottom - yTop) / panelHeight * y + yTop;
                var c = new Point2D(cx, cy);
                var p = new Point2D(cx, cy);
                int iter = 0;
                while (iter < MAX_ITER && p.distance(0, 0) < 4) {
                    p = square(p).add(c);
                    iter++;
                }
                buf.setRGB(x, y, colormap.get(iter));
            }
        }
    }
}

[ronald deux]

thanks for the code, i thought i was abandoned
I made some corrections for your code
instead of javafx.geometry.Point2D
I put java.awt.geom.Point2D

also Point 2D.Double instead of Point2D,

and I block at p = square (p) .add (c)

I think I will have to revise my java lessons
and that I learn more

thank you

[Piet Souris]

A short explanation about this mysterious 'p = square(p).add(c)':

Suppose you have a function f(z) = z^2 + c, where c is a constant. In this, z and c are complex numbers.

What we do in a Mandelbrot program is to pick a point c, and then evaluate the series c, f(c), f(f(c)), et cetera. As soon as one of these points has a distance to the origin of more than 4, we count how many iterations we needed for that, and color the point c according to that number. However, there are points c that you can iterate forever, without getting more than 4 from the origin. The Mandelbrot collection consists of all the points c with this property. Now, we cannot do an infinite number of iterations, so we have a number MAX_ITER, and we say that when we have done MAX_ITER iterations, and the point is STILL within the distance of 4, then we assume that point c to belong to the Mandelbrot set.

So, what we do is: for x = 0 to panelwidth and y = 0 to panelheight, determine which point c belongs to these x and y, and then we iterate:

c, c^2 + c, ((c^2 + c)^2 + c, et cetera, and see when a value has a distance of more than 4 from the origin.

So, if I have a point p, I iterate p = p * p + c, or p = square(p).add(c).

Last remark: multiplying a point with itself?? Yes, with complex numers that is possible.

[ronald deux]

Thanks for the explanation
I block on p = square (p) .add (c); because I cannot correct add which is underlined in red
it says add cast to square (p)

[Piet Souris]

Well, you are using Java Point2D.Double, and I am using JavaFX Point2D, and that has the method 'add'.

By the way: there is in java(and FX) a class AffineTransform (in FX called Affine), that can map one set of coordinates to another set of coordinates. What we do in a Mandelbrot: we have pixelcoordinates, and we transform them to cartesian coordinates. Suppose we have such a transform called 'at'. My code now looks like:

for (int x = 0; x < panelWidth; x++) {
    for (int y = 0; y < panelHeight; y++) {
        var c = at.transform(x, y);
        var p = c;
        int iter = 0;
        while (iter < MAX_ITER && p.distance(0, 0) < 4) {
            p = square(p).add(c);
            iter++;
        }
        buf.setRGB(x, y, colormap.get(iter));
    }
}

And as you see: no horrible squares anymore!  

[ronald deux]

thank you