A basic fractal consists of a self-similar component called an initiator and then a generator which
is used to replace sub-components of the initiator which we use recursively.
For the Koch snowflake, the initiator is the triangle on the left. It is shape `S_0`.
To generate `S_(n+1)` from `S_n`, we take an edge in `S_n` and replace it with an appropriately scaled and rotated copy of the generator. The first three steps of this are illustrated above.
The Koch snowflake itself is the limit of this process.
Classifications of Fractals
A self-similar fractal is one where the parts are scaled down versions of the whole object. For example, pick one "side" of the Koch snowflake. This is a rotated version of the Koch curve. Take an edge `E` in `S_n` and look what happens to it for iterations `n-> infty`. It converges to a scaled rotated variant of the Koch curve.
The generator step can be viewed as applying a sequence of functions to a set. I.e., `S_(n+1) = f_1(S_n) cup f_2(S_n) cup ... cup f_k(S_n)`. Here `k` is fixed.
In the case, of the Koch curve `k` is `4` and each of the `f_i` is a consists of a translation, rotation, and scaling and the scaling factor is the same for each `f_i`.
So the map `f_i` is affine. So we call the fractal self-affine.
There are simpler maps where we only translate and scale called dilations. The Cantor dust example of last day was a fractal made with a dilation.
Suppose had two possible generator maps to choose from at a given step. Either `S_(n+1) = g_1(S_n) cup g_2(S_n) cup ... cup g_(k')(S_n)` or `S_(n+1) = f_1(S_n) cup f_2(S_n) cup ... cup f_k(S_n)` and we flip a (maybe biased) coin to decide which to use. The resulting fractal would be a statistically self-affine fractal. In general, rather than just two possible choice we might have `m > 1` choices.
You might use statistically self-affine fractals when modeling things like tree braches, where the branching pattern might be from a fixed list of possible ways a branch can split into sub-branches.
One can also have invariant fractal sets, `A`. This just says that applying the generator to the final set `A` just results in the set back, however, the mapping performed by the generator map be a non-linear transformation. An example of this is the Mandelbrot set where the operation at each step involves squaring (so it is a self-squaring fractal.)
Quiz
Which of the following statements is true?
Dynamic reflection mapping as described in class is a single pass texture mapping technique.
Projection mapping as described in class is a single pass texture mapping technique.
A quadric is a 3D solid object with flat faces whose boundaries are given by straight edges.
Measuring the Dimension of a Fractal
When we measuring the amount of space a object occupies in `k`-dimension, we often this of size in terms of coverings.
We know how to measure the volume of a `k`-dimensional cube. So we imagine covering the object with `k`-dimensional cubes, then summing up their volume. The infimum of the volumes we gets over all possible coverings of the objects is its `k`-dimensional volume.
If this value is `0` we say the object has measure 0 in `k`-dimensions.
For example the unit line segment has measure `0` in 2-dimensions, but measure 1 in one dimension.
Fractals curves can have weird behaviors. For example, at any iteration the shape one has might be 1-dimension, but the limit of doing the iteration might "fill" some fixed area of space.
Various notions of fractional dimension have been used to capture the true "dimensionality" of a fractal object.
The easiest of these to compute is the fractal similarity dimension or just similarity dimension.
This can be used for self-affine fractals. Let `k` be the number of `f_i` in the generator of such a map (for the Koch map `k=4`), and let's assume for now each `f_i` does the same scaling `s`. For the Koch map this was true and the scaling was `1/3`. Then the fractal dimension is defined to
be `D= (ln k)/(ln(1/s))`. So for the Koch curve about `1.26`.
Suppose when we were calculating the size of the rectangles in the covering of an object we powered them by some `s >0`. Then we added these together as before and took the infimum. It turns out there is only one choice of `s` which can give a non-zero, non-infinite answer in general. This value is called the Hausdorff dimension of the set. If we went very far astray we could show these two notions of dimension agree for self-affine fractals.
Uses of Fractals
We already said we can use statistically self-affine fractals to model things like leaves or trees or plants.
We can also use fractals to generate terrain.
There are two common ways to do this: one uses fractional Brownian motion or Perlin Noise, the other technique uses a
random displacement method
Fractional Brownian Motion Terrain
Let's consider the one dimensional case (useful for a side-scroller, like Defender).
We pick points along the x-direction with a fixed period, say every half unit.
Then we randomly choose heights between some ranges say `(-0.5, 1)` for each of our x-values.
This is called doing a random walk, by shortening our period, and piece-wise connecting the (x,y) points we get a more jaggy curve and it will tend to have a non-zero fractional dimension.
Less frequently sampling makes the curve less jaggy.
Rather than piece-wise interpolating through the points. We can interpolate through them using B-splines to make things smoother.
The Perlin noise technique is to take several such curves with different sampling rates and sum them to get a final curve.
For example, we might make 1 smooth curve sampling every 0.5, another every 1, yet another every 2, every 4, and so one up to a fixed number of doublings. Summing smooth curves is straightforward, and gives us a final smooth curve out.
If we generalize this to heights over a two dimensional rectangle and use Bezier-patches then one gets a terrain.
Random Displacement Method
Again if we start in one dimension with a line segment with coordinates `(a, y(a))`, `(b, y(b))`
We take these two endpoints and then displace the midpoint from `((a+b)/2, (y(a)+y(b))/2)` to
`((a+b)/2, (y(a)+y(b) + r)/2)` where `r` is a chosen from a Gaussian distribution between `0` and `|(b-a)|^(2H)`
where `H = 2- D` is the fractal dimension we want our terrain to have. The new shape is the original end points connected
to this new mid point.
We then iterate this on each of the sub-segments
In two dimensions we can sub-divide the plane into triangles, calculate its centroid, displace the centroid by
a random value and repeat on each of the resulting sub-triangles.
