Master's Thesis On Fractal Coloring Techniques

[juharkonen]

Hi all,
I have recently finished my master's thesis entitled "On Fractal Coloring Techniques" that studies the mathematics of selected coloring algorithms. More information and pdf downloads can be found at
http://www.violetindustries.com/gallery.php?cat=techniques

The reader is assumed to be familiar with calculus and complex analysis and the calculation of fractal images is explained only in the extent necessary to introduce the main concepts and notation.

For fractal math geeks (like myself ) the thesis may offer some interesting new results. In a nutshell it includes
-A thorough mathematical description of how and why the smooth iteration count works
-The secrets of Triangle Inequality Average and Curvature Average colorings revealed
-An appendix illustrating the use of the discussed colorings on a fractal image

The algorithms as well as the image discussed in the appendix are available in the Ultra Fractal Formula Database - see Stripes in jh.ucl
and Pro Gradu Illustration in jh.upr.

[David Makin]

Thanks for posting that Jussi, I didn't know the full derivation for standard smoothing.

Nice to see you using "Autopower" - BTW in addition to smoothing "formulas other than z^p+c" using autopower also smooths z^p+c correctly when using low bailouts.

[lycium]

looks really interesting, thanks for the head's up

(edit: oh, and i see you're a demoscener too! go go finland )

[juharkonen]

When I started writing the thesis, Linas Vepstas' discussion of smooth iteration count was the only proof of its smoothness I could find.
http://linas.org/art-gallery/escape/escape.html
But he left so many details undocumented that I was unable to follow his proofs.

Autopower is a very useful trick as it gives smooth results with almost any divergent fractal formula. And I remember it working even with convergent formulas if you substitute |z| with |z(n) - z(n-1)| (see Ron Barnett's Fibers and Things for an implementation in reb.ucl). It wasn't discussed in the thesis although it is used in one of the figures.

[gandreas]

I printed it out last night and read it over coffee this morning.  It was quite an interesting read (though I'll admit that chapter 5 was bit beyond me - any chance for an English translation?), and I really like the results you got with overlaying multiple stripes.  Thanks for sharing...

[David Makin]

I came up with the "Autopower" idea when I realised that using the actual degree of divergence when bailout occurs would probably fix smoothing on the standard Lambda fractal (on which the degree varies across the Mandelbrot). I then tried it and found it also worked on other fractals - even those involving exp() and the Barnsley types. You'll see that it's implimented in most of my "MMF" formulas for UF 

[HPDZ]

Thanks, juharkonen, for posting this. Great work. It brought together some important fundamentals in how this all works and has some good new ideas.

[Duncan C]

Hi all,
I have recently finished my master's thesis entitled "On Fractal Coloring Techniques" that studies the mathematics of selected coloring algorithms. More information and pdf downloads can be found at
http://www.violetindustries.com/gallery.php?cat=techniques

The reader is assumed to be familiar with calculus and complex analysis and the calculation of fractal images is explained only in the extent necessary to introduce the main concepts and notation.

For fractal math geeks (like myself ) the thesis may offer some interesting new results. In a nutshell it includes
-A thorough mathematical description of how and why the smooth iteration count works
-The secrets of Triangle Inequality Average and Curvature Average colorings revealed
-An appendix illustrating the use of the discussed colorings on a fractal image

The algorithms as well as the image discussed in the appendix are available in the Ultra Fractal Formula Database - see Stripes in jh.ucl
and Pro Gradu Illustration in jh.upr.

This is an old thread, so I hope you see my posting.

I am a software guy, not a mathematician. I haven't had high level math since Calculus 1, and that was a lot of years ago. I find it pretty hard to follow. I could probably wade through it eventually, but time is at a premium these days. Writing fractal code is a hobby, and my day job takes up most of my time.

I am very interested in teaching my app, FractalWorks, how to do triangle inequality average coloring (for standard quadratic Mandelbrot and Julia set fractals.) I already have the option to calculate DE and fractional iteration values. I took a brief look at your paper, and gather that fractional iteration values are a needed to generate triangle inequality average coloring.

Are there any papers on how to go about implementing these coloring algorithms that are less theoretical and more implementation oriented?

I would like to teach my app to offer this sort of coloring rather than using a coloring formula in an existing app like UltraFractal. Can somebody point me to some practical guidance?

[paxinum]

That looks like a nice thesis!
Since you are speaking Swedish, you might be interested in http://www2.math.su.se/~per/files.php?file=Klassiska.Fraktaler[2009][Swe]-PAXINUM.pdf

or at least have some opinions.

[lkmitch]

This is an old thread, so I hope you see my posting.

I am a software guy, not a mathematician. I haven't had high level math since Calculus 1, and that was a lot of years ago. I find it pretty hard to follow. I could probably wade through it eventually, but time is at a premium these days. Writing fractal code is a hobby, and my day job takes up most of my time.

I am very interested in teaching my app, FractalWorks, how to do triangle inequality average coloring (for standard quadratic Mandelbrot and Julia set fractals.) I already have the option to calculate DE and fractional iteration values. I took a brief look at your paper, and gather that fractional iteration values are a needed to generate triangle inequality average coloring.

Are there any papers on how to go about implementing these coloring algorithms that are less theoretical and more implementation oriented?

I would like to teach my app to offer this sort of coloring rather than using a coloring formula in an existing app like UltraFractal. Can somebody point me to some practical guidance?

I'm not aware of many papers about coloring algorithms besides Jussi's thesis and a paper the Javier Barrallo and Damien Jones wrote several years ago.  I've written a few articles on various coloring topics that you can find on my site:

http://kerrymitchellart.com/articles/articles.html


Generally, I frame my thinking about coloring algorithms around what the program needs to actually render a color.  For Ultra Fractal, it's a floating-point variable between 0 and 1 (wraps around the top end but clips at the bottom).  From there, I think about what I can do to a pile of numbers to force it into that range.  For example, when I came up with the Triangle Inequality Average coloring, I knew that the strict boundaries given in the inequality could be mapped to the [0, 1] range and went from there.

I see that you don't want to use Ultra Fractal colorings; you could still use them as a source of inspiration in lieu of more rigorous publications.

[David Makin]

I would like to teach my app to offer this sort of coloring rather than using a coloring formula in an existing app like UltraFractal. Can somebody point me to some practical guidance?

Hi Duncan, here's about the simplest colouring method with added smooth iteration fraction to smooth the results, I hope you can follow it OK:

Code:

SmoothAtan2 {
init:
  complex zold = #z ; for previous z value so we have penultimate z at the end
  int i = 0 ; just an iteration count

loop:
  zold = #z ; store old z - note that because this is a colouring in UF this loop code is *not* called on the bailout iteration
  i = i + 1 ; again this is not called on the bailout iteration, so the value of i in the final section will be zero if the formula bails out on the first iteration

final:
  float lm = log(|#z|)                                         ; log of the final magnitude^2
  float f = log(lm) - log(log(@bailout))
  if i>0                                                            ; if didn't bailout on first iteration
    f = f/log(lm/log(|zold|))                                 ; use estimated divergence as log(|#z|)/log(|zold|)
  else
    f = f/log(@diverge)                                       ; user supplied divergence estimate
  endif

  float a1 = atan2(zold)                                     ; colouring value for penultimate iteration
  if @method==0
    a1 = abs(a1)
  elseif a1<0.0
    a1 = 0.5*(a1 + 2.0*#pi)
  endif

  float a2 = atan2(#z)                                     ; colouring value for final iteration
  if @method==0
    a2 = abs(a2)
  elseif a2<0.0
    a2 = 0.5*(a2 + 2.0*#pi)
  endif

  #index = (f*a1+(1.0-f)*a2)/#pi                     ; smooth - note that the /#pi is just for the atan2 colouring, obviously other colourings may require different scale factors

default:
  title = "SmoothAtan2"
  param bailout
    caption = "Bailout"
    default = 128.0
  endparam
  param diverge
    caption = "Estimated divergence"
    default = 2.0
    hint = "Only used hen bailout occurs on the first iteration."
  endparam
  param method
    caption = "Angle method"
    enum = "Absolute" "All"
    default = 0
  endparam
}

I hope that's clear enough. Obviously more complex colourings will require specific calculations in the loop section for example *but* the principle of having two values for the colouring, one from the penultimate iteration and one from the final iteration that are then mixed using the smoothing fraction method holds for *any* colouring for probably 95% of main formulas.
However as I have said elsewhere this smoothing method only holds at the given level, if you involve the derivative of the results in some way e.g. by turning the colouring into a "slope" method then the breaks at iteration boundaries will reappear.
As far as I know no-one has tried to do a smoothing that will smooth such that the derivative of the resulting colouring is also smooth.

[tit_toinou]

Theses smooth "Average" coloring techniques are awesome for still images.
But when you make a video, it becomes crappy because the parameters need to be fine tuned according to the zoom level.