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

Okay, yesterday I had a really weird idea, and I'm pretty sure no-one has ever done something like this before.

For each pixel, use Distance and Direction Estimation to find the vector to the nearest point in the Mandelbrot set (or outside the set, if the pixel starts out inside). Then, use this new vector (a complex number, really, not a vector) as your next pixel. Repeat the process, over and over. If you begin with a pixel in the set, it's "bailout" occurs as soon as some new iteration is outside the set; vice versa if your initial pixel is outside the set.

Note that this idea could be applied to any fractal; a Julia set, for example, where you estimate the distance to the border.

Simply doing this may not be very aesthetic; maybe something like (say) rotating the vector 90 degrees and multiplying the magnitude by sqrt(2) would produce more intereting results, or halving the radius of the pixel (keeping the angle the same) and then shifting it according to the vector. Or maybe instead of halving, taking the reciprocal of the logarithm of the pixel. I don't know what would produce interesting results.

The coloring would be done by the "iterations" it takes to bailout.

Sadly, there are several features here I wouldn't be able to code; for example, I don't know any formula (maybe there isn't one?) to approximate the direction to the border to the mandelbrot set; I also don't know of any way to do distance estimation from the interior of the Mandelbrot. I suppose those could be done with a nested loop, but in general I only program using FractInt format...I've never changed to any higher level language. Any help generating pictures like this would be greatly appreciated. 

Yes, maybe a small scale it would become very dusty, but at least from a distance (this is with the "offset" idea) I think it would take an interesting shape; for points very far, for instance, the iterations would be approximately proportional to the distance; then, as, iteration by iteration, it got closer to the mandelbrot, it would start to take interesting bifurcations. Also, I think the dust might eventually resolve itself into interesting shapes given enough zoom - Just like the Logistic map's chaotic parts look like pure white noise, but reveal a infinite series of windows if you zoom in. Of course, I hope this would be more interesting than the logistic map.

But it wouldn't actually be in pixels, the vector (difference?) would be a complex number. 0.0+1.5i would give a difference of 0.5i no matter how much you zoomed in.

Yup, that's exactly what I want to do. And yes, I am mad. Insanity produces some pretty interest fractals, occasionally... isn't the very concept of a fractal somewhat insane? 

I'm not sure if I'd call it an "iterative loop with recursion", I just see it as two nested loops instead of single one. And, if there is no simple formula for direction estimation, then that would have to be calculated manually by another loop, a "sibling" in the loop structure to the actual squaring/adding loop. And if you think that I belong in a mental hospital: things like that have been one before. Take a look at the Supermandelbrot and Superjulia; they also use two nested loops.

Well, I've started playing round with how to do the formula... even very simple things to test parts of the code aren't working, though. In order to make the code easier to write, I defined several new functions. Here's some code to test them, which seems to deadlock every time it tries to compute a point within the set. Even if I only set iterations to two, and I haven't zoomed at all!
VectorToMandelbrot {
global:
init:
float func MandelbrotDistance(const complex c, const int MaxIter)
  DpDc=1
  t=0
  repeat
   t=t^2 + c
   Iter=Iter+1
   DpDc=2*DpDc*t + 1
  until (|t| > 4) || (Iter == MaxIter)
  return log(|t|)*sqrt(|t|/|DpDc|)
 endfunc
 bool func InMandelbrot(const complex c, const int MaxIter)
  t=0
  repeat
   t=t^2 + c
   Iter=Iter+1
  until (|t| > 4) || (Iter == MaxIter) ;@InnerIter)
  return (Iter == MaxIter) ;@InnerIter)
 endfunc
 int func MandelbrotEscapetime(const complex c, const int MaxIter)
  t=0
  Int Iter = 0
  repeat
   t=t^2 + c
   Iter=Iter+1
  until (|t| > 4) || (Iter == MaxIter)
  return Iter
 endfunc
loop:
bailout: InMandelbrot(#pixel,10)
}

Basically, this means that at the end of each iteration it runs the Mandelbrot forumla with 10 iterations. Obviously this doesn't do anything more than make a Mandelbrot set that takes longer to load, but it shouldn't deadlock each time it reaches a pixel inside. Help please?