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

I am following the classic Fractal Flame white paper by Draves and Reckase (http://flam3.com/flame.pdf) with the goal of understanding what I'm doing.  I've been writing a program to make the flame renders but have already been stumped by something that must be so trivial.

In the paper it's mentioned that an affline transformation is applied to x and y, and the affline function takes the form of f(x,y) = (ax + by+ c, dx + ey + f).  This transformation to the input and the coefficent values (a thru f) seem critical but I can't figure out how I'm supposed to generate values for a thru f, are they random, random on the bi-unit cube, is there somewhere I could read more about this? 

I am familiar with affline transformations in regards to more modern rendering APIs (i.e. glTranslate*, etc).  Is it the case that I apply a random number of random transformation matrices?  That would build my 2x3 matrix of my coefficient values and allow me to transform x and y, but it seems so arbitrary and completely unspoken in the paper.  I feel like that guess is a little too far out there.

Thanks

It can take a while to get your head around plain IFS never mind flames.

The best option is to look at the IFS versions of classic 2D fractals - Sierpinski triangle. Manger Carpet etc. and try to follow how the application of the transforms works.
The thing to remember is that the easiest visualisation of the results is not by considering the chaos-game render method but rather the deterministic method - here you start with a point on the fractal and perform the whole tree of transforms to a given depth plotting each point - the chaos game method was suggested by Michael Barnsley when he realised that any sequence of the particular transforms will produce points on the attractor and if controlled correctly simple random selection would build the "complete" result over time.
The difference between the deterministic method and the chaos game is that the deterministic method provides very rigid control over the resolution of the image produced whereas the chaos game is generally a little more "lax" and unless the random generator used is near perfect, often reveals bias in the results e.g. one corner of a Sierpinski being less dense than another.

So for a 3-transform fractal such as the Sierpinski Triangle, the tree of transforms for a deterministic render would be a little like this:

                                                                                     start p
                                   p0                                                 p1                  p2
         p00                    p01                     p02            p10   p11    p12       p2x
p000  p001 p002  p010 p011 p012  p020 p021 p022  p10x  p11x  p12x     p2xy
etc.

Note that I've abbreviated the branching/nodes of the tree to the right simply as it doesn't fit otherwise
Of course with a standard IFS of n transforms there are n^d nodes at each depth d.

Also understanding affine transforms that don't involve rotations or skews is fairly easy, what happens when rotations are added is somewhat more complicated
See: http://www.meden.demon.co.uk/Fractals/

Also for IFS involving transforms of differing scale then the depth to go down each branch of the IFS tree in deterministic rendering to produce an image to a constant resolution/density depends on the scales involved - analogous to the random weightings used to produce consistent/correct results when using the chaos game method.

Also I now personally prefer rendering even IFS using the escape-time method (i.e. reversing the usual IFS transforms) as this is far simpler to convert to OpenGL/OpenCL/CUDA etc. - the drawback being that the stadard "flame" colouring method is far from easy to do this way, though something similar is not impossible

From my understanding of the white paper I need know a, b, c, d, e, and f to be able to generate a flame (as described in the paper), the paper does mention the convenience of contractive transformations.  How would I find the values of a, b, c, and d without a guess-and-check strategy (find random values within a logical range; check if det(matrix) >=1; repeat)?

If I'm reading what you wrote correctly, the idea is to find 1 set of coefficients (for all a thru f) and just use that.  From my reading of the paper I thought the affline transform was generated and then applied each iteration, as in the pseudo-code it falls within the loop.  But maybe it means you apply the same affline transform each iteration and then pick a variation.  That might be where I went askew (affline xform pun!)

Thanks!

@nomad the 6 parameters ( a,b,c,d,e,f) stand for the standard IFS fractal, with which the for example the fern fractal can be modelled (got that? please ask!)
the whole thing about the flame algorithm is: "do not just use affine transformations, allow all transformation..." <- this is it ... but: "...and as a hint take care that
those functions do show a contractive behaviour ( for mathematicians: determinant of matrix>0 ) with that is meant that scale functions lead
to smaller copies, e.g. scale 0.999 ... and btw, it is the linear component that makes it chaotic )

Well it's really straightforward - you start with a point on the attractor - this can usually be gotten by solving p=p.T for x and y where p is (x,y) and T is any one of the transforms in the IFS/flame.
Then you apply all n transforms to this giving n new points p.T1, p.T2....p.Tn and plot them (obviously using the #hits method for flames).
Now repeat for *all* the new points giving p.Ta.T1 through p.Ta.Tn where Ta is each of the 1st depth transforms.
The only other important piece of information is to consider the scale change at each depth for each separate branch - the greater the reduction in scale the sooner you can prune the branches of the tree and to a finite resolution there's a given depth for all transforms provided they're contractive.
e.g. if you have 3 transforms in an IFS one of scale 0.8, one of scale 0.5 and one of scale 0.3 and you need an overall scale factor of 0.1 for the resolution you want for the final image then on the branch where you only perform the first transform would need to go down to depth 11 (for an overall scale of 0.8^11) on the branch using only the second transform with scale 0.5 you'd need to go down to depth 4 (for an overall scale of 0.5^4) and for the branch using only the third transform with scale 0.3 you'd only need to go to depth 2 i.e. overall scale 0.3^2.
All the rest of the tree would require various depths between these values depending on the applied transforms on each branch at each depth.

The required depth for a given detail level on a given fractal depends on the dimensionality of the math (i.e. 2D for x,y, 3D for x,y,z etc.) and the actual fractal dimension of the fractal itself - the lower the fractal (Hausdorf) dimension of the IFS then the less far down the tree we need to go - it's possible to compute the fractal dimension of an IFS correctly as follows:

D = log(s0)/log(p0) = log(s1)/log(p1) =.....log(sn)/log(pn)

where p0+p1+...+pn=1

Where s0 to sn are the scales and p0 to pn are the probabilites that would be used in the chaos game - solving the above gives the probablities and the dimension D which can then be used to control the depth in the deterministic method by giving the required overall scale factor based on the dimension, the pixel resolution and the zoom/magnification.

I hope that helps, don't have time to give more detail atmo....

Edit: Apologies but this is just "off the top of my head", I've just corrected the above by adding the log()s - also it's possible I may have the scale/probability equation the wrong way up i.e. it maybe should be probability/scale but I guess if it gives a dimension >1 for the cantor set then you'll know it's upside-down

Thanks for the info.  That makes sense, I should probably go download and play with some flame generating programs.