END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

I made a Mandelbrot program in Processing a little while ago that tests every pixel on the screen using z = sq(z)+c. It works just fine but I did not know how to generalize it to 3D. I found a website that had a very simple looking different method of testing points to see if they are part of the Mandelbrot set (and a generalization to 3D) and followed the instructions. To my surprise it made a different fractal. The website is here:

http://www.skytopia.com/project/fractal/mandelbrot.html#pandora

What I wrote is below. It's in the Java that Processing uses (the important part is in the while statement, I know that the rest works correctly):

float xmin = -2.5;
float ymin = -2;
float wh = 4;
int maxIterations = 100;

void setup() {
  size(400, 400, P2D);
  noLoop();
}

void draw() {
  loadPixels();
  float xmax = xmin+wh;
  float ymax = ymin+wh;
  float dx = (xmax-xmin)/width;
  float dy = (ymax-ymin)/width;
  float x = xmin;
  for (int i = 0; i < width; i++) {
    float y = ymin;
    for (int j = 0; j < height; j++) {
      float nx = x;
      float ny = y;
      int n = 0;
      while (n < maxIterations) {
        float a = atan2(ny, nx);
        float d = sqrt(sq(nx)+sq(ny));
        nx = cos(a*2)*sq(d)+cos(a)*d;
        ny = sin(a*2)*sq(d)+sin(a)*d;
        if (sq(nx)+sq(ny) > 4) break;
        n++;
      }
      if (n == maxIterations) pixels[i+j*width] = 0xffffff;
      else pixels[i+j*width] = 0;
      y += dy;
    }
    x += dx;
  }
  updatePixels();
}

One last thing that was even more strange to me is that if I change two lines in the while statement to subtract Step 3 from the instructions (instead of add) I get something that looks like a Mandelbrot Set reflected over the Y axis (the left half reflects to the right). The changed lines become:

nx = cos(a*2)*sq(d)-cos(a)*d;
ny = sin(a*2)*sq(d)-sin(a)*d;

Any help or suggestions as to what might have gone wrong would be greatly appreciated.

hooooooo fun ! (played with the code)

i realise that i added a lot of modification of my own.
so here is the patch from your original code :


float xmin = -2.5;
float ymin = -2;
float wh = 4;
int maxIterations = 100;

void setup() {
  size(400, 400, P2D);
  noLoop();
}

void draw() {
  loadPixels();
  float xmax = xmin+wh;
  float ymax = ymin+wh;
  float dx = (xmax-xmin)/width;
  float dy = (ymax-ymin)/width;
  float x = xmin;
  for (int i = 0; i < width; i++) {
    float y = ymin;
    for (int j = 0; j < height; j++) {
      float nx = x;
      float ny = y;
      int n = 0;
      float oa = atan2(ny, nx);
      float od = sqrt(sq(nx)+sq(ny));
      while (n < maxIterations) {
        float a = atan2(ny, nx);
        float d = sqrt(sq(nx)+sq(ny));
        nx = cos(a*2)*sq(d)+cos(oa)*od;
        ny = sin(a*2)*sq(d)+sin(oa)*od;
        if (sq(nx)+sq(ny) > 4) break;
        n++;
      }
      if (n == maxIterations) pixels[i+j*width] = 0xffffff;
      else pixels[i+j*width] = 0;
      y += dy;
    }
    x += dx;
  }
  updatePixels();
}

Oh whoops, I never was too good at following the end of instructions, ha ha. Thank you for looking through it, I will post the 3D version if I wrap my head around it. Out of curiosity, do you know the name of any of the fractals that showed up?

• In the original problem code, there was one that looked like a circle being squeezed at the top, right, bottom, and left with bumps on the surface.
• In the original problem code, swapping nx and ny in the atan2() function made some kind of swirly Mandelbrot Set.
• In the weird subtraction version of the problem code, was a reflected Mandelbrot Set over the Y axis.
• In your first code, there was a fractal that was made up of dividing lines.

I think I figured out the 3D one, I'm not really sure to be honest. The problem is that I don't know how to represent it nicely in Processing. Right now I have it representing only points that reached the max iteration count and I don't know how to light it properly.

I spent a few days wrapping my head around getting x, y, z coordinates to be spherical coordinate angles. If I generalized it correctly then this should be the image from that link (the white fractal with the glowing orange aura): http://www.skytopia.com/project/fractal/mandelbrot.html#pandora

float xmin = -2;
float ymin = -2;
float zmin = -2;
float wh = 4;
int boxLength = 200;
int maxIterations = 1;
int screenSize = 400;
float temp = 0;

void setup() {
  size(screenSize, screenSize, P3D);
  noLoop();
}

void draw() {
  background(255);
  translate((screenSize-boxLength)/2, (screenSize-boxLength)/2);
  float xmax = xmin+wh;
  float ymax = ymin+wh;
  float zmax = zmin+wh;
  float dx = (xmax-xmin)/boxLength;
  float dy = (ymax-ymin)/boxLength;
  float dz = (zmax-zmin)/boxLength;
  float x = xmin;
  for (int i = 0; i < boxLength; i++) {
    float y = ymin;
    for (int j = 0; j < boxLength; j++) {
      float z = zmin;
      for (int k = 0; k < boxLength; k++) {
        float rad = sqrt(x*x+y*y+z*z);
        float phi = atan2(z, x);
        float phiLength = sqrt(x*x+z*z);
        float theta = atan2(phiLength, y);
        float nx = x;
        float ny = y;
        float nz = z;
        int n = 0;
        while (n < maxIterations) {
          float nRad = sqrt(nx*nx+ny*ny+nz*nz);
          float nPhi = atan2(nz, nx);
          float nPhiLength = sqrt(nx*nx+nz*nz);
          float nTheta = atan2(nPhiLength, ny);
          nx = cos(nPhi*2)*sin(nTheta*2)*nRad*nRad;
          ny = cos(nTheta*2)*nRad*nRad;
          nz = sin(nPhi*2)*sin(nTheta*2)*nRad*nRad;
          nx += cos(phi)*sin(theta)*rad;
          ny += cos(theta)*rad;
          nz += sin(phi)*sin(theta)*rad;
          if (nx*nx+ny*ny+nz*nz > 4) break;
          n++;
        }
        if (n == maxIterations) point(i, j, k);
        z += dz;
      }
      y += dy;
    }
    x += dx;
  }
  println("Done");
}

It took a little while (a few min) but setting:

boxLength = 500;
screenSize = 800;

Then the rendering section to:

if (n > 10) {
  translate(i, j, k);
  fill(n*3%255, n*2%255, n%255, n);
  box(1);
  translate(-i, -j, -k);
}

Makes a much more reasonable image. Still experimenting with color, transparency, and hopefully soon lighting

huh...
you're checking 500x500x500 points ))