2009 International Conference on Computational Science and Its Applications

IFS Matlab Generator: A Computer Tool for Displaying IFS Fractals

Akemi Galvez Tomida
Department of Applied Mathematics and Computational Sciences
University of Cantabria
Avda. de los Castros, s/n, 39005, Santander, SPAIN
galveza@unican.es

Abstract

decades it has been shown that many nonlinear phenomena are so complicated and irregular that they cannot be
modeled well using these classical techniques [18, 19, 20].
The spectrum of examples of this phenomena ranges from
the growth and decline of populations, weather forecast,
fluid turbulence, to topics in economics (see, for example,
[16, 25]). The development of fractal geometry provides
rigorous concepts and practical techniques for the mathematical formulation and analysis of irregular processes [22].
For example, the fractal dimension of strange attractors associated with chaotic dynamical systems gives valuable information about the irregular evolution observed in such
systems [7, 8, 9, 11, 12].
Several fractal modeling and generation methods have
been developed during the last two decades. Among them,
the Iterated Function Systems (IFS) models, popularized by
Barnsley in the 1980s, are particularly interesting due to
their mathematical simplicity [1]. IFS models have been
applied in many disciplines, for example, in artificial landscape modeling in computer graphics. Roughly speaking,
an IFS consists of a collection of functions that map a region onto smaller parts. Iteration of these mappings results
in convergence to a self-similar fractal that is called the attractor of the IFS. Self-similarity means that any portion
of the object, if enlarged in scale, appears identical to the
whole object. This property allows us to characterize the
kind of fractals that can be generated using IFS models in
an intuitive way. Of course, the concept of fractal includes a
wider class of objects, but many of the most popular fractal
images can actually be obtained through an IFS.
Although IFS fractals can be of any dimension, they
are commonly computed and drawn in the two-dimensional
plane. In the two-dimensional space, the fractal is made up
of the union of several copies of itself, where each copy is
transformed by a function (function system). Such a function is mathematically a 2D affine transformation (see Section 2 for details), so the IFS is defined by a finite number
of affine transformations (rotations, translations, and scalings), and therefore represented by a relatively small set of

Fractals are among the most exciting and intriguing

mathematical objects ever discovered. A particular type of
fractals, the Iterated Function Systems (IFS), has received
a lot of attention due to its appealing combination of conceptual simplicity, computational efficiency and great ability to reproduce natural formations and complex phenomena. This paper introduces a new Matlab program, called
IFS Matlab Generator, for generating and rendering IFS
fractals. In addition to providing a gentle introduction to
the mathematical basis of IFS, two of the most important
rendering algorithms, the deterministic algorithm and the
probabilistic algorithm (also called chaos game algorithm), are briefly outlined. A critical point of chaos game
is the choice of the set of probabilities associated with the
iterated functions. This issue will be briefly discussed in
this paper: we analyze the efficiency of the chaos game algorithm, comparing the standard method for choosing the
probabilities proposed by Michael Barnsley with another
method based on a new multifractal technique [13, 14]. The
latter method optimizes the rendering process by obtaining
the most efficient set of probabilities. Some examples aimed
at illustrating this technique along with a gallery of beautiful two-dimensional fractal objects are also given.

1. Introduction
Traditionally, the classical mathematical concepts and
methods were concerned with smooth objects, ignoring irregular sets. For example, the concept of derivative allows us to analyze smooth curves and surfaces. Nowadays,
smoothness and fairness are still much-desired properties
in almost any mathematical representation of real objects,
wherever it appears. However, in real world irregularity is
the rule rather than the exception: clouds are not spheres,
trees are not cylinders, mountains are not cones and fire
or smoke are not smooth surfaces. In fact, during the last
978-0-7695-3701-6/09 $25.00 2009 IEEE
DOI 10.1109/ICCSA.2009.10

132

2. Iterated Function Systems

input data. Since those functions are usually iterated, we

get the name Iterated Function System (IFS).
A very important result related to IFS fractals is the socalled Collage Theorem, that roughly states that any 2D image can be approximated to any degree of precision by a
fractal using an IFS model. In other words, the final image is (approximately) the attractor of the IFS [1]. This result has motivated an intensive research effort in the field
of fractal image compression, a lossy image compression
method that uses IFS fractals to store the compressed image as a collection of IFS codes [2, 5, 21, 24, 26, 27]. The
method is based on the idea that in images, certain parts
of the image resemble other parts of the same image. This
method differs from other compression methods in that no
pixels but fractal codes are stored. Once an image has been
converted into fractal code it can be recreated by successive
iterations at will. This method has the great advantage that
the final image becomes resolution independent. Further,
since the number of iterations might be theoretically infinite, the final image might fill any screen size. Moreover,
this compression method is able to achieve higher compression ratios than conventional methods and still offer better
quality.
There are several well-known methods for rendering
fractal images based on IFS. Among these methods, the
probabilistic algorithm (also known as the chaos game) is
gaining popularity due to its efficiency and conceptual simplicity. This paper introduces a new Matlab program for
generating and rendering IFS fractals. We begin with an
introduction to IFS fractals. Then, two of the most important rendering algorithms, the deterministic algorithm and
the probabilistic algorithm, are briefly outlined. The program, called IFS Matlab Generator, relies on the use of the
chaos game algorithm. A critical issue of this method is the
choice of the set of probabilities associated with the iterated
functions. This problem will be briefly discussed in this paper: we analyze the chaos game algorithm, comparing the
standard method for choosing the probabilities with another
method based on a multifractal technique [13, 14]. The latter method optimizes the rendering process by obtaining the
most efficient set of probabilities.
The structure of this paper is as follows: in Section 2 a
gentle introduction to the mathematical basis of IFS fractals
is given. Section 3 introduces IFS Matlab Generator, a new
Matlab program for generating and rendering IFS fractals
by using the probabilistic algorithm. Some interesting examples of IFS fractals along with a gallery of beautiful twodimensional fractal objects are given in Section 4. Section
5 includes a discussion about the efficiency of the probabilistic algorithm for different sets of probabilities and how
to select those that optimize the rendering process. The paper closes with the main conclusions and outlines the future
work.

2.1. What is an IFS?

As a first notion, an IFS is a finite set of contractive maps
defined on a complete metric space. Mathematically, an IFS
consists of a complete metric space (X, d) and a finite set
of linear transformations wi : X X, i = 1, . . . , n. We
refer to the IFS as W = {X; w1 , . . . , wn }.
Since we are interested in 2D images, we restrict our
attention to contractive affine transformations on the real
plane. In this case, the metric space (X, d) is IR 2 with the
Euclidean distance d2 , which is a complete metric space,
while the affine transformations wi are of the form
x
y

x
y

= wi

ai
ci

 
 

x
ei
.
+
(1)
y
fi

bi
di

or equivalenty:
wi (x) = Ai .x + bi
where bi is a translation vector and Ai is a 2 2 matrix with eigenvalues 1 , 2 such that |i | < 1. In fact,
|det(Ai )| < 1 meaning that wi shrinks distances between
points. Since we only consider two-dimensional images
with the Euclidean distance, an IFS will be onwards represented by a list of the pairs (A, b). For example, the classical Sierpinsky gasket (see Figure 1) is generated by three
mappings, each of which is a translation composed with a
scaling of one-half:


x
y

x
y

x
y


= w1


= w2


= w3

x
y

x
y

x
y


=


=


=

1
2

1
2

1
2

0
1
2

0
1
2

0
1
2

 
 

x
1
.
+
y
1

 
  
x
1
.
+
y
1

 
 

x
0
.
+
y
1

This IFS code is usually represented in tabular form as

in Table 2. Note that the three mappings forming the Sierpinsky gasket share the same rotation-scaling matrix while
having different translation vectors. Each of these mappings defines one of the three different self-similar gaskets
shown in color in Figure 1(right). The Sierpinski gasket has
Hausdorff dimension log(3)/log(2) 1.585, which follows from the fact that it is a union of three copies of itself,
each scaled by a factor of 1/2.

133

support() = |W|. Thus, given an arbitrary initial measure 0 M(X) the sequence {k }k=0,1,2,... constructed
as k+1 = M (k ) converges to the invariant measure of the
IFSP. Also, a similar iterative deterministic scheme can be
derived from Eq.(2) to obtain |W|.
However, there exists a more efficient method, known as
probabilistic algorithm, for the generation of the attractor of
an IFS. This algorithm follows from the result {xk }k>0 =
|W| provided that x0 |W|, where:

Table 1. IFS code of the Sierpinsky gasket

a
b c
d
e
f
w1 0.5 0 0 0.5 -1 1
w2 0.5 0 0 0.5 1
1
w3 0.5 0 0 0.5 0 -1

xk = wi (xk1 ) with probability pi > 0

(3)

(see, for instance, [3]). This issue will be discussed in Sections 4 and 5.

3. Program Architecture and Implementation

Figure 1. Sierpinsky gasket (left) is an IFS
made up of three copies of itself (right)

3.1. Program Architecture

The program IFS Matlab Generator introduced in this
paper for generating and rendering IFS fractals consists basically of two major components:

2.2. IFS Attractor

Let us now define a transformation, T , in the compact
subsets of X, H(X), by
T (A) =

n
[

wi (A).

1. a computational library (toolbox): it contains a collection of commands, functions and routines implemented to perform the numerical and graphical tasks.

(2)

2. a graphical user interface (GUI): this component is responsible for input/output windowing and smooth interaction with the user.

i=1

If all the wi are contractions, T is also a contraction in

H(X) with the induced Hausdorff metric. Then, T has
a unique fixed point, |W|, called the attractor of the IFS.
Considering a set of probabilities p1 , . . . , pn (0, 1), with
n
X
pi = 1, |W| supports several measures in a natural way.

Our numerical functions have been implemented by using the native Matlab programming language. They take advantage of the large collection of numerical routines available in this system. Usually, these built-in Matlab routines
provide extensive control on a number of different options
and are fully optimized to offer the highest level of performance. In fact, this is one of the major strengths of the
program and one of the main reasons to choose Matlab as a
convenient programming environment.
On the other hand, the powerful Matlab graphical capabilities exceed those commonly available in other CAS such
as Mathematica and Maple. Although our current needs do
not require to apply them at full extent, they avoid us the
tedious and time-consuming task to implement many routines for graphical output by ourselves. In fact, some nice
viewing features such as 3D rotation, zooming in and out,
labeling, scaling, coloring and others, which are automatically inherited from the Matlab windows system, have been
intensively used in our system.
Although this toolbox is enough to meet all our computation needs, potential end-users might be challenged for using it properly unless they are really proficient on Matlabs
syntax and functionalities and the toolbox routines. This

i=1

We refer to {X; w1 , . . . , wN ; p1 , . . . , pn } as an IFS with

Probabilities (IFSP). Given a set {p1 , . . . , pn }, there exists
an unique Borel regular measure M(X), called the
invariant measure of the IFSP, such that
(S) =

n
X

pi (wi1 (S)),

S B(X),

i=1

where B(X) denotes the Borel subsets of X. This fact can

be easily shown through the introduction of the Markov operator [17]. The Markov operator associated to the IFSP is
a transformation, M : M(X) M(X) defined by:
(M )(S) =

n
X

pi (wi1 (S)),

i=1

where S is a Borel subset of X. Using the Hutchinson metric on M(X), it is possible to show that M is a contraction with a unique fixed point, M(X). Furthermore,

134

topic under analysis have been grouped and arranged in a

rectangular area with an indicative title on the top, such as:
code, initial set, method and iterations (see Figure 2 and
subsequent description in Section 4). They are also labeled
with numbers in red from 1 to 4 in Figure 2 for prompt
identification. Thus, in the upper part of area 1 you can see
some boxes and buttons for input/output user interaction.
Below those boxes, some buttons for additional tasks and a
list box to display generated IFS code are also included (see
Section 4 for further description). Additional functionalities
are also provided in hidden menus or in separate windows
which can be invoked at will if needed so as to keep the
main window streamlined and uncluttered. For instance, all
graphical output is displayed in separate windows so that
the information is better organized and flows in a natural
and intuitive way. As a result, this GUI presents an interface
which is both aesthetic and very functional to the user.

3.2. Implementation Issues

Regarding the implementation, this program has been
developed by the author in Matlab [23] v2008a on Windows XP operating system by using a PC with Intel Core
2 Duo processor at 2.4 GHz. and 2 GB of RAM. However,
the program supports many different platforms, such as PCs
(with Windows 9x, 2000, NT, Me, XP and Vista) and UNIX
workstations. A version for Apple Macintosh with Mac OS
X system is also available provided that X11 (the implementation of the X Window System that makes it possible
to run X11-based applications in Mac OS X) is properly installed and configured. Figures in this paper correspond to
the PC platform version.
The graphical tasks are performed by using the Matlab
GUI for the higher-level functions (windowing, menus, or
input) while the OpenGL-based built-in graphics Matlab
commands are applied for rendering purposes. All our numerical functions have been implemented in the native Matlab programming language.

Figure 2. Screenshot of main window of our

program

kind of limitations can be overcome by creating a GUI; a

well-designed GUI uses readily recognizable visual cues to
help the user navigate efficiently through information. Fortunately, Matlab provides a mechanism to generate GUIs by
using the so-called guide (GUI development environment).
This feature is not commonly available in many other CAS
so far. Although its implementation requires - for complex
interfaces - a high level of expertise, it allows end-users to
deal with the toolbox with a minimal knowledge and input,
thus facilitating its use and dissemination.
Based on this idea, a GUI for the already-generated toolbox has been implemented. Figure 2 shows an example of
a typical window. It allows an effective use of powerful
interface tools designed according to the type of values being displayed (e.g., drop-down menu for a choice list, radio
buttons for single choice from multiple options, text boxes
for displaying messages, list boxes for input/output user interaction, etc.). In general, functions associated with each

4. Some Illustrative Examples

In this section the main features of the program are described through its application to generate and render several IFS fractals.

4.1. Session Workflow

A typical session in IFS Matlab Generator program begins by writing the IFS code of a fractal. To this purpose,
some input boxes are provided in the IFS code area (labeled
as 1 in Figure 2). They reproduce the typical structure of
an IFS code, with input boxes for the coefficients of the

135

w1
w2
w3
w4

Table 2. IFS code of Barnsleys fern

a
b
c
d
e
f
0.81
0.07
-0.4
0.84
0.12 0.195
0.18
-0.25
0.27
0.23
0.12 0.02
0.19
0.275 0.238
-0.14
0.16 0.12
0.0235 0.087 0.045 0.1666 0.11
0

Figure 3. Bernsleys fern (left) and its contractive functions in color (right)

IFS functions, namely, values for ai , bi , ci , di , ei and fi arranged in a two-dimensional matrix and vector according to
Eq. (1). Once a new function is inputted, it can be added to
the list of iterated functions by pressing button Add. This
action is immediately reflected in the list box below such
a button since the new iterated function shows up. For instance, Figure 4 displays the IFS code of the famous Barnsleys fern, given by Table 2. Such a fractal is represented
graphically in Figure 3.
We can modify any already created function through the
button Modify. To this aim, it is enough to click on the
list box at the location of the contractive function we wish
to modify and its parameter values will be placed back onto
the input boxes for further modification. Finally, clicking
on the button Update returns the new function code to its
former position at the list box. User is kindly warned at this
point about the possible confusion between pressing button Add or Update once function parameters are modified. The former button adds a new function, so the IFS is
enlarged regarding the number of iterated functions, while
the latter one replaces the former function by the modified
one, so the number of iterated functions for the IFS does
not change. We can also remove any contractive function
of an IFS at any time (button Remove). Alternatively,
button Remove All removes the codes of all contractive
functions of current IFS.
Once we know how an IFS describe a fractal image, the
next step is introducing a rendering method. Equation (2)
provides us with the simplest rendering algorithm, called
deterministic algorithm. It works by generating a sequence
of images obtained by iterating (2) starting on an initial set

Figure 4. Choosing a picture as the initial set

in the plane. This sequence will converge to the attractor of

the IFS independently on the initial set meaning that we can
start with any arbitrary set or image. Our program allows
us to start with several initial sets, ranging from a single
point to a polygon or a picture (see label 2 in Figure 2).
Figure 4 shows an example of a picture as initial set. As
the reader can see, the program allows us to choose any
arbitrary picture from our storage units or devices by simply
selecting or writing the filename and its path from current
directory and the initial region where such a picture is going
to be displayed before iteration.
It is worthwhile to mention that, while the final image
(the attractor, shown in Figure 3) will always be the same
regardless the initial set we select, the computational complexity to get such an image will not. So, instead of dealing
with pictures or complicated shapes as initial sets, it is more
convenient to use very simple sets (preferably a single point,
like in Figure 5) to that purpose.
Another factor to alleviate the computational load concerns the rendering algorithm. In spite of the beauty and
simplicity of the deterministic algorithm, it is computation-

136

Figure 6. IFS models associated with two different natural formations

three former cases, probabilities are normalized to ensure

Eq. (4) holds. Barnsleys and multifractal algorithms are
explained in detail in next section.
The chaos game algorithm generates a sequence of
points that are randomly distributed over the fractal, according to the chosen set of probabilities. Thus, the larger the
number of iterations, the better the resolution of the resulting fractal image. Input data for our program also includes
the number of iterations used to display the final image (label 4 in Figure 2). Typically, fractal images in this paper
have been generated with about 2 105 iterations. It is
also convenient to consider a transient of m initial iterations
(m = 10 in all our pictures) that are not displayed in order
to skip points that do not really belong to the attractor and
might otherwise be displayed before convergence.
One of the most surprising properties of IFS models is
their ability to capture the main features of some natural
formations. For example, it is not difficult to realize at first
glance that the fractal images given in Figure 6 resemble
leaves (top) and trees (bottom), respectively. Note also the
amazing realism of Figure 3.
Figure 7 shows a gallery of fractal images obtained with
our program. Each fractal is displayed twice: on the left,
the attractor in single color is shown; on the right, we use
different colors to highlight the different contractive functions of each IFS. Colors can be chosen by pressing the
button Graphics setting... so that a new window appears
(see Figure 8). User may select the point style for the picture, including its shape (square, star, diamond, hexagram)
or marker (times, plus, minus), size edge color, face color,
line style (solid, dashed, dotted, dashed-dotted), line width,
etc. Additional available options include selecting one or
several colors for the IFS. Coloring is achieved by select-

Figure 5. Choosing a point as the initial set

ally expensive and, hence, practically useless. A more efficient algorithm can be obtained by attaching real weights
pi to each of the transformations in the IFS, such that:
n
X

pi = 1

(4)

i=1

Picking an initial point, one of the mappings in the

set {w1 , . . . , wn } is chosen at random using the weigths
{p1 , . . . , pn } according to Eq. (3). The selected map is
then applied to generate a new point, and the same process
is repeated again with the new point obtaining, as a result
of this iterative process, a sequence of points. The sequence
obtained using this stochastic process converge to the fractal
as the number of points increases. This algorithm is known
as probabilistic algorithm or chaos game [1]. Third area in
our main window (label 3 in Fig. 2) allows us to select the
probabilities in four different modes: randomly or according to Barnsleys algorithm, multifractal algorithm or users
choice. In the later case, user writes the probabilities in an
input box as a list of values separated by commas. In the

137

Figure 7. Gallery of ten IFS models (left-right, top-bottom): blocks, chaos, snowflake, Koch curve,
abestos, Christmas tree, spiral, neuron, gather, bones

ing one color for each contractive function according to either a default palette or users customization. As the reader

can see, number of contractive functions in these examples

range from 3 in the lower case (Christmas tree and spiral,

138

Figure 9. Applying the chaos game algorithm with different probability sets: (top-left)
(1/3,1/3,1/3); (top-right) (0.6,0.2,0.2); (bottomleft) (0.2,0.6,0.2); (botttom-right) (0.2,0.2,0.6)

that corresponds to the right-up hand side image in Figure 9,

we are overestimating the rate of points associated with the
first mapping, since in this case all the mappings fill equivalent regions of the fractal. As a consequence, the points are
not uniformly distributed in the resulting fractal image. The
first figure shows a uniform distribution of points due to the
optimal choice of the probabilities.
One of the main problems of the chaos game algorithm
is that of finding the optimal set of probabilities to render
the fractal attractor associated with an IFS. The problem
consists of finding the set of probabilities to render the fractal image at a given resolution with the minimum number
of iterations; that is, finding the set that leads to a uniform
rendering process. Several different heuristic methods for
choosing efficient sets of probabilities have been proposed
in the literature, but none of them solves the problem in the
general case [4, 6, 10]. The most standard of these methods
was suggested by Barnsley [1] and has been widely used
in the literature. For each of the mappings, this method
(called Barnsleys algorithm) selectes a probability value
that is proportional to the area of the figure associated with
the mapping. Taking into account that the area filled by a
linear mapping wi is proportional to its contractive factor,
si , this algorithm proposes the following set of probabilities:

Figure 8. Graphics setting... window

for instance) to 19 for the chaos example.

5. Choice of Probabilities
The fractal image is determined only by the set of contractive mappings; the set of probabilities gives the efficiency of the rendering process. Thus, a good choice for
the probabilities is relevant for the efficiency of the rendering process, since the random sequence of points is generated according to these probabilities. Figure 9 shows the
enormous resolution difference among the fractal images
associated with four different sets of probabilities and the
sam number of iterations in all cases (3000 iterations in this
example).
This figure illustrates the key role that the set of probabilities play in the efficiency of this algorithm. The differences
among the rendering processes are due to the different distributions of points generated by the different sets of probabilities over the fractal attractor. For example, with the
second choice of probabilities p1 = 0.6, p2 = 0.2, p3 = 0.2

si
pi = P
n
sj
j=1

139

i = 1, . . . , n.

(5)

Figure 10. Comparing the efficiency of three methods for choosing probabilities for the IFS chaos
game (left to right: random method, Barnsleys method and multifractal method) for three IFS fractal
examples (top to bottom: zig-zag, Barnsleys fern and spiral)

However, this choice of the probabilities is far from being the most efficient in some situations. Another algorithm
(proposed in 1996 by Gutierrez, Iglesias and Rodrguez)
known as multifractal algorithm, provides a method for obtaining the most efficient choice for the probabilities in the
case of non-overlapping IFS models, like is the case of the
Sierpinskys gasket and many other fractals. Intuitively, a
non-overlapping IFS is one whose self-similar parts do not
overlap each other. The basic idea of the proposed method
is using a multifractal analysis to characterize the perfor-

mance of the different sets of probabilities in the rendering process [13, 14]. As a results, they obtained that the
standard choice for the probabilities given in (5) do not correspond to the best choice and that the most efficient set
of probabilities have to lead to a multifractal measure with
the smallest strength of singularities [15]. The minimum
strength of singularities is given by the condition [14]:
log(pi ) = Dlog(wi ) pi = wiD ,

(6)

where D is a real constant. We must also consider that the

140

sum of this set of probabilities must be one. Thus, D is the

unique real number satisfying
n
X

wiD = 1.

include some other interesting features such as the computation of the fixed points for the contractive functions and
other numerical and symbolic computations. On the other
hand, we want to explore other ways to generate 2D fractals,
such as escape algorithms, L-systems, etc. The implementation of other types of fractals like Julias and Mandelbrots
sets are also goals for further work. Finally, we plan to use
Matlabs graphical capabilities to extend our program to the
three-dimensional case. Fractals in the 3D space are both
challenging and more difficult to generate. They are typically constructed by superimposing polyhedra upon themselves recursively, a computational expensive technique in
terms of CPU and memory requirements. Stereographic images, that will provide a higher degree of realism and a truly
three-dimensional feeling to our fractal artwork, are also
part of our future work.

(7)

i=1

Then, the most efficient choice corresponds to

pi = sD
i ; i = 1, . . . , N

(8)

where D denotes the similarity dimension. If the contractive

mappings are non-overlapping similarities, then the only
real number satisfying (8) is the fractal dimension of the
fractal set. Otherwise, the number obtained will be an approximation of such dimension. For example, the mappings
associated with the Sierpinskys gasket are non-overlapping
 D
1
1
=
similarities and, thus, Equation (8) becomes
2
3
that gives its fractal dimension D = 1.585... in good agreement with our previous result in Section 2.1.
Our program allows us to select the set of probabilities according to the above-mentioned algorithms. Figure
10 shows a comparison of IFS fractals when three different methods for obtaining the probabilities are used. The
first column corresponds to a random choice, leading to
the worst results, second column is the classical Barnsleys
method and third column corresponds to the multifractal
method, which yields the best results in all cases. All figures
in each row are displayed for the same numbeer of iterations: 2000 for the zig-zag fractal and 3000 for both the fern
and the spiral. Note the very poor result when random probabilities are chosen, making it hard to even recognize the
general shape. Note also that, although Barnsleys method
yields recognizable objects for our number of iterations, the
distribution of points is far from being uniform: some parts
are overdrawn while others are just slightly sketched (see,
for instance the lower corner of zig-zag and the upper corner of the fern). In contrast, multifractal method yields a
very uniform distribution of points all over the fractal so all
areas are similarly displayed.

Acknowledgments
This research has been supported by the Computer Science
National Program of the Spanish Ministry of Education and
Science, Project Ref. #TIN2006-13615 and the University
of Cantabria.

References
[1] Barnsley, M.F.: Fractals Everywhere, Second Edition. Academic Press (1993)
[2] Barnsley, M.F. , Hurd, L.P.: Fractal Image Compression. AK
Peters, Wellesley, MA. (1993)
[3] Elton, J.H.: An Ergodic Theorem for Iterated Maps, Ergodic Theory Dynam. Syst., 7, 481-488 (1987)
[4] Falconer, K.: Fractal Geometry: Mathematical Foundations
and Applications. Wiley (1990)
[5] Fisher, Y.: Fractal Image Compression: Theory and Applications. Springer-Verlag (1995)
[6] Forte, B. Vrscay, E. R.: Solving the inverse problem for measures using iterated function systems : a new approach. Adv.
Appl. Prob., 27, 800-820 (1995)

6. Conclusions and Future Work

[7] Galvez, A.: Numerical-symbolic Matlab program for the

analysis of three-dimensional chaotic systems. Lectures
Notes in Computer Science, 4488 211-218 (2007)

In this paper a new Matlab program for generating and

rendering IFS fractals is introduced. The program allows us
to display any two-dimensional IFS fractal by using a number of graphical and numerical options that are explained
throughout the paper. The good performance of our computer system is illustrated by means of a collection of examples and a gallery of beautiful two-dimensional fractal
objects.
Regarding our future work, we plan to extend our program in several different ways: on one hand, we want to

[8] Galvez, A., Iglesias, A.: Symbolic/numeric analysis of

chaotic synchronization with a CAS. Future Generation
Computer Systems 25(5) 727-733 (2007)
[9] Galvez, A.: Matlab Toolbox and GUI for Analyzing Onedimensional Chaotic Maps, IEEE Computer Society Press,
Los Alamitos, California, USA, 321-330 (2008)
[10] Graf, S.: Barnsleys scheme for the fractal encoding of images. Journal of Complexity, 8, 72-78 (1992)

141

[11] Gutierrez, J.M., Iglesias, A., Rodrguez, M.A.: Logistic

Map Driven by Correlated Noise. Second Granada Lectures
in Computational Physics. Garrido, P.L., Marro, J. (Eds.)
World Scientific, Singapore, 358-364 (1993)

[27] Wein, C. J. , Blake, E.: On the performance of fractal compression with clustering. IEEE Transactions on Image Processing, 5(3), 522-526 (1996)

[12] Gutierrez, J.M., Iglesias, A., Rodrguez, M.A.: Logistic

Map Driven by Dichotomous Noise. Physical Review E,
48(4), 2507-2513 (1993)
[13] Gutierrez, J.M., Iglesias, A., Rodrguez, M.A., Rodrguez,
V.J.: Fractal Image Generation with Iterated Function Systems. In Mathematics With Vision. In: Proceedings of the
First International Symposium of Mathematica, V. Keranen
and P. Mitic (Eds.), Computational Mechanics Publications, ,
175-182 (1995)
[14] Gutierrez, J.M., Iglesias, A., Rodrguez, M.A.: A Multifractal Analysis of IFSP Invariant Measures with Application to
Fractal Image Generation. Fractals, 4(1), 17-27 (1996)
[15] Gutierrez, J.M., Iglesias, A., Rodrguez, M.A., Rodrguez,
V.J.: Efficient Rendering in Fractal Images. The Mathematica Journal, 7(1), 7-14 (1997)
[16] Gutierrez, J.M., Iglesias, A.: A Mathematica package for
the analysis and control of chaos in nonlinear systems. Computers in Physics, 12(6), 608-619 (1998)
[17] Hutchinson, J.: Fractals and Self-Similarity. Indiana Univ.
Math. Jour., 30, 713-747 (1981)
[18] Iglesias, A., Galvez, A.: Analyzing the synchronization of
chaotic dynamical systems with Mathematica: Part I. Lectures Notes in Computer Science 3482, 472-481 (2005)
[19] Iglesias, A., Galvez, A.: Analyzing the synchronization of
chaotic dynamical systems with Mathematica: Part II. Lectures Notes in Computer Science 3482, 482-491 (2005)
[20] Iglesias, A., Galvez, A.: Revisiting some control schemes
for chaotic synchronization with Mathematica. Lectures
Notes in Computer Science 3516, 651-658 (2005)
[21] Jacquin, A.E.: Image Coding Based on a Fractal Theory of
Iterated Contractive Image Transformations. IEEE Transactions on Image Processing, 1(1), 18-30 (1992)
[22] Mandelbrot, B. B.: The Fractal Geometry of Nature. W. H.
Freeman and Co. (1982)
[23] The Mathworks Inc: Using Matlab. Natick, MA (1999)
[24] Mitra, S. K., Murthy, C. A., Kundu, M. K.: Technique
for fractal image compression using genetic algorithm. IEEE
Transactions on Image Processing, 7(4), 586-593 (1998)
[25] Peitgen, H. O., Jurgens, H. and Saupe, D.: Chaos and Fractals. New Frontiers of Science. Springer-Verlag (1993)
[26] Thomas, L., Deravi, E.: Region-based fractal image compression using heuristic search. IEEE Transactions on Image
Processing, 4(6), 832-838 (1995)

142