Oooh, I understand where you're coming from now. ~head-desk~


(TL;DR) Summary:
If I understand correctly, what you're saying holds true for a random fractal such as brownian motion or fractal terrain, but I'm unsure if it holds true for an L-system, which is what (I think) my algorithm actually is.

Most of my knowledge about this comes from wikipedia and you seem to know more on the subject; I don't suppose you've got some good links/books to read on the subject to try and learn more?

Also, after bouncing this around, I can abstract the entire method into a more universal and faster method. Awesome! Exactly what I came here looking for. Thank you.


The Long Path to Conclusion:

What you're saying is that a fractal synthesis algorithm that works on scale/add can be stopped at an octave n to produce an image of n^sqrt(k) resolution without aliasing, where k is the number of children that occur at each octave (in the trivial case where we divide into four quadrants, two; if it were instead dividing into nine equal children it'd be different). Understood and agreed. And what you're saying about blurring and thresholding does hold in this case and makes sense (although I'm still trying to wrap my head around if it's true in all cases...).

The crucial difference is that this fractal generation isn't based on scale/add (I think, if I understand you correctly). It's closer related to an L-system; using the terminology on the wiki page, the algorithm is a non-deterministic L-system with a stochastic and context-sensitive grammar. Fractal in a completely different sense, but still fractal.

Although, most of my knowledge about this comes from wikipedia and you seem to know more on the subject; I don't suppose you've got some good links/books to read on the subject to try and learn more?

The system in L-system terminology:

Variables Squaresize, Circlesize
Constants Size Factor F; Variance Factor V; Random Gaussian with mean 0, stddev 1, g
Start Square (0.5), Circle (0.5)
Rules Squaresize = s (0.5)-> SquareF * s + V * s * g
Squaresize = s (0.5) -> CircleF * s + V * s * g
Circlesize = s (0.5) -> SquareF * s + V * s * g
Circlesize = s (0.5) -> CircleF * s + V * s * g

Also, after formalizing that, I just realized I could abstract the entire method into a more universal method that I could re-use later on that is also probably faster. Awesome! Exactly what I came here looking for.