Dr. B.Raghu Professor / CSE Sri Ramanujar Engineering College
Dr. B.Raghu Professor / CSE
Sri Ramanujar Engineering College
TopicsWhy fractals?Fractal DimensionMandelbrot SetFractal Applications
04/21/23 Dr. B. Raghu Professor/CSE 2
Fractals?Fractal geometry of nature and chaos
The “middle ground of ‘organized’ or ‘orderly’ geometric chaos” (Mandelbrot 1989)
Derived partly “because of the difficulty in analyzing spatial forms and processes” (Lam and Quattrochi 1992)
Pack an infinite amount of length into a small finite area, similar to the coastline scale issue (Flake 1998).A 1 inch Koch curve at 100 iterations would
stretch around the earth 40,000 times.
04/21/23 Dr. B. Raghu Professor/CSE 3
Fractal Dimension
04/21/23 Dr. B. Raghu Professor/CSE 4
1 Dimension (line) 2=21
2 Dimensions (square) 4=22
04/21/23 Dr. B. Raghu Professor/CSE 5
3 Dimensions (cube) 8=23
1 Dimension1 Dimension 2=22=211
2 Dimensions2 Dimensions 4=24=222
3 Dimensions3 Dimensions 8=28=233
d Dimensionsd Dimensions n=2n=2dd
Number of copies made by doubling
= 2dimension
04/21/23 Dr. B. Raghu Professor/CSE 6
Fractal Dimension (Sierpinski Triangle)
3=2?
1 Dimension1 Dimension 2=22=211
F DimensionF Dimension 3=23=2??
2 Dimensions2 Dimensions 4=24=222
3 Dimensions3 Dimensions 8=28=233
d Dimensionsd Dimensions n=2n=2dd
Calculating Dimension with LogFor a, the original
segment is ¼ of the line length.
For b, the original square is ½ of its side.
For c, the original curve is 1/3 of the length of the iterated curve.
04/21/23 Dr. B. Raghu Professor/CSE 7
(Lam and Quattrochi 1992)(Lam and Quattrochi 1992)
Fractal DimensionIn fractal geometry, fractal curves are
between dimension 1 and 2, and fractal surfaces are between dimension 2 and 3.
Coastlines typically are about fractal dimension of 1.2, and their relief dimension is about 2.2.
Fractal dimensions of 1.5 and 2.5 are too large, or irregular, for modeling earth features.
Fractal dimension is an indicator of complexity (Zhou and Lam 2005)Image Characterization and Measurement
System (ICAMS) for dimension (Ibid)04/21/23 Dr. B. Raghu Professor/CSE 8
The Mandelbrot SetXt+1 = xt
2 + c, where c = some imaginary number.Ex. – for c = i, x0 = 0
X1 = 0 + i
X2 = i2 + i » -1 + i
X3 = (-1 + i)2 + i » i2 – 2i + 1 + i » -i …..
Points within the Mandelbrot set are black.
04/21/23 Dr. B. Raghu Professor/CSE 9
Fractal ApplicationsCategorization of phenomena using
dimension similarity.Simulation (coast lines, stream patterns,
surfaces and terrain, etc.)Simulated landscapes have been used to model
habitat destruction (Malanson 2002).Art
04/21/23 Dr. B. Raghu Professor/CSE 10
Fractal Art
04/21/23 Dr. B. Raghu Professor/CSE 11
Fractals and HollywoodStar Trek – Genesis
EffectStar Wars – Death
StarThe Last Starfighter
– LandscapesThe Perfect StormApollo 13Titanic
04/21/23 Dr. B. Raghu Professor/CSE 12
Fractal geometry
Effective way to represent natural objectsRepresents phenomenon w/ concepts of
fragmentation small chunks
Self Similarity similar small building blocks used repeatedly
Fractal pattern generation
Initiatorthe basic element
Repetitorway in which basic element is repeatedly
appliedImportant idea is recursion
I.e. do againfor the definition of recursion - see recursion
Fractal patterns can beDeterministic
Repetitor is same each timeStochastic
some part of repetitor varies randomly
Space filling curvesfirstly - whyneed ways to refer to specific tiles (cells)
in a matrixone (obvious) way is by x and y
coordinates
0
1
2
3
0 1 2 3
Problem w/ obvious wayrequires storage of two numberscannot determine neighbors w/out
computationalternative would permit easy spatial
indexing
Alternatives to x,yrow orderrow prime orderCantor diagonal orderspiral orderwe are generally concerned w/ “space filling curves”
Peano orderingPeano ordering permits use of a key to stand
for 2 (or more - if object is volume) dimensions
Peano key is derived using bit interleaving
0
1
2
0 1 2 3
Bit interleaving
0
1
2
0 1 2 3
3
00 01 10 11
X 0 0 1 1 (3) Y 0 0 1 0 (2)
X
0 0 0 0 1 1 1 0
Topologyrelationships in space based on relative
positionsabsolute position
Thing A is at x=4, y=5 and thing B is at x=3, y=7
relative positionthing A is near thing B
removal of descriptive geometry
Graphsnot x/y graphsbut topological graphs they reflect relationshipselements
intersections or endpoints of lines (vertices)lines called edges (but sometimes arcs or
chains)separate links or disconnected sets of lines
called subgraphsvacant spaces (faces) between or outside edges
Isomorphic graphs
two graphs are isomorphic if there is a one-to-one correspondence between edges and vertices
shapes can be quite different
Graph types
loop, circuit or cyclic graphsone vertex connected to itself without the need
for traversing one edge in both directions highway systems, electrical systems
tree graphgraphs without loops or cycles
rivers
directed acyclic graphno circuit but have directed edge(s)directed edge is simply an edge with direction
associated sewer lines
Some special tree types
spanning treeeach vertex must be connected to at least one
other vertex
traveling salesmanmust be able to return to starting point w/out
retracing an edge
radial treesall peripheral vertices connect to central vertex
Properties of graphsdegree of a vertex
number of edges that connectfor directed graphs number of in and out edges
these numbers can be used to assess the overall character of a networkminimum/max degree, average degree etc.
can use these measures to compute Euler number
Euler numberV + F = E + Swhere
V is total number of verticesE is total number of edgesF is number of facesS (or G) is Euler number
if area outside graph is a face S = 2 otherwise 1
Computation of Euler numbers S= 1 if “outside” is not counted as a face and S=2 if “outside” is counted as a face
V=4, E=4, F=2, S=2V=6, E=5, F=2, S=1
V=4, F=2, E=5, S=1
V=9, F=3 E=11, S=1
• FRACTAL LANDSCAPES
• FRACTAL IMAGE COMPRESSION
Dr. B.Raghu Professor / CSE
Sri Ramanujar Engineering College
Review:
Two important properties of a fractal F
• F has detail at every level.
• F is exactly, approximately or statistically self-similar.
Fractals are now used in many forms to create textured landscapes and other intricate models. It is possible to create all sorts of realistic fractal forgeries, images of natural scenes, such as lunar landscapes, mountain ranges and coastlines. This is seen in many special effects within Hollywood movies and also in television advertisements.
Fractal Landscapes
A fractal landscape created by Professor Ken Musgrave (Copyright: Ken Musgrave)
A fractal planet.
Simulation process
First:
Already known
The average of the 2 neighbor blue points plus r
The average of the 4 neighbor red points plus r
This random value r is normally distributed and scaled by a factor d1 related to the original d by
d is the scale constant.H is the smoothness constant.
/ 21 1
1~ (0, ) ( )
2Hr N d d d
We can now carry out exactly the same procedure on each of the four smaller squares, continuing for as long as we like, but where we make the scaling factor at each stage smaller and smaller; by doing this we ensure that as we look closer into the landscape, the 'bumps' in the surface will become smaller, just as for a real landscape. The scaling factor at stage n is dn, given by
/ 21( )2
nHnd d
Simulation result by MATLAB
Using a 64x64 grid and
H=1.25d=15
FRACTAL IMAGE COMPRESSIONWhat is Fractal Image Compression ?
The output images converge to the Sierpinski triangle. This final image is called attractor for this photocopying machine. Any initial image will be transformed to the attractor if we repeatedly run the machine.
On the other words, the attractor for this machine is always the same image without regardless of the initial image. This feature is one of the keys to the fractal image compression.
How can we describe behavior of the machine ? Transformations of the form as follows will help us.
Such transformations are called affine transformations. Affine transformations are able to skew, stretch, rotate, scale and translate an input image.
M.Barnsley suggested that perhaps storing images as collections of transformations could lead to image compression.
i i ii
i i i
a b ex xw
c d fy y
Iterated Function Systems ( IFS )
An iterated function system consists of a collection of contractive affine transformations.
For an input set S, we can compute wi for each i, take the union of these sets, and get a new set W(S).
Hutchinson proved that in IFS, if the wi are contractive, then W is contractive, thus the map W will have a unique fixed point in the space of all images. That means, whatever image we start with, we can repeatedly apply W to it and our initial image will converge to a fixed image. Thus W completely determine a unique image.
1
(*) (*)n
ii
W w
( )| | lim ( )nox
W f W f
Self-Similarity in Images
We define the distance of two images by:
Original Lena image Self-similar portions of the image
JAVA
( , )( , ) sup | ( , ) ( , ) |
x y Pf g f x y g x y
where f and g are value of the level of grey of pixel, P is the space of the image
Affine transformation mentioned earlier is able to "geometrically" transform part of the image but is not able to transform grey level of the pixel. so we have to add a new dimension into affine transformation
Here si represents the contrast, oi the brightness of the transformation
For encoding of the image, we divide it into:
• non-overlapped pieces (so called ranges, R)
• overlapped pieces (so called domains, D)
0
0
0 0
i i i
i i i i
i i
x a b x e
w y c d y f
z s z o
Encoding Images
Suppose we have an image f that we want to encode. On the other words, we want to find a IFS W which f to be the fixed point of the map W
We seek a partition of f into N non-overlapped pieces of the image to which we apply the transforms wi and get back f.
We should find pieces Di and maps wi, so that when we apply a wi to the part of the image over Di , we should get something that is very close to the any other part of the image over Ri .
Finding the pieces Ri and corresponding Di by minimizing distances between them is the goal of the problem.
Decoding Images
The decoding step is very simple. We start with any image and apply the stored affine transformations repeatedly till the image no longer changes or changes very little. This is the decoded image.
First three iterations of the decompression of the image of an eye from an initial solid grey image
An Example
Suppose we have to encode 256x256 pixel grayscale image.
let R1~R1024 be the 8x8 pixel non-overlapping sub-squares of the image, and let D be the collection of all overlapping 16x16 pixel sub-squares of the image (general, domain is 4 times greater than range). The collection D contains (256-16+1) * (256-16+1) = 58,081 squares. For each Ri search through all of D to find Di with minimal distances
To find most-likely sub-squares we have to minimize distance equation. That means we must find a good choice for Di that most looks like the image above Ri (in any of 8 ways of orientations) and find a good contrast si and brightness oi. For each Ri , Di pair we can compute contrast and brightness using least squares regression.
Fractal Image Compression versus JPEG Compression
Original Lena image (184,320 bytes)
JPEG-max. quality (32,072)comp. ratio: 5.75:1
FIF-max. quality (30,368)comp. ratio: 6.07:1
One very important feature of the Fractal Image Compression is Resolution Independence.
When we want to decode image, the only thing we have to do is apply these transformations on any initial image. After each iteration, details on the decoded image are sharper and sharper. That means, the decoded image can be decoded at any size.
So we can zone in the image on the larger sizes without having the "pixelization" effect..
Resolution Independence
Lena's eyeoriginal image enlarged to 4
times
Lena's eyedecoded at 4 times its encoding
size
FractalsInfinite detail at every pointSelf similarity between parts and overall features
of the objectZoom into Euclidian shape
Zoomed shape see more detail eventually smooths
Zoom in on fractalSee more detail
Does not smoothModel
Terrain, clouds water, trees, plants, feathers, fur, patterns
General equation P1=F(P0), P2 = F(P1), P3=F(P2)…P3=F(F(F(P0)))
Self similar fractalsParts are scaled down versions of the entire
objectuse same scaling on subpartsuse different scaling factors for subparts
Statistically self-similarApply random variation to subparts
Trees, shrubs, other vegetation
Fractal typesStatistically self-affine
random variations Sx<>Sy<>Sz
terrain, water, clouds
Invariant fractal setsNonlinear transformations
Self squaring fractals Julia-Fatou set
Squaring function in complex space Mandelbrot set
Squaring function in complex space Self-inverse fractals
Inversion procedures
Julia-Fatou and Mandelbrot
x=>x2+c x=a+bi
Complex numberModulus
Sqrt(a2+b2) If modulus < 1
Squaring makes it go toward 0
If modulus > 1 Squaring falls towards
infinity If modulus=1
Some fall to zero Some fall to infinity Some do neither
Boundary between numbers which fall to zero and those which fall to infinity Julia-Fatou Set
Foley/vanDam Computer Graphics-Principles and Practices, 2nd edition
Julia-Fatou
Julia Fatou and Mandelbrot con’d
Shape of the Julia-Fatou set based on c
To get Mandelbrot set – set of non-diverging pointsCorrect method
Compute the Julia sets for all possible c
Color the points black when the set is connected and white when
it is not connected
Approximate method Foreach value of c, start with complex number 0=0+0i
Apply to x=>x2+c Process a finite number of times (say 1000)
If after the iterations is is outside a disk defined by
modulus>100, color the points of c white, otherwise color it
black.
04/21/23 Dr. B. Raghu Professor/CSE 51
Foley/vanDam Computer Graphics-Principles and Practices, 2nd edition
Constructing a deterministic self-similar fractal
InitiatorGiven geometric shape
GeneratorPattern which replaces subparts of initiator
Koch Curve
Initiator generatorFirst iteration
Fractal dimensionD=fractal dimension
Amount of variation in the structureMeasure of roughness or fragmentation of the
object Small d-less jagged Large d-more jagged
Self similar objectsnsd=1 (Some books write this as ns-d=1)
s=scaling factor n number of subparts in subdivision d=ln(n)/ln(1/s)
[d=ln(n)/ln(s) however s is the number of segments versus how much the main segment was reduced I.e. line divided into 3 segments. Instead of saying the
line is 1/3, say instead there are 3 sements. Notice that 1/(1/3) = 3]
If there are different scaling factors Sk
d=1K=1
n
Figuring out scaling factorsI prefer: ns-d=1 :d=ln(n)/ln(s)
Dimension is a ratio of the (new size)/(old size)Divide line into n
identical segments n=s
Divide lines on square into small squares by dividing each line into n identical segments n=s2 small squares
Divide cube Get n=s3 small cubes
Koch’s snowflakeAfter division have 4
segments n=4 (new segments) s=3 (old segments) Fractal Dimension
D=ln4/ln3 = 1.262
For your reference: Book method n=4
Number of new segments s=1/3
segments reduced by 1/3 d=ln4/ln(1/(1/3))
Sierpinski gasket Fractal Dimension
Divide each side by 2Makes 4 trianglesWe keep 3Therefore n=3
Get 3 new triangles from 1 old triangle
s=2 (2 new segments from one old segment)
Fractal dimension D=ln(3)/ln(2) = 1.585
Cube Fractal Dimension
Apply fractal algorithmDivide each side by 3Now push out the middle face of each cubeNow push out the center of the cube
What is the fractal dimension?Well we have 20 cubes, where we used to have
1 n=20
We have divided each side by 3 s=3
Fractal dimension ln(20)/ln(3) = 2.727
Image from Angel book
Language Based Models of generating images
Typical Alphabet {A,B,[,]}
RulesA=> AAB=> A[B]AA[B]
Starting Basis=BGenerate words
Represents sequence of segments in graph structure
Branch with brackets
Interesting, but I want a tree
BA[B]AA[B]AA[A[B]AA[B]]AAAA[A[B]AA[B]]
A
AA
B
B
A
AAB
AA
B
AAAA
A
B
AA
B
Language Based Models of generating images con’d
Modify Alphabet {A,B,[,],(,)}
RulesA=> AAB=> A[B]AA(B) [] = left branch () =
right branchStarting Basis=B
Generate wordsRepresents sequence of
segments in graph structure
Branch with brackets
BA[B]AA(B)AA[A[B]AA(B)]AAAA(A[B]AA(B))
A
AA
B
B
A
AAB
AA
B
AAAA
AB
AA
B
Language Based models have no inherent geometryGrammar based model
requiresGrammarGeometric interpretation
Generating an object from the word is a separate processexamples
Branches on the tree drawn at upward angles
Choose to draw segments of tree as successively smaller lengths The more it branches, the
smaller the last branch is Draw flowers or leaves at
terminal nodes
A
AAB
AA
B
AAAA
A
B
AA
B
Grammar and GeometryChange branch size according to depth of graph
Foley/vanDam Computer Graphics-Principles and Practices, 2nd edition
Particle SystemsSystem is defined by a collection of particles
that evolve over timeParticles have fluid-like properties
Flowing, billowing, spattering, expanding, imploding, exploding
Basic particle can be any shape Sphere, box, ellipsoid, etc
Apply probabilistic rules to particles generate new particles Change attributes according to age
What color is particle when detected? What shape is particle when detected? Transparancy over time?
Particles die (disappear from system) Movement
Deterministic or stochastic laws of motion Kinematically forces such as gravity
Particle Systems modelingModel
Fire, fog, smoke, fireworks, trees, grass, waterfall, water spray.
GrassModel clumps by setting up trajectory paths for
particlesWaterfall
Particles fall from fixed elevation Deflected by obstacle as splash to ground
Eg. drop, hit rock, finish in pool Drop, go to bottom of pool, float back up.
Physically based modelingNon-rigid object
Rope, cloth, soft rubber ball, jelloDescribe behavior in terms of external and internal
forcesApproximate the object with network of point nodes
connected by flexible connection Example springs with spring constant k
Homogeneous object All k’s equal
Hooke’s LawFs=-k x
x=displacement, Fs = restoring force on springCould also model with putty (doesn’t spring back)Could model with elastic material
Minimize strain energy
kk
k
k
“Turtle Graphics”Turtle can F=Move forward a unitL=Turn leftR=Turn right
Stipulate turtle directions, and angle of turns
Equilateral triangleEg. angle =120FRFRFR
What if change angle to 60 degreesF=> FLFRRFLFBasis F
Koch Curve (snowflake)Example taken from Angel
book
Using turtle graphics for treesUse push and pop for side
branches []F=> F[RF]F[LF]FAngle =27Note spaces ONLY for
readabilityF[RF]F[LF]F
[RF[RF]F[LF]F] F[RF]F[LF]F [LF[RF]F[LF]F] F[RF]F[LF]F
FractalsFractals are geometric objects.Many real-world objects like ferns are shaped
like fractals.Fractals are formed by iterations.Fractals are self-similar.In computer graphics, we use fractal
functions to create complex objects.
Iteration 0 Iteration 1 Iteration 2 Iteration 3
Generator1/3 1/3
1/3 1/3
1
Iteration 1 Iteration 2 Iteration 3 Iteration 4 Iteration 5
Generator
Generator
Iteration 0 Iteration 1 Iteration 2 Iteration 3
Add Some RandomnessThe fractals we’ve produced so far seem to
be very regular and “artificial”.To create some realism and variability,
simply change the angles slightly sometimes based on a random number generator.
For example, you can curve some of the ferns to one side.
For example, you can also vary the lengths of the branches and the branching factor.
Terrain (Random Mid-point Displacement)Given the heights of two end-points,
generate a height at the mid-point.Suppose that the two end-points are a and
b. Suppose the height is in the y direction, such that the height at a is y(a), and the height at b is y(b).
Then, the height at the mid-point will be: ymid = (y(a)+y(b))/2 + r, where
r is the random offset
This is how to generate the random offset r:
r = srg|b-a|, where s is a user-selected “roughness” factor, and rg is a Gaussian random variable with mean 0 and variance
1
// given random numbers x1 and x2 with equal distribution from -1 to 1// generate numbers y1 and y2 with normal distribution centered at 0.0// and with standard deviation 1.0.void Gaussian(float &y1, float &y2) {
float x1, x2, w;
do {x1 = 2.0 * 0.001*(float)(rand()%1000) - 1.0;x2 = 2.0 * 0.001*(float)(rand()%1000) - 1.0;w = x1 * x1 + x2 * x2;
} while ( w >= 1.0 );
w = sqrt( (-2.0 * log( w ) ) / w );y1 = x1 * w;y2 = x2 * w;
}
Building a more realistic terrainNotice that in the real world, valleys and
mountains have different shapes.If we have the same terrain-generation
algorithm for both mountains and valleys, it will result in unrealistic, alien-looking landscapes.
Therefore, use different parameters for valleys and mountains.
Also, can manually create ridges, cliffs, and other geographical features, and then use fractals to create detail roughness.
// x0, y0 are the starting coordinates// x1, y1 are the ending coordinates// xout, yout is the outward vector// level is how many iterations to draw this koch fractal. 0 means just draw the linevoid Koch2D(float x0, float y0, float x1, float y1, float xout, float yout, int level) { float xa, xb, xd, ya, yb, yd; // (xa,ya) is a third of the way // (xb,yb) is two thirds of the way // (xd,yd) is the new point float xmid,ymid, outmag, displacemag;
if (level==0) { // if level 0, just draw the line glBegin(GL_LINES); glVertex3f(x0,y0,0.0); glVertex3f(x1,y1,0.0); glEnd(); } else { // otherwise, call Koch2D for the four line-segments xa = x0+0.3333333*(x1-x0); ya = y0+0.3333333*(y1-y0); xb = x0+0.6666666*(x1-x0); yb = y0+0.6666666*(y1-y0); Koch2D(x0,y0,xa,ya,xout,yout,level-1); // draw the first third Koch2D(xb,yb,x1,y1,xout,yout,level-1); // draw the second third outmag = sqrt(xout*xout+yout*yout); displacemag = tan(3.14159/3.0)*sqrt((x1-x0)*(x1-x0)+(y1-y0)*(y1-y0))/6.0; xmid = xout*displacemag/outmag; ymid = yout*displacemag/outmag; xd = x0+0.5*(x1-x0)+xmid; yd = y0+0.5*(y1-y0)+ymid; Koch2D(xa,ya,xd,yd,xa+0.5*(xd-xa)-xb,ya+0.5*(yd-ya)-yb,level-1); // protrusion Koch2D(xd,yd,xb,yb,xd+0.5*(xb-xd)-xa,yd+0.5*(yb-yd)-ya,level-1); // protrusion }}
(x0,y0) (xa,ya) (xb,yb) (x1,y1)
(xd,yd)
(xout,yout)
L
L/6
60 degrees or3.14159 / 3 radians
displacemag
// radius, height, iterationvoid FractalTree(float r, float h, int iter) {
GLUquadricObj *optr; // *************** Draw the vertical cylinder ************************************ optr = gluNewQuadric(); gluQuadricDrawStyle(optr,GLU_FILL); glPushMatrix(); glRotatef(-90.0,1.0,0.0,0.0); gluCylinder(optr,r,r,h,10,2); // ptr, rbase, rtop, height, nLongitude, nLatitudes glPopMatrix(); // *************** If more iterations, then recursively draw branches ******** if (iter>0) { glPushMatrix(); glTranslatef(0.0,h,0.0); // translate upwards by h glRotatef(30.0,1.0,0.0,0.0); // rotate about the x axis by 30 degrees FractalTree(0.8*r,0.8*h,iter-1); // draw the next iteration fractal tree glPopMatrix();
glPushMatrix(); glTranslatef(0.0,h,0.0); // translate upwards by h glRotatef(120.0,0.0,1.0,0.0); // rotate about the y axis by 120 degrees glRotatef(30.0,1.0,0.0,0.0); // rotate about the x axis by 30 degrees FractalTree(0.8*r,0.8*h,iter-1); // draw the next iteration fractal tree glPopMatrix();
glPushMatrix(); glTranslatef(0.0,h,0.0); glRotatef(240.0,0.0,1.0,0.0); glRotatef(30.0,1.0,0.0,0.0); FractalTree(0.8*r,0.8*h,iter-1); glPopMatrix(); }}
xz
y
h
30o