how would you define a path along mandelbrot border ?

[cKleinhuis]

we all know that the most interesting shapes of the julia renderings are having seeds close, very close to the border of the mandelbrot set, when i was doing realtime julia animation i always wanted
to have a smooth path along the border, but couldnt find any method for it, to create a path, somehow the iteration borders would make good julia pathes, but how would you extract points from this, with the condition that the mandelbrot set is NOT crossed ?
 

[eiffie]

All I can think of is "feeling" your way along. Start on the border and test nearby points in four directions. Bisect the angle between a point in and another out. Even this runs into the problem of creases/spirals where the only way out is back. Hopefully someone can think of a better approach.

[cKleinhuis]

candidates would be all points on a certain iteration bailout band ...

[knighty]

candidates would be all points on a certain iteration bailout band ...

or a certain distance
Some parts of the mandebrot set boudary (main cardioid, main disk...) that have analytical representation could also be used.

[fractower]

A paint algorithm might work. Start with a point within the set an recursively mark neighboring points if they are within the set. Unfortunately this is likely create islands so some more work is needed to find a single bounding path.

You could probably paint the outside as well. It is guaranteed not to produce the same islands as the in set paint. Then combine the two to produce a single bounding path.

[fractower]

I thought about this some more. The islands are only a problem if you want to automatically extract a particular path.

Once you have a 2D array that indicates points of capture and escape, the extraction can be done using a boundary walking state machine. The statemachine starts with the left foot in a capture square and its right foot in an escape square. It examines the two squares in front of it and decides to turn left, turn right or go forward. There are 4 possible inputs but only one is ambiguous. As long as the ambiguous case is handled consistently it will not get trapped in a small inlet/peninsula loop. 

[s31415]

Mmmhhh... if you want to compute an approximate boundary just to make an animation of Julia sets, you don't need to be very precise. A very small change in the position of the seed will translate in changes of small details of the Julia set, that are likely to be invisible in your animation. As a result, your path doesn't really need to follow the boundary accurately. So I would just pick enough points near the boundary and interpolate linearly between them.

But of course, determining the boundary is an interesting problem in itself. As was aready mentionned, the iteration number bands (or smoothed version thereof) provide better and better approximations to the boundary as the number of iterations increases. And I'm not sure what more you could hope. It seems unlikely that there would exist an explicit parameterization.

[eiffie]

I just wanted to implement fractower's algorithm but wound up learning a bunch about how to determine the seed of a julia set. Particularly the number of arms to the spirals tell you the node(bump) and subnodes on the mandelbrot where the seed lies.
<a href="http://www.youtube.com/v/abU1Mv9kmXU&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/abU1Mv9kmXU&rel=1&fs=1&hd=1</a>
I'm now ready to guess the seed value of any julia near the boarder of the mandelbrot! Maybe not an ability for superhero status

[s31415]

Great animation! I must say I'd love to see it computed at a higher iteration number, so that the many spirals get resolved. And maybe with the M-set in a corner, so that it doesn't interfere with the Julias.

[knighty]

that julia looks alive

[David Makin]

When asked to create a long animation (I mean at least 30 mins) for DVD I played around quite a while with morphing Julia Sets with exactly this question in mind - my conclusion was that unless you're desperately concerned with render times and so want to avoid areas of "inside" at all cost then allowing some frames of the animation to be Julias with inside showing actually enhances the video as it adds greater variety.

At the time my PC was *really* out of date and I couldn't possibly have rendered the full-res animations myself and even the guy wanting them couldn't render at anything like the rate we can nowadays so I ended up doing a number of short sequences that had several different start and end frames in common just at low res while creating them (320*240) and then I sent them to the guy and he played around with the order, linking the different sequences until he had a satisfactory result that lasted the required time - he then rendered the same small sequences at full res and then created the final video.

In case anyone's interested, I later played with the sequences a little myself to create a 5min animation for YouTube - please forgive the res (just 240p) and the music too - the choices YouTube had available then were fairly limited :

http://www.youtube.com/user/makinmagicfractals#p/u/61/YlbfYK5YC4o

The animation works best for me to almost anything by Pink Floyd, Tangerine Dream, JM Jarre or the Afro Celt Sound System
In hindsight for this sort of thing I should have written some customised colouring formulas that would have allowed smooth morphing of the orbit trap colouring between different styles e.g. point to line to waves to pinch etc. as that would have improved things a lot !

[hobold]

The idea of accurately tracing the boundary of the Mandelbrot set has been haunting me since more than 20 years. This thread prompted me to begin tinkering again. So I wrote a program that would be guaranteed to be impractical and useless, even if it happened to work reliably.

What it does is to locate the points where equipotential lines (AKA lemniscates, AKA level set borders) intersect field lines (AKA external rays, AKA binary decomposition borders). These points have the nice property that they are distributed densely in areas where the border is convoluted, but spaced sparsely in regions of low detail.

Nevertheless, the program is near useless, because the number of such points grows proportionally to 2 to the Nth power, where N is the number of iterations. So you cannot get very close to the border of the actual set before computation times and memory consumption explode. Furthermore, in highly detailed areas, adjacent border points move close to each other as the number of iterations increases. So you tend to run out of numerical precision rather sooner than later.

The good news is that you don't have to bother optimizing that kind of program much. A factor of two speedup only brings you one iteration closer to the actual border.

With double precision floating point, I could only get as far as 27 iterations. That takes a bit over an hour to compute, and a bit more than 6GB of RAM. Memory consumption could probably be reduced by a factor of 2 or 4, but what for? The resulting polylines are always huge and cannot really be optimized away.

Anyways, attached is an image of that final borderline number 27.

If anybody is still interested after my anti-advertisement, I could clean up the source code a bit, and let you experiment with it. It's a very basic command line program with no platform specific code.

[cKleinhuis]

nice, the aproach seems to work, although it is a pitty how hard it is to calculate closer lines of that

cleaning out some pixels and getting a smooth julia transform path, with making sure that no "inside" is crossed would now be the next step

would love to see an animation of that julia path...

[hobold]

Well, if smooth animation of morphing Julia sets is the primary purpose, you'd probably be better off with a path based on a distance estimator. You would be at a (more or less) constant distance from the Mandelbrot set, and the path would inherently be smoothed. I don't know how to compute something like that with any kind of consistent accuracy, though.

The level set curves (like the one I showed above) are not that good for Julia morphs, in my opinion. They spend a lot of time near antennas and spikes, but cannot closely approach areas like the "neck" between main cardioid and largest disk. A path at constant distance would still avoid the "neck", but would not focus as much on the spikes.

(The level set curves were relatively easy to compute because the vertices along one level make excellent starting points for the search of next level's vertices. That way, I can be confident in the accuracy of the algorithm, even though I do not have any analytical guarantees to rely on. It's a dumb, straight forward method that keeps adapting, refining, and correcting itself as it goes.)

You sure you don't want to play with the source code yourself, no matter the limitations?

[eiffie]

code please!