CSC 470 Computer Graphics. Fractals

Size: px

Start display at page:

Download "CSC 470 Computer Graphics. Fractals"

Frank Hines
6 years ago
Views:

1 CSC 47 Computer Graphics Fractals 1

2 This Week Approaches to Infinity Fractals and Self-Similarity Similarity Iterative Function Systems Lindenmayer Systems Curves Natural Images (trees, landscapes..)

3 Introduction What is a Fractal? A A fractal is an image with self-similar similar properties produced by recursive or iterative algorithmic means. anything which has a substantial measure of exact or statistical l self-similarity similarity Mandelbrot coined the term from the latin fractus meaning fragmented or irregular 3

4 Introduction Why use fractals in Computer Graphics? Most real world objects are inherently smooth. Most real world objects cannot be represented by simple prisms and ellipsoids. Most real world objects cannot best be described by fixed mathematical curves (e.g. sin, cos etc..) 4

5 Introduction Although curves can represent natural phenomena they can become very complex e.g. Trees, Mountains, Water, Clouds etc... Clouds are not spheres, coastlines are not circles, bark is not smooth, nor does lightning travel in straight lines. -Mandelbrot 5

6 Introduction Fractals are useful for representing natural shapes such as trees, coastlines, mountains, terrain and clouds. Magnification of these things review smaller self-similar similar copies of the entire image. 6

7 Branches are self-similar Roots are self-similar 7

8 Fractal Curve Refinement Very complex curves can be fashioned recursively by repeatedly refining the curve. Koch Curve: subdivide each segment of Kn into three equal parts, and replace the middle part with a bump in the shape of an equilateral triangle. The Koch Snowflake 8

Fractal Curve Refinement //dir - turtle angle //len - length of line segment //n - number of iterations void drawkoch(double dir, double len,int n) { double dirrad =.

9 Fractal Curve Refinement //dir - turtle angle //len - length of line segment //n - number of iterations void drawkoch(double dir, double len,int n) { double dirrad = * dir; // in radians if(n == ) cvs.forward(len,1); else{ n--; // reduce the order len /= 3; // and the length drawkoch(dir, len,, n); dir += 6; cvs.turnto(dir); drawkoch(dir, len,, n); dir -= = 1; cvs.turnto(dir); drawkoch(dir, len,, n); dir += 6; cvs.turnto(dir); drawkoch(dir, len,, n); } } 9

10 Lindenmayer Systems An L-System L works by giving the turtle a string sequence where each symbol in the sequence gives turtle instructions. F -> > go forward 1 step + -> > turn right by x degrees - -> > turn left by x degrees where x is set and predetermined. 1

11 Lindenmayer Systems The string F+F-F F means go forward turn right, go forward, turn left and go forward. 11

12 Lindenmayer Systems L-Systems are produced based on a production rule. This rule is iteratively applied to the string. e.g. F -> > F+F means that all F s in the string should be replaced with F+F therefore, F+F-F F becomes: F+F+F+F-F+F 1

13 L-Systems Starting with: F+F+F+F and the production rule: F -> F+F-F-FF+F+F-F After one iteration the following string would result F+F-F-FF+F+F-F + F+F-F-FF+F+F-F + F+F-F- FF+F+F-F + F+F-F-FF+F+F-F 13

14 L-Systems After iterations the string would be: F+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F-FF+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F+ F+ F- F-FF+ F+ F-F-F+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F+ F+ F-F- FF+ F+ F-F-F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F-FF+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F-FF+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F- F+ F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F-F-F+ F-F-FF+ F+ F- FF+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F+ F+ F-F-FF+ F+ F-F- F+ F-F-FF+ F+ F-F 14

15 L-Systems Programming L-SystemsL producestring(char *rule, int iterations) { FILE *ifp* ifp,, *ofp* ofp; for(int i = ; i < iterations; i++) { if( (ifp( = fopen("ldata.txt","r")) ")) == NULL (ofp( = fopen("ltemp.txt","w")) ")) == NULL ) exit(-1); //cannot open files } } int ch; while((ch = fgetc(ifp))!= -1) { switch(ch) { case 'F': fprintf(ofp,"%s",rule); break; default: fprintf(ofp,"%c",ch); break; } } fclose(ifp); fclose(ofp); remove("ldata.txt"); "); rename("ltemp.txt", ", "ldata.txt" ldata.txt"); 15

16 L-Systems Programming L-SystemsL drawstring(int len,, float angle) { FILE *ifp* ifp; if( (ifp( = fopen("ldata.txt","r")) ")) == NULL ) exit(-1); //cannot open files } int ch; while( (ch( = fgetc(ifp))!= -1) { switch(ch) { case 'F': cvs.forward(len,, 1); break; case '+': cvs.turn(-angle); break; case '-':' ': cvs.turn(angle); break; } } 16

17 L-Systems Programming L-SystemsL void mydisplay(void) { cvs.clearscreen(); gllinewidth(3); cvs.moveto(-5.,.); producestring("f-f++f F++F-F", F", 3); drawstring(,6); glflush(); } 17

18 L-Systems Programming L-L Systems The more iterations you do, the bigger the curve will get.. Therefore you need to modify the length of the sides depending on the number of iterations. 1 iteration 3 iterations 18

19 L-Systems There is a limit to the number of shapes that can be drawn with just and F directive. L-Systems need to be restricted to just F, you can use however many replacement letters and strings you like. 19

20 L-Systems For example, F, X and Y: F -> > F X -> > X+YF+ Y -> > -FX FX-Y atom = X (starting string) But the turtle only draws with F This of course is no rule, you could make X and Y draw as well it is up to you!!!

21 L-Systems The Dragon Curve F -> > F X -> > X+YF+ Y -> > -FX FX-Y atom = X 1 iterations 1

22 L-Systems Koch Island F -> > F+F-F-FF+F+F FF+F+F-F F X -> > Y -> > atom = F+F+F+F 5 iterations

23 L-Systems If you look at a tree you will notice that it is made up of smaller copies of itself. e.g. A tree branch is just a smaller version of a tree. Being self-similar similar doesn t mean each smaller version has to be EXACTLY the same. 3

24 L-Systems Lets look at a tree F F But that can t be right? F F F -> F+F-F 4

25 L-Systems Lets look at a tree F F F F return here F -> F+F-F start here 5

26 L-Systems Lets look at a tree F F F F return here F -> F[+F]-F start here 6

27 L-Systems Lets look at a tree F -> F[+F][-F] push the turtle location pop the turtle location 7

28 L-Systems Lets look at a tree F -> > F[+F][-F] F] atom F 8

29 L-Systems Lets look at a tree F -> > FF-[-F+F+F]+[+F F+F+F]+[+F-F-F] F] atom F 9

30 L-Systems Lets look at a tree Some L-System L trees can look a little calculated, therefore random angles and lengths can be introduced. This is the same tree (above) and below with random lengths and angles. 3

31 L-Systems or you can modify the thickness or length of the branch (lines) depending on the level at which it appears in the tree. 31

32 3 Affine Transformations Affine Transformations For example, take these: For example, take these: = ' ' y x y x = ' ' y x y x = ' ' y x y x original image (1x1) What will it look like after the transformations??

33 33 Affine Transformations Affine Transformations For example, take these: For example, take these: = ' ' y x y x = ' ' y x y x = ' ' y x y x

34 Affine Transformations 34

35 Affine Transformations An my personal favourite: Affine Transformations: T {a,b,c,d,e,f{ a,b,c,d,e,f} x' a = y' d 1 c x f. y 1 1 T1 {,,,,.16,} T {.,-.6,,.3,.,1.6}.6,,.3,.,1.6} T3 {-.15,.8,,.6,.4,.44}{ T4 {.75,.4,,-.4,.85,1.6}.4,.85,1.6} b e 35

36 Affine Transformations An my personal favourite: 36

37 Affine Transformations An my personal favourite: 37

38 Affine Transformations An my personal favourite: 38

39 Iterative Function Systems An iterative function system (IFS) takes a set of affine transformations and transforms a point through them based on a random selection of the transformation. An IFS is a collection of N affine transformations T i, for I = 1,,,N 39

40 Iterative Function Systems Generating an IFS Chaos Game select a random point do { select a random transformation run point through transformation plot new point set old point to new point }while (!bored) 4

41 Iterative Function Systems Generating an IFS Chaos Game select a random point do { select a random transformation run point through transformation plot new point set old point to new point }while (!bored) 41

42 Iterative Function Systems The idea: All points on the attractor (final image) are reachable by applying a long sequence of affine transformations. The random selection of transformations is invoked to ensure the system is fully exercised 4

43 43

44 Next Week More Fractals Mandelbrot and Julia Sets Generating realistic landscapes 44

Fractals & Iterative Function Systems

CS 543: Computer Graphics Fractals & Iterative Function Systems Robert W. Lindeman Associate Professor Department of Computer Science Worcester Polytechnic Institute gogo@wpi.edu (with lots of help from