mandelbrot maps: a web application tool for exploring fractals · abstract mandelbrot maps is a...

$: Mandelbrot Maps: A Web Application Tool for Exploring Fractals · Abstract Mandelbrot Maps is a fractal explorer for the Mandelbrot Set and the Julia Sets allow-ing for their real$
Mandelbrot Maps: A Web

Application Tool for Exploring

Fractals

Edward Mallia

Master of Science

School of Informatics

University of Edinburgh

2009

Abstract

Mandelbrot Maps is a fractal explorer for the Mandelbrot Set and the Julia Sets allow-

ing for their real time exploration. The fractal explorer also provides mechanisms for

studying two important theorems that relate the two sets together - Tan Lei’s similarity

theorem and Fatou’s connectedness theorem. The tool has been used to show case how

parallelisation techniques can be used to obtain better performance.

The produced artefact is an easy to use fractal explorer, that produces stunning

images of the Mandelbrot Set and the Julia Set and allows for the deeper exploration

of the relationship between these sets.

i

Acknowledgements

Infinite thanks go to my supervisor, Professor P. Wadler, for his invaluable advise

throughout the project. It has been an honour working with you.

A big heart felt thank you goes out to my parents without whom studying in Edin-

burgh would not have been possible. May God bless you and keep you both in good

health.

I would also like to thank all my family and friends who have supported me

throughout this year through a friendly chat, an encouraging comment or a night out.

A special thanks goes out to Kurt whose constant support can be summed up in one

word - priceless.

Finally, an especially big thanks goes to my girlfriend Angela who literally stood

by me during this whole year. Thanks for all your support! I dedicate this dissertation

to you.

ii

Declaration

I declare that this thesis was composed by myself, that the work contained herein is

my own except where explicitly stated otherwise in the text, and that this work has not

been submitted for any other degree or professional qualification except as specified.

(Edward Mallia)

iii

Table of Contents

1 Introduction 11.1 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 Mandelbrot Maps Project . . . . . . . . . . . . . . . . . . . . . . . . 2

1.3 Dissertation Overview . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Mathematical Background 62.1 Mandelbrot Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2 Escape Time Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3 Julia Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.4 Mathematical Properties . . . . . . . . . . . . . . . . . . . . . . . . 9

2.4.1 Dichotomy Theorem . . . . . . . . . . . . . . . . . . . . . . 9

2.4.2 Cataloguing the Julia Sets . . . . . . . . . . . . . . . . . . . 10

2.4.3 Similarities between the Mandelbrot Set and the Julia Sets . . 11

2.4.4 Small Copies of the Mandelbrot Set . . . . . . . . . . . . . . 11

3 A Critical Review of Mandelbrot Maps 143.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.2 Colouring Scheme . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.3 Fatou’s Connectedness Theorem . . . . . . . . . . . . . . . . . . . . 17

3.4 Tan Lei’s Similarity Theorem . . . . . . . . . . . . . . . . . . . . . . 17

4 Designing and Implementing the Enhancements 204.1 Designing a New Colouring Scheme . . . . . . . . . . . . . . . . . . 20

4.1.1 Facilitating the Creation of new Colouring Schemes . . . . . 21

4.1.2 The Spiral Colouring Scheme . . . . . . . . . . . . . . . . . 22

4.1.3 Continuous Path Colouring Scheme . . . . . . . . . . . . . . 24

4.1.4 Choosing the Colouring Scheme . . . . . . . . . . . . . . . . 26

4.1.5 Evaluating the New Colouring Scheme . . . . . . . . . . . . 26

iv

4.2 Facilitating the exploration of Tan Lei’s Theorem . . . . . . . . . . . 29

4.3 Designing the Continuous Mode . . . . . . . . . . . . . . . . . . . . 30

4.3.1 Preparing for the Continuous Mode . . . . . . . . . . . . . . 30

4.3.2 The Continuous Process . . . . . . . . . . . . . . . . . . . . 32

4.3.3 Optimising the Continuous Process . . . . . . . . . . . . . . 33

4.4 Fixing the Julia Curve Location . . . . . . . . . . . . . . . . . . . . 33

4.5 Reusing Old Renderings . . . . . . . . . . . . . . . . . . . . . . . . 34

4.5.1 What information to store . . . . . . . . . . . . . . . . . . . 35

4.5.2 How to store the information . . . . . . . . . . . . . . . . . . 35

4.5.3 Reusing old renderings . . . . . . . . . . . . . . . . . . . . . 37

4.6 Exploiting parallelism . . . . . . . . . . . . . . . . . . . . . . . . . . 39

4.6.1 Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . 40

4.6.2 Distributed Parallelism . . . . . . . . . . . . . . . . . . . . . 42

4.7 Improving the Deployment Environment . . . . . . . . . . . . . . . . 44

4.7.1 Improving the deployment mechanism . . . . . . . . . . . . . 44

4.7.2 Improving the loading process . . . . . . . . . . . . . . . . . 45

4.7.3 Facebook Integration . . . . . . . . . . . . . . . . . . . . . . 46

4.7.4 Facelift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5 Evaluation & Results 485.1 User Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.1.1 Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.1.2 User Feedback . . . . . . . . . . . . . . . . . . . . . . . . . 49

5.1.3 Rating the Continuous Mode . . . . . . . . . . . . . . . . . . 53

5.2 Performance Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . 57

5.2.1 Evaluating the Multithreaded Solution . . . . . . . . . . . . . 57

5.2.2 Evaluating the Parallel Distributed Solution . . . . . . . . . . 61

6 Conclusion 636.1 Future Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

6.1.1 A Distributed Solution . . . . . . . . . . . . . . . . . . . . . 63

6.1.2 Integrating Mandelbrot Maps with Social Networking Sites . 63

6.1.3 Colouring Schemes . . . . . . . . . . . . . . . . . . . . . . . 64

6.1.4 Other rendering techniques . . . . . . . . . . . . . . . . . . . 64

6.2 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

v

A Complex coordinates and Mandelbrot Maps Links for fractal images 65

Bibliography 73

vi

List of Figures

1.1 Mandelbrot Maps Screenshot . . . . . . . . . . . . . . . . . . . . . . 4

1.2 Disconnected Julia Set shown in Figure 1.1, is here shown as con-

nected with Continuous Mode switched off . . . . . . . . . . . . . . 4

2.1 The Mandelbrot Set (Maximum Iterations = 160) . . . . . . . . . . . 7

2.2 The Mandelbrot Set (Maximum Iterations = 10) . . . . . . . . . . . . 8

2.3 Connected Julia Set (c =−0.123+0.732i) . . . . . . . . . . . . . . . 10

2.4 Disconnected Julia Set (c =−0.010+0.675i) . . . . . . . . . . . . . 10

2.5 The Mandelbrot Set (left) and the Julia Set (right) at the same location

with the same zoom level . . . . . . . . . . . . . . . . . . . . . . . . 11

2.6 The Julia Set (right) has been zoomed out to better observe the sim-

ilarity between the two curves. The black box shows the area that is

shown in the Julia Set of Figure 2.5. . . . . . . . . . . . . . . . . . . 12

2.7 Copy of the Mandelbrot Set (found at -1.910 + 0i) . . . . . . . . . . . 13

2.8 Copy of the Mandelbrot Set (found at -0.245 + 0.757i) . . . . . . . . 13

3.1 The original Mandelbrot Maps Screenshot . . . . . . . . . . . . . . . 15

3.2 Change in colour when maximum iterations is varied . . . . . . . . . 16

3.3 Snapshot of the Mandelbrot Set and the related Julia Curve . . . . . . 18

4.1 RGB Colour Cube [15] . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.2 Conical Spiral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.3 Colours for the first few iterations . . . . . . . . . . . . . . . . . . . 25

4.4 RGB Colour Wheel [14] . . . . . . . . . . . . . . . . . . . . . . . . 25

4.5 Path followed in the 3D colour cube . . . . . . . . . . . . . . . . . . 25

4.6 Comparing the Colouring Schemes (CS) : Spiral CS & Continuous

Path CS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4.7 Shows differences between the old and the new Colouring Schemes (CS) 28

vii

4.8 Place Marker shown on the Mandelbrot Set . . . . . . . . . . . . . . 34

4.9 R-Tree Example: The spatial data that is inserted into the RTree (shown

in Figure 4.10) showing their grouping according to the nodes the ob-

jects are inserted in. Also shows the search area used in the example

as a red bordered box. . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.10 R-Tree Example: The R-Tree that is generated when the spatial data

show in Figure 4.9 is inserted into it. . . . . . . . . . . . . . . . . . . 38

4.11 Submitting a rendering process . . . . . . . . . . . . . . . . . . . . . 41

4.12 Architecture for exploiting distributed parallelism . . . . . . . . . . . 44

4.13 Screenshot of the problem that occurred on start up . . . . . . . . . . 45

4.14 Screenshots of the original and the new Mandelbrot Maps . . . . . . . 47

5.1 Features the respondents understood how to use . . . . . . . . . . . . 50

5.2 Dual Core : Rendering Time vs. Maximum Iterations . . . . . . . . . 58

5.3 Dual Core : Rendering Time vs. Number of Threads . . . . . . . . . 59

5.4 Single Core : Rendering Time vs. Maximum Iterations . . . . . . . . 60

5.5 Single Core : Rendering Time vs. Number of Threads . . . . . . . . . 60

5.6 Rendering Time vs. Maximum Iterations . . . . . . . . . . . . . . . . 61

5.7 Rendering Time vs. Number of Nodes . . . . . . . . . . . . . . . . . 62

viii

List of Tables

2.1 Different initial values for the Mandelbrot Set and the Julia Sets . . . 8

ix

Chapter 1

Introduction

Mandelbrot Maps[26, 27] is a web application that allows the users to explore the

Mandelbrot Set and the associated Julia Sets. It was originally developed by Iain Parris,

a former Informatics postgraduate student at the University of Edinburgh, and is now

being improved as the output of this project.

1.1 Background

The Mandelbrot Set was discovered by Benoı̂t B. Mandelbrot in the 1980’s and “no

other modern mathematical object has become part of both scientific and popular cul-

ture as rapidly and thoroughly as the Mandelbrot Set” [7].

The boundary of the Mandelbrot Set has a fractal structure, a term coined by Benoı̂t

B. Mandelbrot to describe geometrical figures which have repeating patterns that occur

at different scales[12]. The Mandelbrot Set, like all other fractals, arises from a simple

iterative process. The process in question is the iteration of the non-linear relation

zn+1 = zn + c on the points of the complex plane. Complex points which escape to

infinity under this relation are considered as being outside the Mandelbrot Set, while

points that remain bounded are considered as being inside the Mandelbrot Set.

It turns out that the same relation was already studied in the early 20th century

by Julia and Fatou which lead to the discovery of the Julia Sets. The Julia Sets also

have a fractal structure and are generated using the same iterative process employed

in the generation of the Mandelbrot Set but with slightly different initial conditions

(discussed in Chapter 2). There is only one Mandelbrot Set and infinitely many Julia

Sets - each point on the complex plane acting as a parameter to the Julia Set.

There are two important theorems that describe the relations between the Man-

1

Chapter 1. Introduction 2

delbrot Set and the Julia Sets. A theorem by Fatou and Julia proves that picking the

parameter for the Julia Set from within the Mandelbrot Set generates a connected set,

and picking the parameter from outside the Mandelbrot Set generates a disconnected

Julia Set. Another theorem by Tan Lei discusses how the Mandelbrot Set and the Julia

Set look similar for certain locations.

Understanding these mathematical theorems is a complex process requiring a high

level of mathematics. Mandelbrot Maps, and other fractal explorers, make these mag-

nificent sets accessible to everyone. Fractal explorers allow us to graphically visualise

and explore the sets while giving us the opportunity to understand and verify the sets’

mathematical properties. To visualise the sets, the explorers use the Escape Time al-

gorithm which iterates the points until they escape to infinity or until an imposed limit

on the number of iterations is reached. Typically, these explorers present the user with

a view of the Mandelbrot Set where they allow the selection of the parameter for the

Julia Set. Mandelbrot Maps provides an innovative solution whereby new Julia Sets

are generated simply by moving about the Mandelbrot Set.

1.2 Mandelbrot Maps Project

The overall aim of this project is to improve the original Mandelbrot Maps in order

to better portray Fatou and Julia’s connectedness theorem. The original Mandelbrot

Maps failed to correctly show that for all parameters of the Julia Set selected from

within the Mandelbrot Set the Julia Set was in fact connected. The suspected reason

for this misleading behaviour is that the iterative process was being terminated before

the relative points can break away and tend towards infinity.

The enhancement being proposed to solve the above problem is to allow for con-

tinuous computation after an initial render of the image. The continuous computation

mode will continuously colour in white parts that have been incorrectly classified as

within the set (due to the imposed upper limit of iterations). Implementing the con-

tinuous computation mode required careful software engineering for storing all the

necessary information required by this mode to operate correctly.

The evaluation process included obtaining user feedback about the new continuous

computation mode through a user survey. Several positive responses were received

indicating that the continuous computation mode is preferred and that it facilitated the

verification of Fatou’s connectedness theorem.

Other enhancements that were designed include:


• The creation of a new colouring scheme that does not change the colour of es-

caped pixels as the maximum number of iterations performed is increased.

• Devising of a mechanism that allows the easier verification of Tan Lei’s similar-

ity theorem.

• Exploiting multi-core CPUs by parallelising the image rendering process.

• Exploiting distributed computation for the rendering process. Due to time con-

straints this enhancement was not completed, however some results are presented

in the evaluation chapter which show that a distributed solution is possible under

certain conditions.

As part of the evaluation process, Professor Benoı̂t B. Mandelbrot was contacted

via email and was informed of Mandelbrot Maps. Professor Mandelbrot kindly replied

to the request, his comments may be seen in the email below dated 12th August 2009.

Dear Mr Mallia,

Thank you for pointing out to me the new fractal explorer youhave designed.

I am exceptionally busy at this point but viewed some of theprograms you list. I am impressed by the quantity and thequality of your work.

What are your plans after your Master?

Best wishes for your future career.

Benoit Mandelbrot

The new version of Mandelbrot Maps, available at http://inganoust.inf.ed.

ac.uk/mmaps, is an improvement on the original version. Certain desirable features,

such as accessibility to people with various mathematical background were kept while

facilitating the verification of Fatou’s connectedness theorem and Tan Lei’s similarity

theorem. Figure 1.1 shows a screenshot of Mandelbrot Maps with the Mandelbrot

Set on the left. The red pin shows the parameter chosen for the corresponding Julia

Set shown on the right. The Julia Set, shown as disconnected, is being computed in

continuous mode and if this were switched off we would get the connected Julia Set

shown in Figure 1.2.

http://inganoust.inf.ed.ac.uk/mmaps



Figure 1.1: Mandelbrot Maps Screenshot

Figure 1.2: Disconnected Julia Set shown in Figure 1.1, is here shown as connected

with Continuous Mode switched off


1.3 Dissertation Overview

Chapter 2 presents the mathematical background necessary for understanding how the

Mandelbrot Set and the Julia Set are generated. The chapter also discusses other

mathematical properties including the similarity and connectedness theorems which

we would like the new tool to better portray. Chapter 3 presents a critical analysis

of the original Mandelbrot Maps, outlining its strong points and discussing features

that need to be enhanced and added. Chapter 4 describes how the enhancements for

Mandelbrot Maps were designed and implemented, including the mechanisms created

for verifying the mathematical theorems and techniques used to exploit parallelism.

Chapter 5 evaluates the project through a user survey and shows some results related

to the performance of the implemented parallelisations.

Chapter 2

Mathematical Background

This chapter provides some basic mathematical background required to understand

the Mandelbrot Set and the Julia Sets, describe techniques in representing them and

discuss some mathematical properties of the sets.

2.1 Mandelbrot Set

The Mandelbrot Set, named after Benoı̂t B. Mandelbrot who discovered it, is the set of

points on the complex plane that remains bounded to the set when an iterative function

is applied to them. The iterative function in question is a non-linear relation where,

zn+1 = f (zn)

= zn2 + c

The set is built by iterating the function for each point on the complex plane and setting

z0 = 0 and c to the complex point being considered. Since c is a complex point it will

be in the form x+ yi, and the first iterations for c will be:

z0 = 0

z1 = z02 + c

z2 = (z02 + c)2 + c

...

If, through the iterative process, zn tends to infinity then we say that c is not part of

the Mandelbrot Set, otherwise we say that c is part of the Mandelbrot Set. The Man-

delbrot Set thus segments the complex plane into two regions - the Mandelbrot Set and

the rest of the complex plane. The two regions are separated by an infinitely crum-

pled boundary (i.e. zooming in on the boundary of the regions still shows a crumpled

6

Chapter 2. Mathematical Background 7

boundary) which shows us how “chaos and order cooperate to create intricately beau-

tiful images with self-replicating patterns” [28]. Mandelbrot referred to this crumpled

boundary as having a fractal structure similar to that seen in natural boundaries such

as coastlines[28].

Figure 2.1 shows a graphical representation of the Mandelbrot set which has been

drawn using the Escape Time Algorithm (discussed in the next section).

Figure 2.1: The Mandelbrot Set (Maximum Iterations = 160)

2.2 Escape Time Algorithm

Of particular interest to us is the graphical representation of the Mandelbrot Set, where

we colour each point depending on where its attractor lies (i.e. if it is attracted to

infinity or bound within the set). Points which remain bounded within the Mandelbrot

Set are coloured white, while points which break away and tend to infinity are coloured

depending on the number of iterations required to break away from the Mandelbrot Set.

To help us decide how to classify the points as within or outside the set, we use a

well known result [21] that is, if |zn| of zn (i.e. the distance of zn from the origin) is

greater than 2 then we can conclude that the iterative process will tend to infinity [28]

(note that a formal proof of this result is outside the scope of this project, but interested

readers can refer to [22]). A disc with radius 2 around the origin can be seen in Figure

2.1 as the outer dark blue circle. Points outside it are coloured black to indicate that

they escape after zero iterations.

The described well known result is the basis of the Escape Time Algorithm which

iterates points until they break away from the set (i.e. |zn|> 2) or n reaches an imposed


maximum. The algorithm always correctly classifies points outside the Mandelbrot

Set. However the imposed maximum number of iterations causes the algorithm to

misclassify points as being inside the set since they are not iterated enough times.

The misclassification of points can be clearly noticed when comparing Figure 2.1 and

Figure 2.2 where the latter was generated with a lower limit on the maximum iterations

and as a result has a larger white area (i.e. more points are misclassified as bounded).

Figure 2.2: The Mandelbrot Set (Maximum Iterations = 10)

2.3 Julia Sets

During the First World War, two French mathematicians, Gaston Julia and Pierre Fatou,

had already studied such boundaries with a fractal structure [28]. Although Julia and

Fatou managed to sketch some of their output graphically, they could not achieve the

detail that Mandelbrot (and others) obtained using computers. Known as Julia Curves

or Julia Sets, Julia and Fatou described the behaviour of an iterative function on the

complex plane. The iterative function turns out to be the same as the one used in the

generation of the Mandelbrot Set, however c and z0 are initialised at different values.

z0 c

Mandelbrot Set 0 point being drawn

Julia Sets (Kc) point being drawn fixed parameter

Table 2.1: Different initial values for the Mandelbrot Set and the Julia Sets

As outlined in Table 2.1, in generating the Mandelbrot Set c is varied depending on


the point that is being drawn, while in generating a Julia Set c is kept constant and z0

is varied depending on the point being drawn. In this way, a Julia Set is parametrised

by c, and for every c on the complex plane we get a different Julia Set. All the points

which remain bounded under the iterative function are said to be part of the filled in

Julia Set (Kc) [16], while the Julia Set (Jc) represents the boundary of the filled in Julia

Set [17].

The first iterations for generating the filled in Julia Set at point x and parametrised

by c are shown below,

z0 = x

z1 = z02 + c = x2 + c

z2 = z12 + c = (x2 + c)2 + c

...

The graphical representation of the filled in Julia Set is obtained in a similar way

to which the Mandelbrot Set is obtained. If |zn| of zn (i.e. the distance of zn from

the origin) is greater than 2 (i.e. the circle with radius two around the origin) then

the iterative process will tend to infinity [28]. Points which are bounded within this

disc are coloured white, while points which break away from this region are coloured

depending on the number of iterations required to break away.

2.4 Mathematical Properties

In this section we will discuss mathematical properties of the Mandelbrot Set and the

Julia Sets while outlining some of the relationships that exist between them.

2.4.1 Dichotomy Theorem

The Dichotomy1 Theorem [18], proved independently by Fatou and Julia in 1919 [28],

states that the filled in Julia Set Kc is either connected or disconnected. In a connected

filled Julia Set all the points in the set can be found in one connected block of points,

while a disconnected set, referred to as a Cantor Set, is made up of infinitely many

pieces with no two points touching each other.

1Dichotomy: the division into two opposed groups or parts[1]


2.4.2 Cataloguing the Julia Sets

Since the Julia Sets are parametrised by a complex point c, we can say that with one

image Mandelbrot managed to create a catalogue of all the Julia sets which indexes

and characterises all the Julia sets [8]. Of particular interest to us is the existence of

characteristics that can be portrayed graphically to the user. One of these characteris-

tics follows from Julia and Fatou’s dichotomy theorem, states that for a point c within

the Mandelbrot Set (i.e. c does not escape to infinity under the iterative function) the

corresponding Julia Set Kc is said to be connected. The converse applies, so that if

a point c lies outside of the Mandelbrot Set then the corresponding Julia Set Kc is a

Cantor Set.

Figure 2.3: Connected Julia Set (c =−0.123+0.732i)

Figure 2.4: Disconnected Julia Set (c =−0.010+0.675i)

In [28], Douday describes how he decided to name the Mandelbrot Set after its


discoverer,

For a mathematician, this is a good opportunity to define a new set:The set of values of c for which Kc is connected. I called it the Mandelbrotset M because Benoı̂t Mandelbrot was the first one to produce pictures ofit.

Figures 2.3 and 2.4 respectively show a connected and a disconnected Julia Set

together with the location of the c parameter pin pointed on the Mandelbrot Set.

2.4.3 Similarities between the Mandelbrot Set and the Julia Sets

A theorem by Tan Lei [13] discusses the similarity that exists between the Mandelbrot

Set M and the Julia Curve Kc both zoomed in at point c. As explained in [28],

If you look at M with a microscope focused at c, what you see resem-bles very much what you see if you look at the Julia set Kc with the samemicroscope still focused at c, and the resemblance tends to become perfect(except for a change of scale) when you increase the magnifying power.

Figures 2.5 and 2.6 show an example obtained from [29], where the similarity is

not only up to a change of scale but also requires that the Julia Set be rotated by 55◦ in

a counter clockwise fashion to obtain identical images.

Figure 2.5: The Mandelbrot Set (left) and the Julia Set (right) at the same location with

the same zoom level

2.4.4 Small Copies of the Mandelbrot Set

An interesting replicating pattern that occurs on the boundary of the Mandelbrot Set is

that of the image of Mandelbrot Set itself [19]. In other words, zooming in at particular


Figure 2.6: The Julia Set (right) has been zoomed out to better observe the similarity

between the two curves. The black box shows the area that is shown in the Julia Set of

Figure 2.5.

locations of the Mandelbrot Set will show miniature copies of the Mandelbrot Set, and

re-zooming on the copy to the analogous location will reveal another copy of the set.

This process of zooming in and finding new small copies of the Mandelbrot Set is an

infinite process, making the border of Mandelbrot Set an infinitely complex structure.

The small copies of the Mandelbrot Set are not perfect copies of the original set and

have their own subtle distortions and are surrounded by different boundaries. Figures

2.7 and 2.8 show two of the copies found on the boundary of the Mandelbrot Set. These

images might suggest that the small Mandelbrot Set copies are like islands which are

disconnected from the main Mandelbrot Set (and each other) [20]. However, Douady

and Hubbard have shown that the Mandelbrot Set is in fact connected and these small

Mandelbrot Set copies are connected with each other through tiny strings made up of

copies of the Mandelbrot Set [20, 5].


Figure 2.7: Copy of the Mandelbrot Set (found at -1.910 + 0i)

Figure 2.8: Copy of the Mandelbrot Set (found at -0.245 + 0.757i)

Chapter 3

A Critical Review of Mandelbrot Maps

Since the overall aim of the project is to improve the existing Mandelbrot Maps [26]

fractal explorer, we need to perform a critical review of the tool with the aim of iden-

tifying desirable features we would like to keep and other features which need to be

improved.

3.1 Description

Mandelbrot Maps is an open source fractal explorer that allows the exploration of the

Mandelbrot Set and the associated Julia Sets. In comparison to other fractal explorers,

Mandelbrot Maps provides the facility of generating Julia Sets in real time while mov-

ing around in the Mandelbrot Set. The applet provides a simple and intuitive interface

borrowed from the extremely popular mapping application Google Maps [2] allowing

the user to use the mouse for panning and zooming. Mandelbrot Maps also allows the

user to save particular views either as images with different resolution sizes or as links

which act as bookmarks to interesting locations within the fractals. A screenshot of

the original Mandelbrot Maps applet can be seen in Figure 3.1.

3.2 Colouring Scheme

Although the colouring scheme employed by the original Mandelbrot Maps produces

stunning images of the Mandelbrot Set and the Julia Sets certain aspects of it can still

be improved. We will first explain how the colouring scheme works and then identify

problems that we will attempt to solve.

A function for each of the primary colours in the RGB space is defined over the

14

Chapter 3. A Critical Review of Mandelbrot Maps 15

Figure 3.1: The original Mandelbrot Maps Screenshot

continuous interval 0-1, where 0 represents 0 iterations required to escape from the

Mandelbrot Set and 1 represents a point which is bound within the set. The functions

return a value between 0 and 255 representing the contribution of the component (i.e.

Red/Green/Blue) to the final colour. When in use, the 0-1 space is scaled to match

the interval of iterations between 0 and the maximum number of iterations, granting a

unique colour to each iteration escape value. The term iteration escape value will be

used to refer to the number of iterations required for a point to escape from the set.

As the maximum number of iterations used in the Escape Time algorithm (Section

2.2) is increased for a particular image, the 0-1 interval is split between more iterations

causing iteration escape values to shift left to make space for new iterations escape

values. This shifting causes iteration escape values to change colour, an undesirable

effect as we would like the colouring scheme to be consistent in colouring points as the

maximum number of iterations is increased. For example, if a point that escapes after

50 iterations is coloured red when the maximum number of iterations imposed is 100,

then we expect that the same point (which will still escape after 50 iterations) will be

coloured red when the maximum number of iterations imposed is 200.

Figure 3.2 shows the situation described above where the same escaped points

have different colours as the imposed maximum number of iterations is increased.

Figure 3.2(a) shows part of the Mandelbrot Set generated when the maximum number

of iterations was set to 60, Figure 3.2(b) shows the same part of the Mandelbrot Set


(a) Maximum Iterations = 60

(b) Maximum Iteration = 240

(c) Maximum Iteration = 2000

Figure 3.2: Change in colour when maximum iterations is varied


generated when the maximum number of iterations was set to 240, and the Figure

3.2(c) has a maximum number of iterations of 2000.

As can be observed by comparing these images, the colouring scheme also causes

loss in the detail of the image. The contours that segment points with different iteration

escape values and are clearly visible in Figures 3.2(a) and 3.2(b) are completely lost in

Figure 3.2(c).

The example given above for the Mandelbrot Set also applies to the rendering of

the Julia Sets as a colouring scheme with the same properties is used. However, the

colouring scheme for the Julia Sets has different functions for the RGB components

giving out differently coloured images. Using different colouring schemes makes it

harder to notice the similarities between the Mandelbrot Set and the Julia Curve ex-

plained in Section 2.4.3.

3.3 Fatou’s Connectedness Theorem

As explained in Section 2.4.2, the Julia Set for a point within the Mandelbrot Set is

expected to be connected while the Julia Set for a point outside the set is expected to

be disconnected. The first version of Mandelbrot Maps failed to show all Julia Sets

with a c parameter chosen from the Mandelbrot Set as disconnected. We suspect that

the reason for the curves to be incorrectly shown as connected is that computation is

being terminated before the relative points can break away and tend towards infinity.

Forcing more iterations to be performed (through the contrast slider) will eventually

show that the Julia Set is in fact disconnected.

Figure 3.3 shows an example of when the tool portrays the Julia Set (Figure 3.3(b))

for a point outside the Mandelbrot Set (marked with a red pin in Figure 3.3(a)) as con-

nected when in fact it should be disconnected. Unfortunately, we cannot increase the

maximum number of iterations further as the image was generated with the maximum

possible iterations allowed by the tool at that location.

3.4 Tan Lei’s Similarity Theorem

As explained above, the Mandelbrot Set and the Julia Sets are coloured using two

different colouring schemes which makes it harder to observe similarities between

the two images. However, there is a bigger hurdle in being able to observe these

similarities. Recall (Section 2.4.3) that Tan Lei’s theorem states that similarity occurs


(a) Mandelbrot Set

(b) Julia Curve

Figure 3.3: Snapshot of the Mandelbrot Set and the related Julia Curve


when the Mandelbrot Set and the Julia Set Kc are both centred and zoomed in on point

c. The original version of Mandelbrot Maps defines no mechanism in which the user

can easily browse to the same location in both the Mandelbrot Set and the associated

Julia Set, and has to manually move around the two sets without a clear indication of

where he/she is within the set.

Chapter 4

Designing and Implementing the

Enhancements

In designing and developing the enhancements for Mandelbrot Maps an iterative ap-

proach was adopted where new features were designed, implemented, tested and in-

tegrated into the application on completion. User feedback and the integration of

new features required code refactoring to be carried out throughout the lifetime of the

project. The new version of Mandelbrot Maps can be found at

http://inganoust.inf.ed.ac.uk/mmaps/.

4.1 Designing a New Colouring Scheme

As explained in Section 3.2, the colouring scheme used in the original Mandelbrot

Maps tool does not exhibit the desired behaviour when increasing the maximum num-

ber of iterations and thus needs to be improved. In defining the colouring scheme,

Parris [27] sets the following properties that need to be satisfied:

• Aids intuition - allows users to identify between points with different escape

values

• Is aesthetically-pleasing

• Each iteration percentage (i.e. the 0-1 interval described in Section 3.2) should

be represented by a unique colour

• A point which escapes after zero iterations should be coloured black, and a point

which is bound within the set should be coloured white

20

http://inganoust.inf.ed.ac.uk/mmaps/

Chapter 4. Designing and Implementing the Enhancements 21

• Use continuous functions in order to avoid colour discontinuities

Experience has shown that the above stated properties generate colouring schemes

which change the colour of escaped points as the maximum number of iterations per-

formed by the escape time algorithm is increased. Ultimately this behaviour causes

loss of detail as the differences between the unique colours become invisible to the

naked eye. The third property mentioned above is responsible for this behaviour of the

colouring scheme by requesting that each iteration escape value is assigned a unique

colour.

The constraint imposed by the third property can be relaxed if the property is re-

placed by:

• Each iteration escape value should be always represented by the same colour, and

the colour should not be related to the maximum number iterations performed. In

other words, if an iteration escape value of 10 is coloured red when the maximum

number of iterations is 100, then the iteration escape value of 10 is still coloured

red under any other maximum number of iterations.

• The colouring scheme can repeat itself as the iteration escape values increase.

However, the intuition property defined above requires that colour repetition

frequency is low enough to enable observers to pick out points with different

iteration escape values.

The following sections describe two new colouring schemes based on the above

stated properties and explain which colouring scheme was chosen and why.

4.1.1 Facilitating the Creation of new Colouring Schemes

In the original Mandelbrot Maps, the colouring scheme was part of the same method

that iterated the points to be drawn. Creating, or modifying, a colouring scheme meant

that one would need to modify the point iterating code. In order to make it easier to

create new colouring schemes the colour scheme was decoupled from the point iter-

ating code. The point iterating code would deal with the ColouringScheme interface

which defines two methods:

• int colourOutsidePoint(int iterations)

• int colourInsidePoint()


One could now easily create new colouring schemes by implementing this interface,

and using a newly defined colouring scheme would be as simple as creating an instance

of a different class for the point iterator.

Figure 4.1: RGB Colour Cube [15]

4.1.2 The Spiral Colouring Scheme

Our first intuition was to create a function that would pick as may colours as possible

from the RGB space. Figure 4.1 shows an RGB colour cube with black hidden at the

origin of the three axes and white at the opposite end of the cube. One way to traverse

the colour cube is to spiral out from the black region, reach the cube border limits and

then start again. Explaining how the spiral colouring scheme was obtained requires the

explanation of how a conical spiral is defined mathematically on the xyz-plane.

Recall that a circle of radius R on the xy-plane can be described in the following

ways [11]:

• Parameter Form: x(θ) = R cos(θ), y(θ) = R sin(θ)

• Polar Equation: r(θ) = R

Given this definition of a circle, a simple spiral (spiral of Archimedes) is defined

by setting the above functions as follows:

• r(θ) = a.θ (where a is a constant)

• x(θ) = r(θ)cos(θ)

• y(θ) = r(θ)sin(θ)


The function for the Archimedes spiral can be modified to generate a conical spiral

on the xyz-plane as shown in Figure 4.2. This conical spiral can be obtained by setting

r, x, y & z as follows:

• r(θ) = θ (i.e. a = 1)

• x(θ) = 2 × r(θ) × (cos(θ)+1)

• y(θ) = 2 × r(θ) × (sin(θ)+1)

• z(θ) = θ

Figure 4.2: Conical Spiral

The spiral colouring scheme uses the conical spiral shown in Figure 4.2 to find

out the output values of the 3 colour components - red, green and blue, by setting

θ to grow in relation to the number of iterations. More specifically, one revolution

(i.e. 2π) was set to represent 255 iterations (so 510 iterations would be represented

by 4π etc.). 255 iterations was picked as it was judged to give an acceptable range

of colours while having adjacent colours different enough to produce clear contours

between themselves.

The values extracted from the conical spiral are in no way bound, and need to be

scaled to fit into the 0-255 range used by the colour components. Further more, to

avoid too dark colours that look too close to black, the range is further restricted to

25-255. The individual colour components are computed as follows:


• Red : z × 230

• Green : y × 230

• Blue : x × 230

This operation will generate numbers that are still unbounded. To bind them within

the 25-255 range, the following steps are performed on the computed colour compo-

nent (cc):

1. If cc > (230 × 2) then subtract (230 × 2) enough times until cc is in the range

0-(230 × 2)

2. If cc > 230 then cc = 230 − (cc − 230) (i.e. start counting backward from 230

to 0). For example if cc = 250, then cc would become 210. This operation is

performed to have the sequence of colour components as continuous as possible.

3. The colour component to be used is cc + 25, bringing the value in the range

25-255.

The resulting first few iterations produced by this colour scheme are shown in

Figure 4.3. One immediately notices that the plot is not a perfect conical spiral. The

imperfection can be attributed to the operations performed above by forcing the spiral

to turn prematurely. Figure 4.6(a) shows part of the Mandelbrot Set generated using

the spiral colouring scheme.

4.1.3 Continuous Path Colouring Scheme

A second approach adopted in designing a colouring scheme was to follow a continu-

ous fixed path around the RGB space. Visualising the RGB colour space as a wheel,

one can take a walk through the RGB colour space that starts from black and leads out

to blue and then moves from blue to cyan to green to yellow to red to magenta and

back to blue to start again.

Figure 4.4 shows this walk on the RGB colour wheel, while Figure 4.5 shows the

path taken in the 3D colour cube. The diagrams clearly show that the sequence of

colours is repeated in the colouring scheme. This colour repetition will occur within

the same image for points that have different iteration escape values. Although one

might think that this colour repetition will cause confusion, users can use the repeating

colours to quickly classify points that escape later by following the flow of colours.


Figure 4.3: Colours for the first few iterations

Figure 4.4: RGB Colour Wheel [14]

Figure 4.5: Path followed in the 3D colour cube


Figure 4.6(d) shows the colours repeating themselves as they go deeper into the

seahorse valley1. Following the change in colour users can realise that the deeper you

go into the valley, the longer it takes to break away from the set. With this repeating

colouring scheme, users have an intuitive metric they can use to identify faster escaping

points rather than just identifying differently escaping points. Figure 4.6(c) also shows

the seahorse valley using the spiral colouring scheme, but this time the colours give no

indication of the speed in which points are escaping.

4.1.4 Choosing the Colouring Scheme

Figure 4.6 shows different locations from the Mandelbrot Set generated using the two

colouring schemes defined above.

The Continuous Path colouring scheme described in Section 4.1.3 was chosen to be

the colouring scheme for the new version of Mandelbrot Maps. The colouring scheme

will be used for both the Mandelbrot Set and the Julia Sets to help bring out any

similarities between the two curves (Section 3.4). There are three main reasons why

the continuous path colouring scheme was chosen over the spiral colouring scheme:

• When comparing the images in Figure 4.6 it is clear that the continuous path

colouring scheme produces images with colours that seem to be more continuous

without loosing any information through blending of the different colours.

• The continuous path colouring scheme allows users to easily identify slower

escaping points by intuitively following the fixed sequence of colours.

• In my opinion, the continuous path colouring scheme generates better looking

images.

4.1.5 Evaluating the New Colouring Scheme

Figure 4.7 shows part of the Mandelbrot Set generated using 60, 240 and 2000 as the

maximum number of iterations using the old and the new colouring scheme. The only

difference between the three images generated with the new colouring scheme is the

white part shown in the image generated with 60 iterations (Figure 4.7(b)). The white

1The space between the two largest white areas of the Mandelbrot Set is referred to as the SeahorseValley


(a) Part of M-Set - Spiral CS (b) Part of M-Set - Continuous Path CS

(c) Seahorse Valley - Spiral CS (d) Seahorse Valley - Continuous Path CS

(e) Part of M-Set - Spiral CS (f) Part of M-Set - Continuous Path CS

Figure 4.6: Comparing the Colouring Schemes (CS) : Spiral CS & Continuous Path CS


(a) Maximum Iterations = 60 (Old CS) (b) Maximum Iterations = 60 (New CS)

(c) Maximum Iteration = 240 (Old CS) (d) Maximum Iteration = 240 (New CS)

(e) Maximum Iteration = 2000 (Old CS) (f) Maximum Iteration = 2000 (New CS)

Figure 4.7: Shows differences between the old and the new Colouring Schemes (CS)


part is then filled-in in the other images with a higher maximum iterations. Compar-

ing these images to those generated by the old colouring scheme, shows that the new

colouring scheme is preserving image detail by not changing the colour of already

coloured-in points.

4.2 Facilitating the exploration of Tan Lei’s Theorem

Tan Lei’s Theorem, discussed in Section 2.4.3, states that the Mandelbrot Set and the

filled in Julia Set Kc look similar around the point c. To be able to explore this theorem,

the user is required to know the precise location he/she is currently exploring in the

Mandelbrot Set and then navigate to the same location on the Julia Set.

Our initial reaction to solve this problem was to display the coordinates of the

complex plane that are currently being explored. The coordinates allow the user to

keep track of his/her position in the set being explored, while also allowing the user to

navigate to a desired location in the set.

Although showing the coordinates made it a bit easier to navigate through the Julia

Set to a particular coordinate location, it still was painstakingly hard to locate an exact

position (especially when in a deep zoom location). The only viable solution was to

totally automate the process of centring the two views at the same location. A simple

mechanism was developed where by right clicking on the Mandelbrot Set:

1. Centres the Mandelbrot Set on the chosen point

2. Uses the chosen point as the c parameter for the Julia Set and locks the real time

generation of Julia Sets

3. Centres the Julia Set on the chosen point (i.e. Julia Set Kc is centred around c)

4. The Julia Set magnification level is set to match the magnification level of the

Mandelbrot Set

The similarity between the two curves is still up to changes in magnification and

rotation (as mentioned in Section 2.4.3), so the user still needs to adjust the zoom level

for the Julia Set to better notice the similarities between the two sets. However, this

mechanism facilitates the task by taking out the hard job of navigating to the same

locations on both sets.


4.3 Designing the Continuous Mode

Recall that the Julia Set should be connected for c parameters picked from within the

Mandelbrot Set and disconnected for c parameters picked from outside the Mandelbrot

Set (Section 2.4.2). As discussed in the critical review of Mandelbrot Maps (Section

3.3) instances were found where (disconnected) Julia Sets were misleadingly being

shown to be connected due to premature termination of the computation process.

The need for a solution to this problem was undisputed; however the approach to

be adopted was not straight forward. Clearly, the only way to achieve more detailed

images is to increase the maximum number iterations performed by the Escape Time

algorithm. The repercussion of simply increasing the maximum number of iterations

arbitrarily will slow down the generation of images that contain several points which

remain bounded. Note that these points can be iterated for an infinite number of time

and they will still remain bounded to the set.

Alternatively, images could generate up to an adequate level of detail, and improve-

ments on the initial rendering can be performed at a later stage. This concept was be-

hind the decision to create the continuous mode - a process which would continuously

improve the image being displayed after an initial render of it is generated.

4.3.1 Preparing for the Continuous Mode

The first hurdle to be overcome in designing the Continuous Mode was the manage-

ment of points that still needed to be iterated. The only point related information that

was being stored was the colour to be displayed. Hence identification of points that

required further iteration was easily obtained - all points coloured white would be con-

sidered. Knowing the coordinates of a point on the complex plane is not sufficient to

continue iterating the point; the number of iterations n it has been submitted to and the

current value of zn are also required. The estimation of zn is not possible, and the only

viable way of obtaining it is by iterating from z0 to zn.

The PointForIteration data structure was created to enable the storage of the

relevant information required to iterate a point, more specifically:

• x - The real part of the complex coordinates (i.e. x in (x+ yi))

• y - The imaginary part of the complex coordinates (i.e. y in (x+ yi))

• zX - The real part of the complex value obtained from the iterative process


• zY - The imaginary part of the complex value obtained from the iterative process

• cX - The real part of the complex value c. For the Mandelbrot Set cx = x and for

the Julia Set cx is the real part of the point parametrising the Julia Set

• cY - The imaginary part of the complex value c. For the Mandelbrot Set cy = y

and for the Julia Set cx is the imaginary part of the point parametrising the Julia

Set

• xPixel - The x position of the pixel on the screen

• yPixel - The y position of the pixel on the screen

• iterations - The number of iterations performed on the point so far

• pixelSize - The pixel size (i.e. what width on the complex-plane is this pixel

representing)

• escaped - Indicates whether the point has escaped or not

• colour - The colour assigned to the point

An abstract data type was defined to act as a collection for PointForIteration.

The abstract data type, PointsForIterationCollection, would allow us to imple-

ment the collection using different underlying data structures.

PointsForIterationCollection, defined as a Java interface, requires the imple-

mentation of the following operations:

• void addPoint(PointForIteration point) - Adds a PointForIteration

to the collection

• PointForIteration nextPointForIteration() - Returns the next point for

iteration from the collection. Note that the implementation should remove the

point from the collection, and the caller will have to add back the point to the

collection if further iterations are required (The reason for this decision will be

more apparent in Section 4.6.1.1.3).

• int pointCount() - Returns the number of points stored in the collection

The current implementation of this abstract data type is based on linked lists as this

data structure facilitates the removal of items from one end and the addition of items at

another end, thus allowing the points to be processed in a relative order while ensuring

that all points get a fair share of processing time.


4.3.2 The Continuous Process

Before the rendering of the image, a new PointsForIterationCollection is cre-

ated. This new collection is passed on to the point iterating code which is responsible

for populating the collection with points that have not escaped and thus require fur-

ther iterations under the continuous mode. The point iterating code was modified to

accommodate this new data structure so that the process now performs the following

steps:

• Create a new PointForIteration object

• Iterate the point

• Add the point to a PointsForIterationCollection collection if the point has

not escaped

• Colour the relative pixel

The collection is then passed on to the continuous process which picks a point from

the collection and iterates further. If the point does not escape, it is placed back into the

collection for further processing. If the point escapes, then its colour is changed from

white to the appropriate colour based on the number of iterations required to escape.

It was here that the inadequacy of the original colouring scheme became apparent.

The scheme segments the colour space into an equal number of parts depending on the

maximum number of iterations. While using this colouring scheme, further iterating

one point meant that the maximum number of iterations for the current image would

be automatically increased, forcing us to either,

• colour the point based on the current maximum iterations, meaning that the point

would always be coloured to the last available colour on the spectrum and that

all points coloured in the continuous mode would have the same colour

or alternatively,

• recolour all the points with the new maximum number of iterations, which would

require the recomputation of the colour for each point and would not be aesthet-

ically pleasing to watch all the points change colour every time a point escapes

with a higher number of iterations

Given these two options, it was decided that the best approach would be to design

a new colouring scheme that is totally independent from the maximum number of

iterations performed, further justifying the scheme presented in Section 4.1.


4.3.3 Optimising the Continuous Process

Initially, the continuous process was performing one extra iteration for each point in the

collection. Performing just one extra iteration was causing long delays in obtaining any

visible results. Clearly, the process of taking points out from the collection and placing

them back was taking its toll on performance.

The number of iterations performed at one go was arbitrarily increased from 1 to

10, and an immediate improvement was noticed at low zoom levels. At high zoom

levels, the continuous process was not responsive enough as it was still taking long to

start making adjustments to the image.

In [27], Parris observed that as you zoom in further into the fractals a higher number

of iterations is required to obtain accurate images. In fact zooming in Mandelbrot Maps

automatically increases the maximum number of iterations performed. A clear relation

exists between the problem mentioned above and the observation made by Parris. The

number of iterations imposed on each point had to be increased as the zoom factor

is increased. The zoom slider works in the range of 1 to 300, using this value as

the number of iterations to perform at each step gave successful results. After some

tweaking of the parameters, the number of iterations per step for the Mandelbrot Set

was set to:

Max(Zoom Level - 25, 5)

In the case of the Julia Set, the number of iterations required was not only depen-

dant on the zoom level of the Julia Set but also dependant on the zoom level of the

Mandelbrot Set. Thus the number of iterations per step for the Julia Set was set to:

Max(Julia Zoom Level - 25, Mandelbrot Zoom Level - 25, 5)

These values were decided upon after judging, by eye, the delay for different zoom

levels. The delay for the first 30 levels of zoom was noted to be quite low, so 5 iterations

per step. After this level, an extra iteration is performed for each additional zoom level.

4.4 Fixing the Julia Curve Location

While using the tool during development and testing, a simple usability problem was

encountered. While watching the Mandelbrot Set and the Julia Set filling in, users

could easily forget whether the Julia Set was locked (i.e. whether moving the mouse

on the Mandelbrot Set would generate a new Julia Set). In cases where the Julia Set


generation was indeed locked, users could forget which point from the Mandelbrot Set

view was chosen to parametrise the Julia Set. These situations presented the user with

a dilemma - could he/she move the mouse over the Mandelbrot Set without loosing all

the work done on the Julia Set?

For inspiration we looked at Google Maps [2], which after all was the basis for the

original design of Mandelbrot Maps. In Google Maps, users can create their own maps

and pin point locations of interest using place markers. The same markers are used by

Google Maps to pin point returned results of a particular search.

A place marker was added to Mandelbrot Maps which would act as a visual re-

minder that the Julia Set rendering has been locked while at the same time identifying

the point that is being used as the Julia Set parameter. One might argue that the place

marker alone would not fully solve the problem as the Julia Set generation might be

locked for a point that is not within the current view of the Mandelbrot Set. However,

in this situation the user can freely move the mouse without loosing any work done on

the Julia Set. Figure 4.8 shows the place marker in use on the Mandelbrot Set.

Figure 4.8: Place Marker shown on the Mandelbrot Set

4.5 Reusing Old Renderings

A drawback with using the Continuous Mode was that slight movements of the canvas

caused all the work done to be lost. Ideally work done would be stored and used

to generate rough renderings of new windows requested by the user, after which a

full rendering is performed and information about it is stored together with the other

old renderings. Storing this information would not only be useful for an optimised


move operation, and can also be used for generating rough renderings when zooms are

performed. With the information obtained from the initial picture, all points could be

coloured (although perhaps too crudely in some instances).

4.5.1 What information to store

Clearly, the amount of data to be stored for each point needs to be kept to a minimum

since a single rendering has approximately 190,000 points. Hence an array containing

just the number of iterations for each escaped point and a special value for bounded

points was used. With the number of iterations one could easily recompute the colour

of a pixel while identifying the points that required further iteration. The array of

iteration escape values required to be annotated by the area that it is representing on

the complex plane.

4.5.2 How to store the information

A data structure that could handle spatial information while allowing for quick data

retrieval was required to handle our data. One such data structure is the R-Tree [9]

which was developed in the 80’s for handling spatial data objects and their retrieval

with regards to their location. The remainder of this section outlines the anatomy of

an R-Tree and proceeds to explain how this data structure is used to store the iteration

escape value arrays.

4.5.2.1 R-Trees

Similar to the B-Tree [4], the R-Tree is a height balanced tree where all the data objects

(or pointers to data objects) are stored in the leaf nodes. The tree’s structure is designed

so that a search requires as few node visits as possible.

Nodes in an R-Tree have different properties depending on whether they are leaf-

nodes or not. Each R-Tree leaf node is made up of two components:

• An n-dimensional index record which represents the bounding box of the spatial

data object represented by the node

• The spatial data object

Each non-leaf R-Tree node is made up of two components:


• An n-dimensional index record which represents the bounding box that covers

all the bounding boxes of its child nodes

• A list of R-Tree child nodes

The R-Tree also defines a minimum (m) and a maximum (M) number of child

nodes that a node should have and m≤ M2 .

The properties of an R-Tree can be summarised as follows:

• Each leaf node contains between m and M spatial objects (unless it’s the root)

• The index record in a leaf node is the smallest rectangular area that covers all the

spatial objects

• Every non-leaf node contains between m and M child nodes (unless it’s the root)

• The index record in a non-leaf node is the smallest rectangular area that covers

all the rectangles of the child nodes

• All data appears in the leaf nodes and all leaf nodes appear at the same level

4.5.2.1.1 Inserting in an R-Tree New entries are inserted into leaf nodes and a leaf

node is chosen by traversing the tree from the root node and at each level choosing the

node whose rectangular bounding box requires the least enlargement to accommodate

the new node. If the chosen leaf node cannot accommodate a new node because it has

reached the M limit of objects, then the node is split into two new nodes with the same

parent. If the splitting operation causes the parent node to exceed M, the split operation

is propagated upwards in the tree. After a new object is inserted in an R-Tree node,

its bounding box is updated together with the bounding of all the non-leaf nodes in the

path to the root.

4.5.2.1.2 Searching in an R-Tree A search in an R-Tree is done spatially in the

sense that one looks for objects that are found within a specified search area. Searching

starts from the root comparing the bounding box of the root with the search area. If the

two areas overlap we proceed to examine the bounding box of its child nodes. If the

child node is a non-leaf node and its bounding box overlaps the search area then the

process is repeated with the child node as the root. If the child node is a leaf node and

its bounding box overlaps the search area then the overlapping data objects are added

to the search result.


4.5.2.1.3 Example Figure 4.9 shows nine numbered rectangles representing our

spatial data. The rectangles are inserted into an R-Tree (with m = 2 & M = 4) in

their numbering order, the resulting R-Tree shown in Figure 4.10. The root of the gen-

erated R-Tree has three child nodes which in turn contain all the spatial objects. The

three nodes are given a different colour used to depict the rectangular area they cover

in Figure 4.9. Running a search for any objects located in the area (-5, 9, 7, 1) repre-

senting (topLeftX, topLeftY, bottomRightX, bottomRightY), would return the objects

1, 5 & 8. This search area (and its overlapping result) is shown as a red bordered box

in Figure 4.9.

Figure 4.9: R-Tree Example: The spatial data that is inserted into the RTree (shown in

Figure 4.10) showing their grouping according to the nodes the objects are inserted in.

Also shows the search area used in the example as a red bordered box.

4.5.3 Reusing old renderings

This section describes how the iteration escape value arrays are stored in a custom

implementation of an R-Tree, and how the data is retrieved to produce a rough sketch

of an image.


Figure 4.10: R-Tree Example: The R-Tree that is generated when the spatial data show

in Figure 4.9 is inserted into it.

4.5.3.1 Creating and storing the arrays

While computing all the pixels for an image, the number of iterations related to each

point is stored in an array - iterations for escaped points are stored as positives while

iterations performed for bounded points are stored as negative. In this way we can

distinguish between the two types of points while still storing the number of iterations

a bounded point has been submitted to.

At the end of the rendering process, the array of iterations is encapsulated into an

R-Tree payload and inserted into the tree if a payload with the same bounding box does

not exist. In cases where an entry with the given bounding box already exists, then the

existing entry is updated if and only if the maximum number of iterations performed

in this rendering is higher than that for the stored array.

The continuous process has been modified slightly to update the information stored

in the R-Tree. Apart from being handed a collection of points for iteration, the continu-

ous process is also handed the R-Tree payload to be updated whenever a point escapes.

Updating one point in the payload also updates the maximum number of iterations

performed for that rendering.

4.5.3.2 Producing a rough sketch

The steps performed to produce a rough sketch for the iteration escape value arrays are

outlined below.

1. Search the R-Tree for nodes overlapping the required area

2. Sort the search result in order of increasing pixel size so that the nodes that have

a smaller pixel size (i.e. higher zoom level) are first. Arrays with the same pixel


size are sorted in order of decreasing maximum iterations performed. In this

way, the higher detailed images are processed first.

3. Create an array, representing the sketch, which will be populated by the iteration

escape values picked from the R-Tree nodes. All entries in the array are initialise

to -1.

4. For each entry in the search result:

(a) Ignore any result that has a smaller pixel size from the image being com-

puted. This step removes any complexities in deciding which pixel to

choose when more than one pixel from the deeper zoom levels can be used.

Ignoring these results also makes the generating rough sketches faster.

(b) Alternatively, use the result for generating a rough sketch. For all pixels p

in the result array,

i. If pixel p is not within the window to be generated, then ignore it

ii. If the pixel p is not escaped (i.e. is a negative number) and the cor-

responding new pixel is also marked as not escaped, then set the new

pixel to the largest negative number between the two to indicate the

number of iterations it has been submitted to. No change in colour is

required

iii. If the pixel p is escaped then

A. If the p ≤ maximum number of iterations for the rough sketch

then update the output array and set the appropriate colour

B. Else p > maximum number of iterations for the rough sketch then

set the point as not escaped and colour white

4.6 Exploiting parallelism

Generating images for the Mandelbrot Set and Julia Sets is a highly parallelisable task.

Recalling our definition of how the Mandelbrot Set and the Julia Sets are built, we

realise that rendering each point is totally independent from rendering the other points.

The result for each point can thus be computed concurrently without interfering with

the computation of other points. Problems of this kind, where the problem is made

up of a number of tasks that can be executed in an independent fashion, are referred


to as embarrassingly parallel problems as they are usually easy to adapt for parallel

computation[6].

4.6.1 Multithreading

Today’s CPU enhancements are being made in terms of number of cores rather than

processor speed, with current CPUs being shipped with two or four cores (and eight-

core CPUs are just round the corner). Having more than one core on a processor means

that independent tasks can be executed concurrently, presenting us with the opportunity

of parallelising the generation of the Mandelbrot Set and Julia Sets. By segmenting the

image generation task into subtasks, each subtask can be assigned to different threads

which execute in a concurrent fashion, speeding up the image generation process.

4.6.1.1 Multithreading Mandelbrot Maps

The original version of Mandelbrot Maps already had some level of multithreading,

however its use is centred upon usability rather than performance. One thread per frac-

tal image was created in order to handle GUI events so as not stall the GUI while doing

any image renderings. The GUI thread would create an event in a rendering queue and

the rendering thread would process the elements in this queue. This architecture was

reemployed in the new version of the tool as we wanted to keep the GUI responsive

while the images where being rendered.

Figure 4.11 depicts the flow that occurs in the new Mandelbrot Maps when a GUI

event (such as a zoom or a pan) occurs. The GUI event handler cancels all current

jobs and creates an entry in the Rendering Queue, which is picked up the Rendering

Thread. At this stage in the original version of Mandelbrot Maps the Rendering Thread

would start the rendering process. However, this was modified to allow for more than

one thread to perform the rendering.

The Rendering Thread is now responsible for decomposing the rendering task into

smaller renderings to be processed by the thread pool. Decomposition of the task

occurs through the Rendering Task Creator which dissects the rendering window into

horizontal windows depending on the number of threads available in the thread pool.

The Rendering Task Creator creates a list of Runnable objects that are submitted to

the Rendering Manager for processing. The Rendering Manager provides two ways

in which tasks can be submitted - blocking and non-blocking. Tasks are wrapped

in FutureTasks which allows us to easily cancel tasks and monitor the final status


(completed/cancelled) of the task.

Figure 4.11: Submitting a rendering process

4.6.1.1.1 Initialising the Thread Pool At start-up, the new Mandelbrot Maps de-

tects the number of cores available on the machine running the applet by using methods

available in the Runtime class. The number of CPU cores available dictates the size

of the thread pool to be created (n cores = n threads). Refer to Section 5.2.1 for results

on why this value was chosen.

4.6.1.1.2 Rendering Images As explained above the rendering window (i.e. the

area to be drawn) is segmented to give a task to each of the threads in the thread

pool. Rendering of the window used to occur in a top-down fashion, and two threads

computing two horizontal windows meant that two top-down rendering would occur -

the first from the top of the window to the midpoint of the window, and the second from

the midpoint of the window to the bottom. This rendering didn’t seem aesthetically

pleasing and it was decided to make the rendering direction dependant on the window

number the thread is processing. Using a simple mod equation, windows with (index

% 2 == 0) are processed in a bottom-up fashion, while windows with (index % 2 == 1)

are processed in a top-down fashion. With the new rendering approach, rendering with


one thread occurred in a bottom-up fashion. Rendering with two threads now occurred

from the middle of the image to the top and bottom concurrently, which was found to

be more aesthetically pleasing.

4.6.1.1.3 Continuous Mode For the Continuous Mode, the threads will take points

from the points for iteration collection, iterate the points and update the screen if they

escape or place them back in the list if they do not escape. This process explains

why the nextPointForIteration() operation (described in Section 4.3.1) requires

the implementation to remove the point from the list when it is being iterated as there

is the danger that two or more threads might be working on the same point wasting

processing cycles.

4.6.2 Distributed Parallelism

Apart from exploiting extra cores on the same machine that the applet is running on,

unused computing power on idle machines in a network could also be exploited. Com-

putations required for image generation can be farmed out to several idle computers;

the results are then collected and amalgamated together to generate the requested im-

age.

To ease the development process Java Parallel Processing Framework (JPPF), a

framework allowing the distribution of tasks over a network, was used. JPPF’s archi-

tecture defines three types of entities:

• JPPF Node - the entity that is willing to provide its processing power for the

execution of tasks

• JPPF Client - the entity requesting jobs to be performed

• JPPF Driver - the driver entity is used as a central control in the network. JPPF

nodes register with the JPPF Driver and JPPF Clients send requests for process-

ing to the JPPF Driver. The JPPF Driver acts as a farmer, distributing tasks to

the nodes and aggregating the results to be sent back to the JPPF Client

Using JPPF, tasks for iteration were defined for the Mandelbrot Set and the Julia

Set generation. A JPPF Client would submit a collection of Mandelbrot Set tasks or

Julia Set tasks to the JPPF Driver, which in turn would farm out the tasks to the JPPF

nodes and return their result to the JPPF Client.


Where would the JPPF Client be placed? Should it be placed in the applet? It was

decided not to place the JPPF Client in the applet for several reasons. Firstly, some

firewalls might block the communication taking place between the JPPF Client and

the JPPF Driver. Secondly, and more importantly, we wanted to have a solution that

would be as independent as possible from the underlying framework used. Thus, the

JPPF client was placed on the Web Server hosting the applet, and the applet would

communicate with the Web Server to request new renderings.

The first approach to this problem was to use Ajax technologies to communicate

between the web browser running the applet and the Web Server. A combination of

the LiveConnect [25] and JSObject [23] libraries were used to communicate between

the applet and the browser. Although a working solution with these two libraries was

achieved, the resulting system was not very stable and tended not to work on all plat-

forms.

An alternative solution lied in using XML-RPC [31] for the communication layer

between the applet and the Web Server. XML-RPC is a remote procedure calling

specification that uses HTTP as the transport layer and encodes data in XML. XML-

RPC gives us the advantage of doing without communicating between the browser and

the applet, and also gives control on how the connections are managed between the

applet and the Web Server (whereas with AJAX it was the browser that managed the

connections typically limiting us to two connections). Using Apache’s XML-RPC [3]

implementation, a Java implementation of the XML-RPC specification, marshalling

and unmarshalling data was not an issue as this is handled within the library (whereas

with Ajax the request objects and returned results had to be built and parsed).

Using XML-RPC the architecture shown in Figure 4.12 was implemented. The

applet would send requests to the Web Server for a particular image to be rendered. The

Web Server will accept the request and respond to the applet with a Job Id. The Web

Server will then create a collection of tasks for the given image - one per horizontal

line, and send the tasks through the JPPF Client to the JPPF Driver. The JPPF Driver

will farm out the tasks to the JPPF Nodes and return results to the JPPF Client. In the

mean time, the applet will request the Web Server to return any data for a particular

job id. If any data is present it is returned to the applet.

4.6.2.1 Problems with the Distributed Parallelism Implementation

Due to time restrictions, I was unable to completely finish the implementation for

the distributed parallelism solution. The implementation was in a stage where it was


Figure 4.12: Architecture for exploiting distributed parallelism

working, however it wasn’t very usable as it wasn’t responsive. The overheads incurred

in communication where making low zoom images take much longer than if rendered

locally. If time were available, we could have studied how to automatically trigger the

distributed parallelism after a certain threshold of workload is reached.

4.7 Improving the Deployment Environment

This section discusses some of the enhancements that were made to the overall deploy-

ment environment and aesthetics of Mandelbrot Maps.

4.7.1 Improving the deployment mechanism

In order to have a more robust solution, the Deployment Toolkit [24] provided by Sun

was used to deploy the new Mandelbrot Maps applet. The toolkit provides JavaScript

functions to facilitate applet deployment, JRE version detection and JRE installation

requests.

The toolkit was used to detect whether Java 1.6 is installed and available to the

web browser being used. If Java 1.6 is available Mandelbrot Maps is shown normally,


Figure 4.13: Screenshot of the problem that occurred on start up

however if Java 1.6 is not present we hide the Mandelbrot Maps applet and display

a message informing the user that Java 1.6 is required to run Mandelbrot Maps. The

user is given the option to install the latest version of Java, and if he/she agrees, the

installation process is started through the deployment toolkit.

4.7.2 Improving the loading process

The original Mandelbrot Maps experienced some problems on loading. At times, a

replicated image of the other controls in Mandelbrot Maps would be displayed instead

of the fractal image. Other times, a blank screen replaced the fractal images.

Two factors where causing this problem to happen. The first was a misconfigu-

ration in the way the graphical objects were created and added to the GroupLayout

Java Swing layout manager. The second factor was an unhandled exception that was

being generated by the initialisation code and the rendering module of the application.

Basically, the rendering module would attempt to start rendering an image while all

the necessary data structures were not yet initialised. Both factors causing this loading

problem were tackled and solved for the new version of Mandelbrot Maps.


4.7.3 Facebook Integration

The original Mandelbrot Maps already provided a way for sharing particular locations

with other people through the “Show Link” button. This button would display a URL

that encodes the current location in Mandelbrot Maps. In this day and age of social

networking, we decided to add the functionality of directly posting the link to the user’s

Facebook profile. To provide for this functionality a “Post on Facebook” button was

added to Mandelbrot Maps. On clicking of this button the Desktop class was used to

instruct the host operating system to load the following URL in the web browser:

http://www.facebook.com/sharer.php?u=<url of current screen>

This link will log the user into his/her Facebook profile, allowing the user to submit

the link to their profile and annotate it with any comments.

4.7.4 Facelift

Improvements to the aesthetic packaging of the tool were also carried out. Figure 4.14

shows both screenshots of the old and the new packaging for the tool. The tabs shown

in the screenshot for the new tool (Figure 4.14(b)) have the following content:

• The Tool - Contains the Mandelbrot Maps applet and the code check for the

required JRE version

• Instructions - Contains a YouTube instruction video for the applet

• Links - Contains a list of interesting screens in Mandelbrot Maps

• About Fractals - Contains a small description of what the Mandelbrot Set and

the Julia Sets are and how they are related through Tan Lei’s similarity theorem

and Fatou’s connectedness theorem

• Source Code - Contains the source code for Mandelbrot Maps

• Survey - Contains the survey that was used for the User Evaluation


(a) Original Mandelbrot Maps

(b) New Mandelbrot Maps

Figure 4.14: Screenshots of the original and the new Mandelbrot Maps

Chapter 5

Evaluation & Results

5.1 User Evaluation

Mandelbrot Maps is ultimately designed to allow easy exploration of fractals, and

who better to evaluate it than users with varying mathematical background. To obtain

feedback on the tool we designed a user survey, the results of which are discussed in

the following sections. The survey also served the purpose of obtaining data for testing

our hypothesis that the continuous mode is typically preferred over the non-continuous

mode.

5.1.1 Method

A survey was designed whereby the users were asked to indicate whether they have

understood the features offered by Mandelbrot Maps. The users were also asked to

rate the system for its ease of use, image quality, overall rating, and ease of verifying

Fatou’s connectedness theorem when in the continuous mode and when not. The users

could switch between the two modes by using a toggle button labelled “Continuous”.

When the toggle button is selected, the tool would work in continuous mode and the

detail slider is disabled.

The survey and the tool were advertised to the School of Informatics undergraduate

and MSc students, on a fractal forum web site (http://www.fractalforums.com)

and on the popular social networking site Facebook. To help the users understand how

to use the tool and what it is portraying, an instruction video was created, uploaded to

YouTube and embedded into our web application. The survey advertisement directed

the users to the home page of Mandelbrot Maps (http://inganoust.inf.ed.ac.

48

http://www.fractalforums.com



Chapter 5. Evaluation & Results 49

uk/mmaps/), where they were asked to watch the instruction video, use the tool and

then fill in the survey.

5.1.2 User Feedback

The survey ran for five days over which period 68 survey responses were collected.

The users were able to run the applet without a problem, although some reported that

they needed to update the JRE installed on their machine before doing so and found the

auto-update feature (Section 4.7.1) we included in the tool very useful. One avid Mac

user complained that he was not able to run the tool, but came back with an explanation

before we could investigate this problem - “Java 1.6 on OSX is only 64bit. Whilst this

is fine for desktop applications, no 64bit browser yet exists for OSX and so 64bit Java

Applets can’t be run.”

5.1.2.1 Respondent Base

Some general questions were asked in the survey. One of these questions asked whether

the users had used any other fractal explorers before using Mandelbrot Maps, and 29%

of the respondents had in fact used a fractal explorer.

We also asked the users to indicate how many minutes they spent using the tool. In

total all the users spent 789 minutes using Mandelbrot Maps with a mean of 11 minutes

per user. Two minutes was the minimum time users spent using Mandelbrot Maps, and

forty-five was the highest.

5.1.2.2 Features Understood

Figure 5.1 shows the responses for the features understood question. All the respon-

dents understood how to use the move and zoom functions. More than 90% understood

how to use the detail slider and 85% of the respondents understood the Continuous

mode. The least understood feature was the similarity feature with only 65% of the

respondents understanding how to use it, indicating that we might need to enhance

the similarity feature or provide a more thorough explanation of how to use this fea-

ture. The Link and Save features were understood by 75% and 85% of the respondents

respectively.

One thing to keep in mind when viewing these statistics is that the users might have

confused the question with “Which features did you use?” This statement is based on

the feedback received by one of the users - “I did not save or generate a link so I left




the selection unticked although this does not mean that I did not understand how to use

it.”

Figure 5.1: Features the respondents understood how to use

5.1.2.3 Comments

There were several positive and encouraging comments collected both through the

survey and through direct responses received over Facebook.

The list below shows a selection of positive comments received through the survey.

• Excellent job. I have seen this fractal before so I had a slight idea of what to

expect. I think that it is a useful program. Prosit!

• Objectively very good project, good implementation, well thought, etc.Good

stuff

• Very good tool to explore Mandelbrot sets and examine how the Julia Curve

relates to the Mandelbrot set. Well done!

• I like this! well done.

• Tool is great, very easy to use! Really enjoyed it, lovely colours too, very bright

and fun! :) I will use the patterns for my handmade greeting cards.


• Very interesting tool. Good job.

• Fractals are fascinating :)

• The tool looks quite simple to use if you know what you want to do with it, and

it runs pretty damn fast too.

• I could answer the questions in part 3. only after returning to the tool. I would

expect the continuous mode to be more computationally expensive, but found no

significant differences in the performance or image quality between both modes.

With that, you could consider to make the continuous mode the default, as IMO

it is easier to navigate in this mode. Overall usability is great, I wish all software

vendors had your standards. Finally, the integration with facebook to raise atten-

tion on your project and this survey is ingenious. Congratulations, I hope you

will blast the marking scale!

• Great tool! Feels very responsive and I love watching the images fill in while in

the Continuous Mode

• I wish it were possible to adjust the color scheme or maybe load a different color

map. Other than that, a very nice tool and easy to use.

• Fascinating, great work and images! well done

• Great tool! Easy to use, easy to navigate, compatible from different browsers

and very impressive with the image results

• nice job

• I like it!

• its great I really enjoyed using Mandelbrot Maps

• Well done. Very easy and fun to use. I’m not into too much theory about fractals

but certainly appreciate the usability of the tool and the quality of the images.

• Apart from all the maths and complicated stuff: It simply looks awesome!

• Really amazing work...I am also doing my MSc. dissertation on fractals, so can

truly appreciate the quality of your work... I can imagine the amount of effort

you must have put in... cheers!!


• it was fun to use

• well done, interesting! could not stop using it

• Interesting stuff although honestly I don not know anything about fractals

• Fantastic tool! Beautiful images created! Concept isn’t too simple, but the tool

is very easy to use, and really mind boggling!

• Well done for an excellent presentation which we found to be aesthetically ap-

pealing. Your theoretical explanation and method in describing a complicated

structure arising from a simple definition is very commendable.

• an excellent effort :)

• The post to facebook link is really cool :)

The list below shows a selection of comments received through other channels.

• nice work ... I’m tempted to use one of the images as a tattoo!

• Well done, tool is very usable and generated fractals are great!

• They’ve always fascinated me! Great tool!

• This is AWESOME!! I’ve seen programs like that before, but none was even

close in detail or speed. I will send my former professor the link, he will love it!

Nice work!

• I found a nice section of the Set, its my picture! (referring to the Facebook profile

picture)

• I put one on my desktop. Fractals are quite captivating :)

• Psychedelic symmetry... (while sharing a link to Mandelbrot Maps)

In the survey, we also received critical comments which we list below in order to

provide a full picture of the user responses.

• Great tool! The tool helps to convey a visual explanation of the theory behind

the fractals. One suggestion is to speak at a slower pace during the quick start

video and maybe provide a transcript of the video.


• 3.d. is a bit confusing. The windows in the app are not labelled either, so it’s

hard to tell what the Mandelbrot set and Julia curve are. Other than that, it seems

like a useful and easy to use tool.

• My 1.2 GHz Centrino wasn’t very quick in drawing the continuous mode.

• the explanation for the maths was weak. The video was longer than it needed

to be. It was not ’to the point’. I got bored trying to understand why this was

important. But the tool is cool and intriguing

This feedback shows that we have to work a bit more in providing better instructions

for using the tool and provide a better instruction video. Also, one user seemed to

have performance problems using the continuous mode. We might consider leaving

the continuous button as an option for the users to switch between modes to use the

one that gives a better performance on the given platform.

5.1.3 Rating the Continuous Mode

We hypothesised that the Continuous Mode would give the users a better experience

while exploring the Mandelbrot Set and the Julia Set. The users were asked to compare

the two modes and rate the image quality, ease of use, overall experience, and the ease

in which they could study Fatou’s connected theorem.

Below we test this hypothesis for each of the mentioned variables. When testing

hypothesis in relation to two different measurements taken from the same subjects, and

needing to show that the differences in means are statistically significant, the paired

sample t-test is often used [30]. The basic idea is quite simple, if subjects do not

recognise any additional value for the continuous mode over the manual mode the

average difference between the scores would be close to 0 and the null hypothesis

holds. On the other hand, if one of the modes was considered to be better, then the

average difference of the scores would be significantly different from 0 and the null

hypothesis is rejected.

5.1.3.1 Hypothesis Testing : Image Quality

The mean values obtained for image quality were 8.310 for the continuous mode and

8.110 for the manual mode, indicating that the image quality under continuous mode

is preferred. However, we would like to test whether this difference is statistically


significant. The one-tailed paired sample t-test was used with a 5% level of significance

(α). The formulation for our hypothesis is as follows,

α = 0.05 : level of significance

µquality,continuous : mean scores given to image quality under continuous mode

µquality,manual : mean scores given to image quality under manual mode

And we have to decide between the hypotheses

H0 : µquality,continuous = µquality,manual

Ha : µquality,continuous > µquality,manual

In other words, H0 is the hypothesis that there is no difference between the scores

for continuous mode and the manual mode in relation to the image quality, and Ha

is the alternative hypothesis that continuous mode scores are better than the manual

mode.

The observed tobs value was found to be 1.146 which was less than the critical

t0.05 = 1.668 for the one-tailed test. Therefore we could not reject H0 with 95% confi-

dence. Although the means for image quality under the continuous mode were higher,

we cannot statistically conclude that the higher means were not down to chance.

We suspect that the failure of our hypothesis that the continuous mode produces

better quality images is due to the fact that the colouring scheme is mainly responsible

for the quality of the images being produced and the colouring scheme does not change

when changing modes. Also, we suspect that the contrast provided by the white points

might make the images more appealing to look at.

5.1.3.2 Hypothesis Testing : Ease of Use

The mean values obtained for ease of use were 8.310 for the continuous mode and 7.8

10

for the manual mode, indicating that the continuous mode was found to be easier to

use. We need to test whether this difference was statistically significant. The one-

tailed paired sample t-test was used, this time with a 1% level of significance (α). The

formulation for our hypothesis is as follows,



µease,continuous : mean scores given to ease of use under continuous mode

µease,manual : mean scores given to ease of use under manual mode


H0 : µease,continuous = µease,manual

Ha : µease,continuous > µease,manual


for continuous mode and the manual mode in relation to ease of use, and Ha is the

alternative hypothesis that continuous mode scores are better than the manual mode.

The observed tobs value was found to be 3.308 which is greater than the critical

t0.01 = 2.384 for the one-tailed test. Since tobs falls in the rejection area, we can reject

with 99% confidence the null hypothesis, and we can accept Ha that the continuous

mode was found to be easier to use by the respondents.

In the manual mode, the user is required to switch between exploring the sets and

adjusting the detail slider to observe more accurate images, whereas in the continuous

mode, the user has just one task to do - explore the fractals. We believe that this reason

motivated the users to assign higher scores to the continuous mode when judging the

tools ease of use.

5.1.3.3 Hypothesis Testing : Overall Rating

The mean values obtained for the overall rating of the tool were 8.610 for the continuous

mode and 8.110 for the manual mode. The mean values indicate that the continuous mode

was rated better than the manual mode. As above, the one-tailed paired sample t-test

was used to test statistical significance of this difference with a 1% level of significance



µoverall,continuous : mean scores given as an overall rating under continuous mode

µoverall,manual : mean scores given as an overall rating under manual mode


H0 : µoverall,continuous = µoverall,manual

Ha : µoverall,continuous > µoverall,manual



for continuous mode and the manual mode with regards the overall rating of the tool,

and Ha is the alternative hypothesis that the continuous mode scores are better than the

manual mode.




mode was given a better overall rating by the respondents.

The result obtained here complements the result obtained above for the ease of use

which indicates that the continuous mode is the preferred mode by the respondents.

5.1.3.4 Hypothesis Testing : Ease in Verifying Fatou’s Connectedness Theorem

The mean values obtained for verifying Fatou’s theorem were 7.410 for the continuous

mode and 6.810 for the manual mode. The mean values indicate that the continuous mode

was rated better than the manual mode. As above, the one-tailed paired sample t-test

was used to test statistical significance of this difference with a 1% level of significance



µconnectedness,continuous : mean scores given for verifying Fatou’s theorem under

continuous mode

µconnectedness,manual : mean scores given for verifying Fatou’s theorem under

manual mode


H0 : µconnectedness,continuous = µconnectedness,manual

Ha : µconnectedness,continuous > µconnectedness,manual


for continuous mode and the manual mode with regards the overall rating of the tool,

and Ha is the alternative hypothesis that the continuous mode scores are better than the

manual mode.





mode was given a better rating by the respondents in relation to the verification of

Fatou’s connectedness theorem.

To verify Fatou’s connectedness theorem, users typically would be moving around

in the Mandelbrot Set and observing the Julia Set changing as they vary the c parameter

for the Julia Set. To verify that the Julia Set is in fact disconnected for points outside

the Mandelbrot Set while in the manual mode users will have to first lock the Julia Set

generation by clicking on the Mandelbrot Set, increase the Julia Set’s detail slider, and

then wait for the Julia Set to be re-rendered. In the continuous mode, the user simply

needs to observe the Julia Set fill in automatically. We believe that this difference in

the process of verifying Fatou’s connectedness theorem motivated the users to prefer

the continuous mode. Further more, since the manual mode is controlled by a slider,

the users could reach an upper limit for the maximum number of iterations causing the

Julia Set not to be totally filled in.

5.2 Performance Evaluation

This section presents data about the performance of the Mandelbrot Maps tool in rela-

tion to the parallelism introduced.

5.2.1 Evaluating the Multithreaded Solution

Section 4.6.1 mentioned that the thread pools for the Mandelbrot Set renderer and the

Julia Set renderer were initialised to have threads equal to the amount of cores available

on the host machine. This section explains how we arrived to such a decision.

5.2.1.1 Method

A small test application was built to evaluate the optimum number of threads to be

created in each thread pool. The test application measured the performance of image

rendering when different a number of threads were used. The application creates a

Mandelbrot Set renderer which repeatedly renders the initial view of the Mandelbrot

Set up to different maximum number of iterations. The initial screen was chosen as it

has a good mix of points which escape and points which remain bounded.

The test starts off rendering the Mandelbrot Set with the maximum number of

iterations set to 100. The maximum number of iterations is increased by 100 until a

capping defined in a configuration file is reached, rendering the Mandelbrot Set at each


step. The configuration file also defines the number of times the same test is executed

in an attempt to minimise error as much as possible, and also defines the number of

threads to be created in the thread pool for the rendering process.

5.2.1.2 Results

The tests were run on two different machines running the following dual core and

single core CPUs respectively:

• Intel Core 2 Duo E8400 @ 3.0 GHz

• Intel Pentium M (Centrino) @ 1.6 GHz

The tests were run for maximum iterations going up to 5000. Tests on the dual core

CPU machine were run for 10 times each and run with one, two, four and eight threads.

Tests on the single core machine were run for 3 times and run with one, two and four

threads.

Figure 5.2: Dual Core : Rendering Time vs. Maximum Iterations

Figure 5.2 shows a chart that plots the maximum number of iterations on the x-axis,

the rendering time on the y-axis and plots different series for using a different number

of threads for the dual core scenario. The graph shows that the runtime for the single

threaded test was much slower than the other cases. The tests for two, four and eight

threads show a similar performance with the two threaded version being marginally

slower. Figure 5.3 shows plots for different number of iterations, with the number of


Figure 5.3: Dual Core : Rendering Time vs. Number of Threads

threads on the x-axis and rendering time on the y-axis. The graph shows that there is

considerable win in all scenarios of using two threads rather than one, and a marginal

gain in using four threads. The gains seem to improve as the workload for the rendering

process becomes higher. Using eight threads will give us no performance gains for a

low number of iterations, and will hinder performance as the workload increases.

We were expecting the performance for the two thread scenario to be nearly twice

as fast than the one thread scenario. Further investigation is required to identify the

limiting factor on improved performance, this could not be done due to time con-

straints. Also, the two thread scenario was expected to be faster than the four thread

scenario. Sometimes, threads can hang or be deprived from processing power and we

suspect that this might contribute to make the four thread scenario perform better -

with a slightly higher work force these hangs are minimised.

Figures 5.4 and 5.5 show similar charts to those we have just discussed but corre-

spond to the single core scenario. The charts clearly show that using more than one

thread on a single core CPU hinders performance.

Given these results, it was decided that a good approach for initialising the thread

pool would be to create one thread per available core. In the single core situation, the

results show that using more than one thread would be detrimental. In the dual core

situation, on the other hand, we have seen that using four threads instead of two might

give a better performance however the gain seems to be low enough to justify sticking

with two threads.


Figure 5.4: Single Core : Rendering Time vs. Maximum Iterations

Figure 5.5: Single Core : Rendering Time vs. Number of Threads


5.2.2 Evaluating the Parallel Distributed Solution

Due to time restriction, I was not able to finish the parallel distributed solution. Using

the system in this mode is still buggy (although there is a working base) and still feels

unstable. Also, the current implementation does not allow for the continuous mode

to be used as the distributed computation only returns the pixel colours to minimise

network traffic. This section shows preliminary results that using idle computers in a

network is a possible solution for generating our fractals.

5.2.2.1 Method

A small test application, similar to the one defined for the multithreaded evaluation,

was built to analyse the performance of image rendering in a distributed fashion. The

application creates a Mandelbrot Set renderer which is used repeatedly to generate

images of the Mandelbrot Set with different maximum iterations.

Figure 5.6: Rendering Time vs. Maximum Iterations

5.2.2.2 Results

The study compares the performance of generating the images using a different number

of computing nodes. The tests were run for maximum iterations going up from 100

to 5000 (in steps of hundred), and were performed using 1, 2, 4 and 8 computing

nodes. Figure 5.6 shows the results obtained in the tests. The jagged nature of the

plots is immediately noted and can be attributed to the uncertainties (such as network


loads, packet loss and machine load spikes) of sending such tasks to be executed on

the network.

Another observation is the fact that the execution time for the first few hundred

iterations is very close for all the four scenarios. We suspect that with low maximum

iterations the processing time for computing the points is negligible next to the network

overheads, causing all jobs to take approximately the same time to complete.

As the number of nodes is increased, the computation time for generating an image

takes less time. Figure 5.7 depicts this notion better as we can notice a dip for nearly

all the maximum number of iteration cases. The exception for this is the 100 iterations

case, where performance for the 4 nodes and the 8 nodes scenarios are worse or match

the performance of the 1 node and 2 nodes scenarios. As explained above, we attribute

this behaviour to network overheads.

Figure 5.7: Rendering Time vs. Number of Nodes

From this evaluation, we may conclude that exploiting distributed parallelism is

possible. However, one needs to ensure that it is engaged only for operations which

will generate a significant load when compared to the network overheads incurred.

Chapter 6

Conclusion

6.1 Future Work

Although the goals we set out to fulfil have been accomplished, we believe that there

is room for improvement in terms of new features and enhancements to the system. In

this section we will discuss where we would like Mandelbrot Maps to be in the future.

6.1.1 A Distributed Solution

In the evaluation we have shown that a distributed solution for computing the points of

the Mandelbrot Set and the Julia Sets is possible. However, due to network overheads,

such a solution is not feasible for all renderings on the sets. An interesting approach

would be to have a distributed solution that would be called upon when the image to

be generated requires a specific load. Also, a good solution might take this further by

amalgamating the multi-core parallel solution and the distributed solution to get the

best of both worlds.

6.1.2 Integrating Mandelbrot Maps with Social Networking Sites

The integration with Facebook for sharing Mandelbrot Maps links has proven popular

with the survey respondents. This simple integration is just the tip of the iceberg for

what can be done. Facebook integration can be enhanced by allowing users to post

images and not just links to their profile. A similar integration is to allow users to

upload pictures to photography based social networks such as Flickr.

63

Chapter 6. Conclusion 64

6.1.3 Colouring Schemes

As one of the survey respondents commented “I wish it were possible to adjust the

color scheme or maybe load a different color map.” Generating new colouring schemes

is now a simple process, and colouring schemes can be easily swapped during the

execution of the applet. Developing other colouring schemes and allowing the user to

switch between them might be a good way of satisfying everyone’s preference, after

all beauty is in the eye of the beholder. A step further would be to allow the user to

define his/her own colouring scheme, through a colouring scheme creation widget, and

allowing the user to share that colouring scheme.

6.1.4 Other rendering techniques

During the years, variations for the rendering of the Mandelbrot Set have been de-

fined, such as the Hubbard-Douady equipotential lines method[28]. Another interest-

ing technique is the Buddhabrot [10] which plots the paths of points that escape from

the Mandelbrot Set. These techniques can be used to give different representations of

the Mandelbrot Set.

6.2 Conclusion

Mandelbrot Maps is a fractal explorer that allows the easy exploration of the Mandel-

brot Set and the associated Julia Sets in real time. The tool, available at

http://inganoust.inf.ed.ac.uk/mmaps, also allows the easy exploration of two

important theorems relating the Mandelbrot Set and the Julia Sets. Tan Lei’s Similar-

ity Theorem is explored through a simple mechanism, while Fatou’s Connectedness

Theorem can be verified through the new Continuous Mode which we have shown to

be the preferred mode through a user survey. We also implemented parallelisation en-

hancements to exploit multiple cores on the same machine and explored the possibility

of exploiting idle computers on a network. Both techniques may be successfully ap-

plied. Furthermore, the tool is developed as an open source project and is available for

anyone who wishes to adapt it further.


Appendix A

Complex coordinates and Mandelbrot

Maps Links for fractal images

The following tables list the fractal images used through out the document together

with the complex coordinate of the top left point (tl = x + yi) of the screen and a hy-

perlink which links to Mandelbrot Maps at the same location.

Figure 1.1

Type Mandelbrot Set

Complex Coordinates tl = 0.3608810381915035+0.31684620591821416i

Type Julia Set


Complex Parameter c = 0.3609759613256478+0.3167543877464017i

Mandelbrot Maps URL http://inganoust.inf.ed.ac.uk/mmaps/?grid_mandelbrot=

0.36088103819150350000,0.31684620591821416000,0.

00021069387251651528&grid_julia=0.36050164768103327000,0.

31654954567917937000,0.00101577801114544930&param_julia=0.

36097596132564780000,0.31675438774640170000&contrast_mandelbrot=

99&contrast_julia=99

65

http://inganoust.inf.ed.ac.uk/mmaps/?grid_mandelbrot=0.36088103819150350000,0.31684620591821416000,0.00021069387251651528&grid_julia=0.36050164768103327000,0.31654954567917937000,0.00101577801114544930&param_julia=0.36097596132564780000,0.31675438774640170000&contrast_mandelbrot=99&contrast_julia=99






Appendix A. Complex coordinates and Mandelbrot Maps Links for fractal images 66

Figure 1.2

Type Julia Set


Complex Parameter c = 0.3609759613256478+0.3167543877464017i


0.36088103819150350000,0.31684620591821416000,0.

00021069387251651528&grid_julia=0.36050164768103327000,0.

31654954567917937000,0.00101577801114544930&param_julia=0.



Figure 2.1

Type Mandelbrot Set

Complex Coordinates tl = −2.7105203996564224+2.291345783269053i


-2.71052039965642240000,2.29134578326905300000,5.

50376570879999800000&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-0.



Figure 2.2

Type Mandelbrot Set



-2.71052039965642240000,2.29134578326905300000,5.

50376570879999800000&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-0.


0&contrast_julia=99







http://inganoust.inf.ed.ac.uk/mmaps/?grid_mandelbrot=-2.71052039965642240000,2.29134578326905300000,5.50376570879999800000&grid_julia=-1.75000000000000000000,1.40000000000000000000,3.50000000000000000000&param_julia=-0.86820724660547580000,0.03190512386694877000&contrast_mandelbrot=99&contrast_julia=99













Figure 2.3

Type Mandelbrot Set


Type Julia Set


Complex Parameter c = −0.12315789473684213+0.7321052631578947i


-2.10000000000000000000,1.25000000000000000000,3.

00000000000000000000&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-0.



Figure 2.4

Type Mandelbrot Set


Type Julia Set




-2.10000000000000000000,1.25000000000000000000,3.

00000000000000000000&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-0.



Figure 2.5

Type Mandelbrot Set


Type Julia Set




-0.74546837281458040000,0.11304296233150149000,0.

00008028268271464967&grid_julia=-0.74546837281458040000,0.

11304296233150149000,0.00008754550324984919&param_julia=-0.






















Figure 2.6

Type Mandelbrot Set


Type Julia Set




-0.74546837281458040000,0.11304296233150149000,0.

00008028268271464967&grid_julia=-0.74574562786987330000,0.

11324431242016823000,0.00060158368343865200&param_julia=-0.



Figure 2.7

Type Mandelbrot Set



-1.90790517597532160000,0.00048138027448438500,0.

00114088554020530530&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-1.

90703570110047040000,-0.00046015052922188810&contrast_mandelbrot=


Figure 2.8

Type Mandelbrot Set



-0.24500814174980784000,0.75657905697720710000,0.

00268953528594687000&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-0.









http://inganoust.inf.ed.ac.uk/mmaps/?grid_mandelbrot=-1.90790517597532160000,0.00048138027448438500,0.00114088554020530530&grid_julia=-1.75000000000000000000,1.40000000000000000000,3.50000000000000000000&param_julia=-1.90703570110047040000,-0.00046015052922188810&contrast_mandelbrot=99&contrast_julia=99













Figure 3.2(a)

Type Mandelbrot Set


Original Tool URL http://homepages.inf.ed.ac.uk/wadler/mandelbrot-maps/mmaps.html?

grid_mandelbrot=0.32676913504245286000,0.48490211841033270000,

0.00168230418216530620&grid_julia=-1.80000000000000000000,

1.45000000000000000000,3.60000000000000000000&param_julia=0.



Figure 3.2(b)

Type Mandelbrot Set



grid_mandelbrot=0.32676913504245286000,0.48490211841033270000,

0.00168230418216530620&grid_julia=-1.80000000000000000000,

1.45000000000000000000,3.60000000000000000000&param_julia=0.



Figure 3.2(c)

Type Mandelbrot Set



grid_mandelbrot=0.32676913504245286000,0.48490211841033270000,

0.00168230418216530620&grid_julia=-1.80000000000000000000,

1.45000000000000000000,3.60000000000000000000&param_julia=0.



Figure 3.3(a)

Type Mandelbrot Set



grid_mandelbrot=-0.73871559105993330000,0.12391949532945996000,

0.00010453474311811206&grid_julia=-1.80000000000000000000,1.

45000000000000000000,3.60000000000000000000&param_julia=-0.



http://homepages.inf.ed.ac.uk/wadler/mandelbrot-maps/mmaps.html?grid_mandelbrot=0.32676913504245286000,0.48490211841033270000,0.00168230418216530620&grid_julia=-1.80000000000000000000,1.45000000000000000000,3.60000000000000000000&param_julia=0.32728976391567033000,0.48349252459032893000&contrast_mandelbrot=44&contrast_julia=99


















http://homepages.inf.ed.ac.uk/wadler/mandelbrot-maps/mmaps.html?grid_mandelbrot=-0.73871559105993330000,0.12391949532945996000,0.00010453474311811206&grid_julia=-1.80000000000000000000,1.45000000000000000000,3.60000000000000000000&param_julia=-0.73869094286787180000,0.12388428362651492000&contrast_mandelbrot=151&contrast_julia=200







Figure 3.3(b)

Type Julia Set




grid_mandelbrot=-0.73871559105993330000,0.12391949532945996000,

0.00010453474311811206&grid_julia=-1.80000000000000000000,1.

45000000000000000000,3.60000000000000000000&param_julia=-0.



Figure 4.6(a) & Figure 4.6(b)

Type Mandelbrot Set



-0.74999858034832200000,0.00824184318421624500,0.

00003754888883633623&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-0.



Figure 4.6(c) & Figure 4.6(d)

Type Mandelbrot Set

Complex Coordinates tl = −0.82224384386644840000 +

0.15532413591854694i


-0.82224384386644840000,0.15532413591854694000,0.

15808596879429980000&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-0.






















Figure 4.6(e) & Figure 4.6(f)

Type Mandelbrot Set

Complex Coordinates tl = −0.82224384386644840000 +

0.15532413591854694i


-0.29239990755745904000,1.00463844627138270000,0.

29304922733298050000&grid_julia=-1.75000000000000000000,1.

40000000000000000000,3.50000000000000000000&param_julia=-0.



Figure 4.7(a)

Type Mandelbrot Set



grid_mandelbrot=0.32676913504245286000,0.48490211841033270000,

0.00168230418216530620&grid_julia=-1.80000000000000000000,

1.45000000000000000000,3.60000000000000000000&param_julia=0.



Figure 4.7(b)

Type Mandelbrot Set



0.32676913504245286000,0.48490211841033270000,0.

00168230418216530620&grid_julia=-1.80000000000000000000,1.

45000000000000000000,3.60000000000000000000&param_julia=0.



Figure 4.7(c)

Type Mandelbrot Set



grid_mandelbrot=0.32676913504245286000,0.48490211841033270000,

0.00168230418216530620&grid_julia=-1.80000000000000000000,

1.45000000000000000000,3.60000000000000000000&param_julia=0.















http://inganoust.inf.ed.ac.uk/mmaps/?grid_mandelbrot=0.32676913504245286000,0.48490211841033270000,0.00168230418216530620&grid_julia=-1.80000000000000000000,1.45000000000000000000,3.60000000000000000000&param_julia=0.32728976391567033000,0.48349252459032893000&contrast_mandelbrot=44&contrast_julia=99













Figure 4.7(d)

Type Mandelbrot Set



0.32676913504245286000,0.48490211841033270000,0.

00168230418216530620&grid_julia=-1.80000000000000000000,1.

45000000000000000000,3.60000000000000000000&param_julia=0.



Figure 4.7(e)

Type Mandelbrot Set



grid_mandelbrot=0.32676913504245286000,0.48490211841033270000,

0.00168230418216530620&grid_julia=-1.80000000000000000000,

1.45000000000000000000,3.60000000000000000000&param_julia=0.



Figure 4.7(f)

Type Mandelbrot Set



0.32676913504245286000,0.48490211841033270000,0.

00168230418216530620&grid_julia=-1.80000000000000000000,1.

45000000000000000000,3.60000000000000000000&param_julia=0.





















Bibliography

[1] Collins english dictionary. http://www.collinslanguage.com.

[2] Google maps. http://maps.google.com.

[3] Apache. Apache xml-rpc. http://ws.apache.org/xmlrpc/.

[4] T.H. Cormen, C.E. Leiserson, R.L. Rivest, and C. Stein. Introduction to algo-

rithms, 2001.

[5] A. Douady and J.H. Hubbard. On the dynamics of polynomial-like mappings.

Ann. Sci. Ecole Norm. Sup, 18(4):287–343, 1985.

[6] I. Foster. Designing and building parallel programs: concepts and tools for

parallel software engineering. Addison-Wesley Longman Publishing Co., Inc.

Boston, MA, USA, 1995.

[7] M. Frame and B.B. Mandelbrot. Fractals, graphics, and mathematics education.

The Mathematical Association of America, 2002.

[8] J. Gleick. Chaos - Making a New Science. 1988.

[9] A. Guttman. R-trees: A dynamic index structure for spatial searching. ACM

Sigmod Record, 14(2):47–57, 1984.

[10] R. JOVANOVIC, M. TUBA, D. SIMIAN, and S.S. ROMANIA. A New Visual-

ization Algorithm for the Mandelbrot Set.

[11] Jurgen Koller. Spirals. http://www.mathematische-basteleien.de/

spiral.htm.

[12] H. Lauwerier. Fractals, Images of Chaos.

[13] Tan Lei. Local properties of the mandelbrot set m - similarities between m and

julia sets. Technical report.

73

http://www.collinslanguage.com

http://maps.google.com

http://ws.apache.org/xmlrpc/

http://www.mathematische-basteleien.de/spiral.htm

http://www.mathematische-basteleien.de/spiral.htm

Bibliography 74

[14] Brian Mahieu. Optical compliments vs pigmentary compliments. http://www.

brianmahieu.com/optical_comp.html.

[15] MathWorks. Rgb cube. http://www.mathworks.com/access/helpdesk_

r13/help/toolbox/images/color5.html.

[16] Nial Neger Michael Frame, Benoit Mandelbrot. Julia sets. http://classes.

yale.edu/fractals/MandelSet/JuliaSets/JuliaSets.html.

[17] Nial Neger Michael Frame, Benoit Mandelbrot. Julia sets. http://classes.

yale.edu/fractals/MandelSet/JuliaSets/JuliaSetDef.html.

[18] Nial Neger Michael Frame, Benoit Mandelbrot. Julia sets - dichotomy

theorem. http://classes.yale.edu/fractals/MandelSet/JuliaSets/

JuliaDichotomy.html.

[19] Nial Neger Michael Frame, Benoit Mandelbrot. The mandelbrot set - small

copies. http://classes.yale.edu/fractals/MandelSet/MandelDef/

MandelCopies/MandelCopies.html.

[20] Nial Neger Michael Frame, Benoit Mandelbrot. The mandelbrot set - small

copies. http://classes.yale.edu/fractals/MandelSet/MandelDef/

MandelConnected/MandelConnected.html.

[21] Nial Neger Michael Frame, Benoit Mandelbrot. Run away to infinity. http://

classes.yale.edu/fractals/MandelSet/JuliaSets/JSetComps2.html.

[22] Nial Neger Michael Frame, Benoit Mandelbrot. “run away to infinity”

criterion. http://classes.yale.edu/fractals/MandelSet/JuliaSets/

InfinityProof.html.

[23] Sun Microsystems. How java to javascript communication works in java plug-in.

http://java.sun.com/products/plugin/1.3/docs/jsobject.html.

[24] Sun Microsystems. Java web app deployment advice. http://java.sun.com/

javase/6/docs/technotes/guides/jweb/deployment_advice.html.

[25] Mozilla. Liveconnect. https://developer.mozilla.org/en/LiveConnect.

[26] Iain Parris. Mandelbrot maps. http://homepages.inf.ed.ac.uk/wadler/

mandelbrot-maps/mmaps.html.

http://www.brianmahieu.com/optical_comp.html

http://www.brianmahieu.com/optical_comp.html

http://www.mathworks.com/access/helpdesk_r13/help/toolbox/images/color5.html

http://www.mathworks.com/access/helpdesk_r13/help/toolbox/images/color5.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/JuliaSets.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/JuliaSets.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/JuliaSetDef.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/JuliaSetDef.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/JuliaDichotomy.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/JuliaDichotomy.html

http://classes.yale.edu/fractals/MandelSet/MandelDef/MandelCopies/MandelCopies.html

http://classes.yale.edu/fractals/MandelSet/MandelDef/MandelCopies/MandelCopies.html

http://classes.yale.edu/fractals/MandelSet/MandelDef/MandelConnected/MandelConnected.html

http://classes.yale.edu/fractals/MandelSet/MandelDef/MandelConnected/MandelConnected.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/JSetComps2.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/JSetComps2.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/InfinityProof.html

http://classes.yale.edu/fractals/MandelSet/JuliaSets/InfinityProof.html

http://java.sun.com/products/plugin/1.3/docs/jsobject.html

http://java.sun.com/javase/6/docs/technotes/guides/jweb/deployment_advice.html

http://java.sun.com/javase/6/docs/technotes/guides/jweb/deployment_advice.html

https://developer.mozilla.org/en/LiveConnect

http://homepages.inf.ed.ac.uk/wadler/mandelbrot-maps/mmaps.html

http://homepages.inf.ed.ac.uk/wadler/mandelbrot-maps/mmaps.html

Bibliography 75

[27] Iain Parris. Mandelbrot maps: Creating a real-time mandelbrot/julia fractal ex-

plorer. Technical report, 2008.

[28] H.O. Peitgen and P.H. Richter. The beauty of fractals: images of complex dynam-

ical systems. Springer, 1986.

[29] H.O. Peitgen and D. Saupe. The science of fractal images. Springer-Verlag New

York, Inc. New York, NY, USA, 1988.

[30] M.R. Spiegel, J.J. Schiller, and A. Srinivasan. Probability and statistics. Mcgraw-

hill, 2002.

[31] XML-RPC. Xml-rpc home page. http://www.xmlrpc.com/.

http://www.xmlrpc.com/

mandelbrot maps: a web application tool for exploring fractals · abstract mandelbrot maps is a...

Documents