Drawing trees using fractals with OpenGL

Computer Graphics project

EECS 366/466

The Instructor: Prof. M. Cenk Cavusoglu

Student name: Sulieman Bani-Ahmad, sxb139

Spring 2004

Introduction:

During the last years, a variety of techniques have been proposed to sketch and non-photo-realistically render objects. Research in this area was driven by the realization that drawings are able to convey visual information in a different way than photorealistic images do.

While the proposed methods allow creating line drawings of many objects and in many different styles, the illustration of plants has so far been neglected. This is surprising because drawings of these objects are needed in areas like architecture and landscaping.

A nice property about trees is that they are self-similar. In other words, a small portion, such as a branch, looks similar in structure to the whole tree. We can structure our code to follow nature's design. The basic idea is that every single part of the tree is self similar. For example, a branch has the same basic shape as the trunk, except it is a little smaller. Using this idea, we draw a large branch, then smaller branches attached to that, and even smaller branches, and so forth.

Illustration styles for trees

· art-based style [Kowalski, 1999]: aims at creating generic tree representations.

· pen-and-ink style [Deussen, 2000]: visually representing specific plants.

How to draw a tree:

· Using billboarded sprites with images of trees: This approach is quick to implement and quick to run, because only a rectangle with a texture pasted on top needs to be drawn. However, the drawbacks are that the resolution depends on the texture, and the texture is planar, so ultimately the tree is mostly planar.

· Using Lindenmayer systems or L-systems (a particular type of symbolic dynamical system with the added feature of a geometrical interpretation of the evolution of the system): A grammar is defined for drawing commands (such as rotate, translate, or draw), which is recursively expanded an arbitrary amount. This generated string of drawing instructions are then parsed and interpreted to draw the tree.

· Using recursive tree generating function (Fractals approach).

Some related work:

· Kowalski [Kowalski, 1999] generated abstract sketches of trees by using geometric primitives like spheres for defining rough approximations of a tree’s foliage.

· Deussen [Deussen, 2000] used a surface-oriented plant modeling system and developed a method for automatic pen-and-ink illustration of trees.

Properties of trees:

· Trees are that they are self-similar. In other words, a small portion, such as a branch, looks similar in structure to the whole tree. [P1]

· Trees always grow towered the light source (the sun), down-direction branches are always weak or bent to face the sun light. [P2]

· Some trees go in height more than width. [P3]

· Some trees show more growth diffusion than others. [P4].

Project methodology:

Tree drawing pipeline:

The basic fractal looks like:

· Prepare a 2D skeleton

· Cover with cylinders

· Cover the cylinders with leaves

· Apply some rotations, translations, scaling on copies of the 2D tree.

Generating tree branches cylinders:

Generating tree leaves:

Interaction between tree and environment:

· The tree data structure is designed so that the points representing leaves can be distinguished, the small branches are also distinguishable, and this makes molding tree-wind, sun-wind … possible to be implemented.

· Growth diffusion of tree [P4] can be implemented by adding some randomness while rendering the trees.

Future work:

· Enhance the fractals to give more realistic tree models.

· Implement tree-environment interactions.

References:

· Kowalski M., Markosian L., Northrup J. D., Burdev L., Barzel R., Holden L., and Hughes J. F.. Art-based rendering of fur, grass, and trees. In SIGGRAPH ’99 Conference Proceedings. ACM SIGGRAPH, August 1999.

· Deussen O., Strothotte T., Computer-Generated Pen-and-Ink Illustration of Trees. In SIGGRAPH ’2000 Conference Proceedings. ACM SIGGRAPH, 2000.