http://www.youtube.com/v/GbF5yceVLcE&rel=1&fs=1&hd=1I wanted to use my improved "Iteration division" that is combining nearby key-colors and combine it with color cycling to make an animation that use many colors. In this animation the iterations are divided with 19 and there are 1024 random key colors, so the result is that 19456 unique colors are used.
To find the end minibrot I just zoomed on random and at e50 I let the automatic Find minibrot find it at e100 something.
But what I didn't realize was that the path I selected, passing near several minibrots and going near one of a minibrot's "tentacle", resulted in a pertubation glitch that was of a different character, and was really difficult to solve.
The automatic glitch solving function is not perfect, and it may never be and it may not even be possible to make it perfect. But the ability to add references manually to solve glitches makes it at least possible to live with a non-perfect automatic function.
In previous animations I have had to examine each key frame and for some 1-10% of them add one or a few references due to glitch blobs, and then update the key frame.
However in this animation, more than half of the key frames had visible glitches, and those frames needed some more than 20 additional references to be solved completely.
This is an example for which no additional reference is added:

At right there is the typical big blob, a result of passing near the elephant valley of a minibrot. But at left, there are reindeer horn shaped glitches, from the previous minibrot's tentacle, and those glitches have pattern inside!! My additional reference function replace pixels with the same iteration count as the reference, and since there are many different iteration counts inside these reindeer horns, many many references needed to be added.
However, in the other thread,
http://www.fractalforums.com/announcements-and-news/superfractalthing-arbitrary-precision-mandelbrot-set-rendering-in-java claude came up with a function to visualize the errors due to the precision limitations in the double datatype. I did a variant that don't use square-roots, it's simply adding the result of
relerr applied on the real and imaginary parts of z for each iteration, and got the following image of the example location

It shows clearly that there are big float-errors inside the reindeer horns, and when the pixel with the most error inside one of them is selected as reference, and the surrounding area with errors more than a certain level is re-rendered, these glitches can be corrected in one step. However the big blob cannot be corrected this way, since also the float-errors appears as a big blob and there is no way to find where to put new reference points. So the solution is to combine the two types of glitch correction methods, and then it is possible to create the perfect image automatically:

So, with this function implemented, only 11 of the 335 key frames in this animation needed to be corrected with a few additional references, and that I can live with
