# In by Out Again

Arbitrarily-Deep Zooming on Iterated Function Systems by 'Self-Similarity Jumping'

BSc Wiebe-Marten Wijnja

## Summary

• Iterated Function Systems?
• Existing rendering methods
• New approach
• Results & Remarks
• Conclusion

### What is an Iterated Function System?

• What: Mathematical concept, related to set theory and constructing fractals
• Why: physics, image compression, gene structures, beauty
• How:

### What is an Iterated Function System?

• What: Mathematical concept, related to set theory and constructing fractals
• Why: physics, image compression, gene structures, beauty
• How:

"repeatedly apply the collection of mappings"

### What is an Iterated Function System?

• What: Mathematical concept, related to set theory and constructing fractals
• Why: physics, image compression, gene structures, beauty
• How:

iterate

system

(transformation) functions

"repeatedly apply the collection of mappings"

## Transformation function (mapping)

image $$\longrightarrow$$ transformed image

image: Set of points

{

}

,

## Formally

• IFS $$\mathcal{F} = \{ f_i : \mathcal{M} \rightarrow \mathcal{M}\}_{i=1}^N, N \in \mathbb{N}$$(mappings are required to be contractive)

• one iteration: $$\mathcal{S}_{n + 1} = \bigcup_{i=1}^{N} f_i(\mathcal{S}_n), n \in \mathbb{N}$$

• Attractor: $$\mathcal{A} = \lim_{n \rightarrow \infty} \mathcal{S}_n$$

($$\mathcal{S}_0$$ can be an arbitrary non-empty set of points)

## Formally

• IFS $$\mathcal{F} = \{ f_i : \mathcal{M} \rightarrow \mathcal{M}\}_{i=1}^N, N \in \mathbb{N}$$(mappings are required to be contractive)

• one iteration: $$\mathcal{S}_{n + 1} = \bigcup_{i=1}^{N} f_i(\mathcal{S}_n), n \in \mathbb{N}$$

• Attractor: $$\mathcal{A} = \lim_{n \rightarrow \infty} \mathcal{S}_n$$

($$\mathcal{S}_0$$ can be an arbitrary non-empty set of points)

!!

## Formally

• IFS $$\mathcal{F} = \{ f_i : \mathcal{M} \rightarrow \mathcal{M}\}_{i=1}^N, N \in \mathbb{N}$$(mappings are required to be contractive)

• one iteration: $$\mathcal{S}_{n + 1} = \bigcup_{i=1}^{N} f_i(\mathcal{S}_n), n \in \mathbb{N}$$

• Attractor: $$\mathcal{A} = \lim_{n \rightarrow \infty} \mathcal{S}_n$$

($$\mathcal{S}_0$$ can be an arbitrary non-empty set of points)

!!

👌

## Rendering an IFS's attractor

$$t(t(t(\mathcal{S}_0))) \cup t(t(l(\mathcal{S}_0))) \cup \ldots r(r(r(\mathcal{S}_0)))$$

how to find all transformation-sequences?

### Transformation-sequences as trees

$$t(t(t(\mathcal{S}_0))) \cup t(t(l(\mathcal{S}_0))) \cup \ldots r(r(r(\mathcal{S}_0)))$$

### Depth-First

• Depth-First:
•   $$\mathcal{O}\big(\log{P}\big)$$ memory
• $$\mathcal{O}\big(P\big)$$ memory,
• but able to stop interactively

## Can we do better?

• Both use quite a bit of memory
• Difficult to parallellize (reason: coordination)*

* There is one cool (but complex) implementation,

c.f. Orion Sky Lawlor. "GPU-accelerated rendering of unbounded nonlinear iterated function system fixed points"

$$t(t(t(\mathcal{S}_0))) \cup t(t(l(\mathcal{S}_0))) \cup \ldots r(r(r(\mathcal{S}_0)))$$

$$t(t(t(l(\mathcal{S}_0)))) \approx t(t(t(r(\mathcal{S}_0))))$$

[

[

indistinguishable!

$$t(t(t(\ldots)))) \rightarrow r(t(t(t(\ldots))))) \rightarrow t(r(t(t(t(\ldots)))))) \rightarrow l(t(r(t(t(t(\ldots)))))))$$ etc.

[

[

[

[

ttt, rtt, trt, ltr, etc.

### Yes!

• $$\mathcal{O}(1)$$ memory
• Simple implementation
• including a parallel one
• but needs
• enough points
• fine-tuned probabilities

## the chaos game

  N: the number of mappings of the IFS;
z: a single arbitrary starting point;
v: the camera's view transformation;
m = 0;
for m ∈ [0..n + P) {
i: a random integer between 0 and N;
if(m >= n){
render(v(z)) cumulatively;
}
z = fᵢ(z);
}


## New Approach

1. Use a point cloud
• moving the camera does not change points
2. 'self-similarity jumping'
• Too little detail? (ab)use self-similarity to (re)use more points!
• Based on the Chaos Game
• Meant for animations/interaction

## Self-Similarity Jumping

"inside", "outside", "overlapping"

  n: the number of mappings the IFS consists of;
v: the current camera's view transformation;
s: a stack of jumps made so far;
for i <- [1, ..., n] {
if isInvertible(fᵢ) and isInside(v⁻¹, fᵢ) {
push(s, fᵢ);
v = fᵢ⁻¹ ◦ v;
break;
}
}

  v: the current camera's view transformation;
s: a stack of jumps made until now;
if notEmpty(s) and isOutsideUnitSquare(v⁻¹) {
f = pop(s);
v = f ◦ v;
}


Jump 'up'

Jump 'down'

## Implementation

• Accelerate library
• Haskell EDSL $$\rightarrow$$ LLVM $$\rightarrow$$ NVidia PTX ('GPU assembly')

## Results & Remarks

• Point clouds take a lot of GPU memory
• Self-similarity jumping has two restrictions

Cannot be used on 'borders'

Points of single subtransformation visible

Points of multiple subtransformations visible: problem

Both cases are unfortunately rather common

## Conclusion

• The technique works, but has limited applicability
• point clouds take a lot of memory
• self-similarity jumping cannot be used everywhere

## Summary

• Iterated Function Systems?
• Existing rendering methods
• New approach
• Results & Remarks
• Conclusion

# Thank you!

### Thanks to

• Jiří Kosinka for answering all my questions, and sheer limitless  patience
• Luc, Jeroen, Sietze and Michiel for kindling my love for computer graphics, visualization and clever algorithms
• 2D affine transformations (slide 7): Cmglee

• IFS construction (slide 8): Scott Draves

By qqwy

• 277