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

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.

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

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. 

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

that julia looks alive

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.

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?