The Datafile PD-CD 2/DATAFILE_PDCD2.iso/fractals/fractal107/fractal_10/_fractal/help/functions

Text File | 1994-01-25 | 54.6 KB | 1,304 lines

  ________________________________________________________________________
 /                                                                        \
|                   !Fractal : Fractal Function Help                       |
|                                                                          |
|                           September 1993                                 |
 \________________________________________________________________________/

Introduction
============
This help file covers the various fractal and 3d transformers available
within !Fractal and their associated parameters and menu options. Note: the
3d_Plane, 3d_View, Riemannn and Render options are not fractal functions,
but take a fractal image and perform a 3d transformation. They are described
after the fractal functions.

The algorithms where shown usually give only the core maths, omitting things
like the scaling needed to handle zooming.

Most functions have a set of variables which are accessed from the
Image->Data menu option or the Numbers tool icon. Normally the first four
variables are for controlling the zooming and image positioning.

Fractals: A Brief Overview
==========================
Typical characteristics of fractal images are:

a) They are generated by a mathematical formula which is repeated over and
over (called iteration), usually feeding the results of the previous value
into the next cycle, i.e. feedback. The formulae are usually fairly simple.

b) The resulting images are generated by plotting two of the resulting
values like an x/y graph, often using the number of cycles as the colour.

c) The images contain an infinite amount of detail. As you zoom in yet more
details unfolds.

d) Although of infinite detail, the patterns shown are usually very similar
with just minor differences.

The types of plots generated fall into 3 main categories. Functions in the
same category have the similar processing and colouring effects within
Fractal.

Pixel Plots: Imagine your screen as an x/y plot on graph paper with each
little square a single pixel colour of the screen. The function takes the
value of x/y at each pixel and performs the iterative calculation, setting
the pixel colour normally to the number of cycles taken before the result is
greater or smaller than some predefined value. Pixel plot functions
therefore plot each pixel of the screen. With Pixel plots the '3d Details'
Effects panel allows you to plot in 3d or plot directly onto a Riemann
sphere. To speed up plotting Fractal plots in several passes, guessing
intermediate values where possible.

Point Plots: These functions take an initial value of x and y and then
perform a calculation generating new values of x and y. A point is plotted
for each set of x/y values. Colour is introduced by setting the plot style
or by changing the colour after a certain number of plots - see the 'Plot
Options' Effects panel to set these optons.

Line Plots: These functions operate in the same way as Point plots except
that a line is drawn between each point. There are usually less points
plotted than point plots making the use of lines a more feasible option.

Pixel Plot functions: Julia, Lyapunov, Mandelbrot, Newton, Quaternion, Unity

Point Plot functions: Bifurcate, Henon, IFS, Martin, Popcorn

Line Plot functions: L-System

3d Plot functions: Lorenz, Pickover, Rossler. These are point or line
plotting functions that use 3 values instead of 2. You can dynamically
change the x/y/z axis whilst plotting by moving the cursor keys. Plotting is
resumed by pressing space.

Other: CellFill, Fault, Midpoint, Plasma. All except CellFill can be used as
'Landscape' generators by processing the image via one of the 3d transform
functions such as Render.

--------------------------------------------------------------------------

Bifurcate
---------
!Fractal would not be complete without bifurcation diagrams, one of the
original manifestations of chaos. They were originally discovered from a
very simple equation to describe animal populations:

    New Population = Growth Rate * Old Population * ( 1 - Old Population)

where population is a value between 0 and 1. With growth rates < 200% a
single line results, over 200% it splits (bifurcates) into 2, then 4, then
becomes chaotic. In the plot the x-axis is the growth rate, the y-axis is
the population.

Bifurcate plots points, the colours of which are set from the main Plot
Options dialogue box in the Effects menu. For best results set Initial
Colour=0 and Plot Type to 'Subtract' so that where multiple points are
plotted at the same pixel, the colour is decremented.

The data values for Bifurcate are:

Growth Rate: value at x0.
Pop. Size  : value at y0.
Rate Range : add to x0 to give growth rate at far right.
Pop. Range : add to y0 to give population at top of screen.
Init Popn. : The inital value of the population used in the equation.
Max Gen.   : Number of generations to calculate for each growth rate.
Min Gen.   : Number of generations before plotting.

The Min Gen value is used as a low filter to let the population stabilise
before plotting, whilst the Max Gen is the total number of generations to
calculate before moving onto the next growth rate.

You can zoom in to examine the chaotic patterns, which often reveal detail.
Increase Max Gen as you zoom in to see the range of population values.
!Fractal switches from fast 32 bit to full floating point calculations as
you zoom in.

There are many formulae that lead to bifurcation diagrams. There are several
to choose from the menu - the 'R' in the equation is the growth rate.
Mitchel Feigenbaum discovered that the ratios of lengths of adjacent areas
of bifurcation were always 4.6692..., a constant that is now named afer him.

--------------------------------------------------------------------------

CellFill: A Space Filling Cellular Automata
========
This function is a bona-fide flood fill algorithm based on a cellular
automata. It creates an amazing textured pattern that is beautiful in its
own right, or which may be combined with other fractals to fill in the
background eg. L-Systems. The initial fill points (live cells) can be
specified from the menu or set by the mouse. Each cell then grows randomly
in each direction until there are no adjoining unfilled cells. The strange
pattern results from using different colours depending in which direction
the new cell was filled.

An unfilled cell is one in the colour at the initial cell position. By using
mouse selection you can specify where the initial point is and thus the
colour to be filled.

The textures created can look like terrains, crumpled paper, bark, metal
foil, rock faces etc, depending on the colours and initial pattern. Try
different display palettes and the palette adjust facility. See the
MandyGold and Pop_Fill scripts for ideas. Note that the L-System fill calls
this function, so the following settings take effect there as well.

Data Items: The first 4 items specify the fill colour when converting an
empty (black) cell. The directions are relative to the cell being processed.
The Die colour specifies the value to be added to the cell that created a
new cell (-255 to 255, 0 for no change). The Draw Colour is the value to use
when using mouse selection. All colour values are physical colour numbers
(0-255) - use !EditPal to see what they look like.

Menu Items: The From submenu allows the setting of the initial fill points -
the corners or centre of the image. Alternatively Mouse Select allows you to
choose your own start points - see below. The Presets submenu leads to a
selection of preset colour values to get you going - the colours assume you
are using the Default palette.

Mouse Select: When on this allows you to specify the initial fill cells. It
may be combined with the preset cells. Press Redraw then press Select at the
points where you want to fill from - the point will be temporarily set to
the Draw Colour to show it has been selected. To end selection, press Menu,
and the shape will be drawn. To create terrains draw lines corresponding to
where you want the ridges. To create a volcano, draw a circle. If you press
Adjust then the point is drawn but does not become an active cell. This
allows you to draw barriers to enclose or alter the fill pattern.

Hints On Colouring: A good way to think of the colour schema is to imagine a
point of light coming from one side. Set this side to the brightest colour,
the opposite side to the darkest, and the two perpendicular sides to
in-between shades. For the preset colours, the light comes from top right.
Set the Draw Colour to one of the fill colours so that your outline shape
merges with the fill colour.

By setting a fill colour to the initial cell colour (eg. 0) you effectively
stop growth in that direction, which can lead to other interesting effects

Algorithm: A set of initial points are chosen as the live cells. A cell is
then chosen at random from this set and the adjacent cells inspected. If not
set (colour=initial cell colour) then the cell is coloured depending whether
it is above, below, left or right of the chosen cell. These new cells are
added to the set of live cells. The original cell is then killed, changing
its colour by the 'Die colour' value. The process is repeated until all
cells are dead.

It is possible to extend this algorithm to handle all 8 surrounding cells
rather than 4, the result being a much smoother display especially when
using shading colours. I've stuck to 4 because it is easier to choose 4
suitable colours.

My thanks to Jean Van Mourik for this algorithm.
Nb. This function works best in modes with square pixels, eg. Mode 21 or 13.

--------------------------------------------------------------------------

Fault
-----
Generates a landscape by a very simple simulation of geological faulting,
showing the result as a contour map. Each time a fault occurs, a part of the
landscape is moved up (or down). By repeating the process hundreds or
thousands of times at random locations across the image, an uneven terrain
is created. The portion of the terrain faulted is determined by the fault
type selected by Fault->Type. All but Linear are based on shapes, where the
region within the shape is faulted upwards or downwards. The position of the
fault shape is chosen at random.

For Linear faulting, a line is chosen at random across the image, then one
side is faulted downwards or upwards. The initial image is at a set level
to accomodate downward faults. Linear faults look best when plotted in 3d
rather than as a contour map.

The data parameters are:

No. Faults: the number of faults to be run before stopping. Higher numbers
produce more realistic and uneven shapes.

Shape Size: The size of the fault shape in OS units. Larger sizes tend to
produce more generalised faults but may lead to obvious boundary lines which
can look unrealistic. Smaller shapes give more uneven, bumpy landscapes.
Sizes of 1/5th the total image give a good balance between smoothness and
variety. Larger shapes will take longer to plot. Not used for Linear faults.
The size is limited by memory.

Step: The maximum height increment for each fault. The maximum height that
can result is 255 unless Fault->Wrap is turned on in which case heights wrap
around to 0. For 3d shapes such as Cone and sprites, the Step represents the
maximum height (usually the centre).

Base Level: A value 0-255. For Linear faults or when using Up/Down faulting,
this sets the initial level (128=middle). Change this value to alter the
"sea level" or bias towards low or high levels.

Seed: The random number used as a seed to generate the landscape. To
recreate a landscape, set Fault->Random off and set the seed value. This
allows the effects of different shapes, sizes and step values to be
evaluated.

From the Fault menu the following options are selectable:
Type: leads to a submenu showing the type of fault to use. The first set are
shapes, the size of which is set from the data value Shape Size, and maximum
height by Step.
  Circle    : a circle of radius Shape Size/2.
  Cone      : a conic rising evenly in height (max Step) to the centre.
  Hexagon   : a hexagon of radius Size/2.
  Octagon   : an octagon of radius Size/2.
  Octagon 3d: a 3d octagon rising in height to the centre.
  Sprites   : leads to a panel listing a sprite shape to be used as the
              fault pattern. Click on Sprite to use this feature, and click
              on the name of the sprite to use.
  Linear    : Uses linear faulting rather than by shape. When Random Step is
              on, the Step size is the maximum, rather than the actual amount.

Random: when on generates a random landscape. Turn off to recreate a
landscape using the Seed value.

Wrap: when on allows height values to wrap around from 255 to 0, otherwise
values peak at 255.

Up/Down: when on faults are made randomly upwards or downwards, otherwise
only upwards faults are made. When off, using a lot of faults will cause the
image to end up as all high, so setting this on will help to keep heights
between 0 and 255. Linear faults are always made in Up/Down mode.

Using Sprite Fault Shapes
-------------------------
Any shape can be used as the fault pattern. The colour values of the sprite
are used as the relative fault height, whilst the overall size of the sprite
is set by Shape Size as for other shapes. The supplied sprites are in the
file FaultSpr (see Misc->Resources).

You can experiment with your own shapes by dragging a sprite file onto any
of !Fractal's windows whilst Fault is selected. The sprites must be defined
in a 256 colour mode - 13 and 21 are best since the pixels are square. Each
sprite should be square in terms of OS units, but the pattern inside can be
any shape.

It is best to draw the pattern in distinct colours since the low colour
values are difficult to see. Treat each colour number as a relative height
value. At plot time the maximum colour is set to the value of Step and the
other colours are scaled accordingly. Circular patterns tend to give the
most realistic landscape effect, but feel free to experiment since strange
patterns can be produced with linear shapes. You can think of Fault as a
special type of Tiling mechanism.

Hints And Tips
--------------
Faulting with shapes works best with a thousand or more faults with a shape
size of 100-200. With 3d shapes use a higher step than normal. With Linear
faulting try 400 faults with a step value of 8. With Random Step off, each
fault is of the same size. Linear faults look better once transformed into
3d, since this removes some of the linear effect.

The resulting image looks best with the Landscape display palette. If the
image is too low you'll just see blue, so use the Palette adjust facility
(striped Tool icon) to alter the mapping until you get a mixture of sea and
land. Alternatively load your own customised palette made with !EditPal. For
instance, a palette of various shades of white, grey and light blue give a
very realistic cloud effect.

To view the landscape in 3d try 3d_View or Render using either a Log or
Linear 3d mapping (in the 3d panel). Use the 3d Scalar value to accentuate
or smooth the image. Again, select the Landscape palette. Try the Riemann
plot to create your own globe.

Try composite faults by turning off Image->Redraw->Clear. This allows
different shapes, sizes and step values to be cumulatively applied. When
creating composite images it is best to start with a large shape size,
running for several hundred faults, to generate the basic rolling terrain.
Then use a smaller fault size, increase the number of faults and step size
to give more localised variation and peakiness. The best shapes are the Cone
and Octagon 3d - for these you'll need a relatively larger size than Circle
because of the gradual rise in height. Try mixing shapes to create different
effects - eg. start off with Linear, then switch to cone to smooth the
image. Using large shape sizes can also produce interesting patterns.

Faulting by shape is a variation on tiling, and many images can be created
by using the function in this manner rather than for landscape generation.
Try colour cycling (especially with a single colour) with an image created
with a few faults and large shape size.

Scripts
-------
Use !Fractal's script facility to create images from composite faults. See
the Misc->Resources directory for sample scripts. This is a very powerful
facility which allows complex patterns to be created.

Algorithm
---------
Faulting by shape simply involves selecting a point at random and then
plotting the shape centred on that spot. The value of each shape pixel is
added to the image pixel value - if Fault->Wrap is off, then the maximum
value of 255 is set, otherwise the value wraps around.

With Linear faulting, two co-ordinates on 2 different sides are chosen at
random. One side is faulted down or up (both chosen at random). If the
height is <0 or >255 then it is wrapped inwards.

--------------------------------------------------------------------------

Hénon Maps : An implementation of Hénon's strange attractor.
----------
Two sub-functions are provided. The Original function shows a simple orbit,
whilst the SIN/COS function is a fuller implementation. They both relate to
orbits of asteroids and so on.

Henon plots points, the colours of which are set from the main Plot Options
dialogue box in the Effects menu.

The menu options are greyed when not applicable to a particular function.
The menu options are:

Original: selects the basic function. This function is infinite so you will
need to manually stop it. See Chaos by J.Gleick p.141 for full details.

SIN(a)/COS(a): selects the full function. See J.Dewdney, Sc.American, July
1987.

Random a: The value of a is chosen at random by the program when ticked.
Random b: The value of a is chosen at random by the program when ticked.

Auto Step: When on, the number of points calculated will be increased as you
zoom in, to give greater resolution, though this will take longer.

Original Algorithm:
------------------
The default value for a is 1.4 and b is 0.3. The best
results come from slightly altering these values rather than choosing random
figures.

   px=1
   py=1
   do
       z=px
       px=py+1-a*z*z
       py=b*z
       plot px,py
   until (x>1.0e10 or y>1.0e10)

SIN(a)/COS(a) Algorithm:
-----------------------
Here the main control is the data variable a. The step rate is decreased
when zooming in. Thanks to Joyce Haslam for passing on this algorithm.

   for i=-0.8 to 0.8 step 0.05
     for j=-0.8 to 0.8 step 0.05
       c=0; x=i; y=j
       repeat
         c+=1
         xx=x*COSa-(y-x*x)*SINa
         y=x*SINa+(y-x*x)*COSa
         x=xx
         plot x,y
       until (i>100 or x>1000 or y>1000)
     next
   next

--------------------------------------------------------------------------

IFS 2d: An implementation of Michael Barnsley's IFS system in 2 dimensions.
------
Up to 40 IFS transformations are stored internally, one of which is the
working IFS.

IFS plots points, the colours of which are set from the main Plot Options
dialogue box in the Effects menu.

From the IFS menu the options are:

Data: The current IFS data except for the zooming co-ordinates which are
accessed via the standard Image⇨Data⇨ menu. Click Input to enter new values,
or Re-draw to enter and re-draw the image. Click Store to store the data in
the internal file, or Restore to revert to the version held internally.
Click Copy to take a copy of the current data and create a new IFS function,
or click Delete to delete the current entry.
The data on display consists of:

Name: used to identify the IFS function, any 1-11 characters.

Number: location within the internal IFS file. Click on the arrows to access
prior or next entries.

Transformations: number of affine transforms to use (1-20). If the sum of
the probabilities is less than 1, this number is automatically increased by
1 and a null transformation is added.

Iterations: The number of iterations before stopping image generation.

The affine data is shown according to its place in the affine function, not
as a,b,c... as shown in some programs, so be careful when porting values.
The sum of the probabilties must be >=1. If not, an extra null
transformation is added. To move around the grid use !Fractal's standard
editing keys. Numbers may be entered in scientific format. Remember to click
Input or Re-draw afterwards to get the new values processed. Only the first
9 values are shown. If a function has more (such as Chaos) then use !Edit to
edit the IFS data file & reload into Fractal.

List: shows a panel listing all the internal IFS functions available. Click
over a name to make it the current one. Most of these came from Fractint, so
see there for credits.

Save: allows the internal IFS file to be saved as a text file. Saved files
can be re-loaded by dragging onto the !Fractal icon or window. Please send
in exciting new IFS functions to AFG so that we may all see them.

Algorithm
---------
The algorithm to generate each point is essentially as shown on the input
panel, ie:

  r=random number from 0 to 1
  select affine transformation whose probability sum is just less than r
  x=a*x+b*y+c
  y=d*x+e*y+f
  plot x,y

where a..f refer to the columns in the data input panel left to right.

--------------------------------------------------------------------------

Julia Set
---------
Plots the Julia set corresponding to the equivalent Mandelbrot function.
The initial zoom uses integer maths, then reverts to to a rather slower
floating point. From the menu you can switch to the equivalent Mandelbrot -
the current Real and Imaginary values are used to set the Mandelbrot x & y
value for the centre of the image. Other options are as described under
Mandelbrot.

It is usually best to select a Julia from the equivalent Mandelbrot display.
Trying to set cReal and cImaginary otherwise can be a slow process to get
reasonable results. When switching to the Quaternion set, Quaternion q0 is
set to cReal & q2 to cImaginary.

When using functions other than Square, floating point is used much sooner
so as to maintain accuracy.

Algorithm: the Julia algorithm is essentially the same as for Mandelbrot,
but with a different start point, namely:

  u=x
  v=y
  x=cReal
  y=cImaginary

--------------------------------------------------------------------------

Lorenz : The Edward Lorenz Strange Attractor.
------
This was probably the first fractal to be recognised as such, and started
the ball rolling for chaos investigation. The shape is three dimensional and
you can use !Fractal's rotation and elevation icons to control the view
position. There are three variables which may be set or randomly chosen, and
there are three colour schemes. Refer to Chaos by J.Gleick for a description
of the story behind its discovery.

The plot is infinite. You can control the speed by setting the Step Rate
factor - smaller values will slow the plot so you can trace its shape.
Notice that the plot revolves around one centre and then suddenly jumps
across to the other.  Try altering the default values of a/b/c by small
amounts and see the effect this has on the shape and when the jump occurs.

The menu options are:

Random a/b/c: Click to set/unset random selection of the variable when a
plot is started. For each variable there is an associated maximum, which can
be changed from the data panel. New variables are not chosen when zooming.
Once you have found an interesting shape, turn off random variables, and use
the 3d options to explore the shape.

Random colour: when set a random colour is chosen after every 100 plots.

Step Colour: the colour value is increased after every 100 plots.

If neither Random or Step colour is set, then the plot is made in white
using exclusive or'ing to trace the current position.

You can change the viewpoint whilst plotting by pressing the cursor keys,
and then pressing the space bar to restart. See the 3d section in the
!MainHelp file for more details. Try Step Rate=2.0e-2 for the best use of
this function - note that bigger values destroy the shape.

Algorithm
---------
  x=1; y=1; z=1;
  do forever
     dx=a*(py-px)
     dy=px*(b-pz)-py
     dz=px*py-c*pz
     px+=dx*step_rate
     py+=dy*step_rate
     pz+=dz*step_rate
     draw px,pz           where px/pz are 3d transforms of x/y/z
  enddo

--------------------------------------------------------------------------
Lyapunov
--------
This function is a development of the Verhulst equation (similar to the
Bifurcation algorithm) used to model population growth. The Lyapunov
exponent is the average of the population size over a series of iterations.
In the display the x and y axis represent different rates of growth. For
each pixel the Lyapunov exponent is calculated, using the x or y value each
iteration. Which value of x or y is chosen is set by the Sequence variable:

  xyx - means use x, then y, then x, then repeat the sequence.

The algorithm used is as follows:

  x=initial population, usually 0.5, but between 0 and 1
  for i=1 TO initial_iteration_limit
    R=x or y depending on sequence
    x=R*x*(1-x)
  next
  L=0
  for i=1 TO iteration-limit
    R=x or y depending on sequence
    x=R*x*(1-x)
    r=R*(1-x-x)
    L=L+LOG(ABS(r))
  next

The value of L is used to set the screen colour. Solid areas tend to be
those where the value of x remains stable (negative L), whereas dotted areas
tend to be chaotic ones.

The data panel lets you set the values of the iteration limits, the initial
population and the sequence of x or y values. Note that the value of x and y
(ie. R) must lie within the range 0 to 4, with the range 3 to 4 usually
providing the best values.

To change the shape of the image use different x/y sequences - use the menu
to select different preset images as a starter. To see the image at its best
you will need to experiment with different palettes, such as the Lyapunov
ones. Full 256 colours helps a lot since it is difficult to get a good
palette using the RiscOS fixed palette. Interesting 3d effects are possible.

The image takes quite a while to generate even though fast integer maths is
used throughout. From the menu you can choose between 16 and 32 bit maths.
Use the latter for better image quality with some loss of speed. You will
find that the amount of zooming is fairly limited but in general this does
not matter since detailed close ups tend to repeat the overall picture.

You can use Lyapunov with 3d and Riemann sphere plotting methods.

For more information see the article "Leaping Into Lyapunov Space" by
A.K.Dewdney in the Scientific American Sept 1991 and Fractal Report 21 which
gives a simple BBC Basic version.

--------------------------------------------------------------------------

Mandelbrot
==========
The classic fractal, supplied here in 9 different flavours. Thanks to Joyce
Haslam and Michael Rozdoba for providing the maths for the enhanced versions.

The initial zoom uses integer maths, then switches to floating point
routines. The point at which the switch occurs depends on the zoom level and
whether you have an FPA chip. Without an FPA, the floating point routines
will unfortunately be very slow.

Level Set, Continuous Potential and Distance Estimator Methods
--------------------------------------------------------------
Three methods of calculating Mandelbrots are provided. The Level Set method
(LSM) is the one seen in most other Mandelbrot generators. LSM creates a
stepped image, resulting from plotting the number of iterations it takes
before the function tends to infinity. The Continuous Potential method (CPM)
is calculated in a similar way except that the colour plotted is dependant
on the value of the result, resulting in a much smoother transition of
colours which can look very professional.

CPM requires use of floating point and so will be slow without a maths
coprocessor. You will normally need to set Limit to a value >500 to get a
smooth transition, and will need to experiment with the Slope value to get a
good colour mapping. You will also need to use a palette that has smooth
transition of colours, such as Grey256 or Landscape2, and of course a
graphics board of showing these to their best! Alternatively try the Black &
White palette for an interesting Moire pattern.

CPM also looks good in 3d Mandelbrots since it gives a much smoother
terrain. See the Script file MountMandy for an example. The image generated
is similar to that seen in books like "The Science Of Fractal Images".

The Distance Estimator Method (DEM) enhances detection of the boundary
region of the Mandelbrot set. Normally for each pixel we calculate whether
that point is in (result tends to 0) or outside (result tends to infinity)
of the Mandelbrot set. Since there is so much detail within the set it is
easy to miss an interior point near the boundary since we are dealing with
discrete values at each pixel location. The DEM overcomes this by looking
either side of the current pixel in fractional amounts (ie. less than a
pixel's width) to see if an interior region is present. The distance we look
either side is set by the Threshold parameter - smaller values limit the
search.

When using DEM on the standard Mandelbrot plot you will notice it displays
extended fine filaments. If you zoom in you will find these filaments are
very fine indeed, requiring a lot of zooming to obtain resolution. The
benefit of DEM is that these boundary regions are where all the interesting
shapes are, so using DEM allows you to see these potential locations at low
magnifications.

To use DEM you need to turn off X/Y Guessing (in the Misc->Options panel)
since we need to calculate the values at each pixel and cannot guess their
values. It is also useful to set Min_Iter=Max_Iter so that only the boundary
is plotted, and Colour=255 to display the interior in white. As you zoom in
it will be necessary to increase the value of Overflow - if it is too low
the boundary line becomes distorted.

DEM requires a lot more computation than the other techniques so it is
slower. Also DEM requires 24*Max_Iter bytes for workspace, so be careful on
high iterations. You can combine the DEM and CPM techniques.

Data Values
-----------
x0, y0, width and height: the co-ordinates in the real & imaginary plane.

Max Iter: the bailout value. If the value of Limit has not been reached
after Max Iterations, then the calculation is stopped, assuming the interior
of the set has been reached. High Max Iter values will slow down plotting
but increase detail, and becomes necessary as you zoom in. DEM requires
24*Max_Iter bytes for workspace.

Min Iter: if the calculation stops prior to Min Iter then the point will not
be plotted. Setting Min Iter allows exclusion of low iteration colour
values. With LSM, for iterations > Min Iter, the colour is set to
Iter-Min Iter to extend the colour range into higher iterations. Set
Min Iter=Max Iter to only plot the interior.

Limit: when the value of the function exceeds Limit the calculation is
stopped. The default value of 4.0 is sufficient for the Level Set method and
is hard wired into the integer routines. For the Continous Potential method
values >500 are required to get smooth transitions between values.

Slope: used to transform the potential value when using CPM into a colour
number. As you zoom in and increase Max_Iter you will need to increase the
Slope - unfortunately there is no easy way to calculate the best value for
you. Altering slope alters the spread of colours across the potential.

Max Colour: used in CPM mode, it sets the maximum logical colour to plot.
Normally this will be 255 but higher values allow a greater range of
gradients at the expense of colours wrapping around.

Threshold: a value 0-1.0, used in DEM mode. It specifies the fraction of a
pixel to examine for the interior of the set. If it is too low no extra
detail is shown, whilst if it is too high the filaments become too wide,
resulting in lost detail. This parameter needs modifying depending on
function, Max Iter, Limit, Mandelbrot or Julia_Set, which is why this
parameter cannot be set automatically.

Overflow: This is the DEM equivalent to Limit. Lowering Overflow makes the
point more likely to be considered as part of the interior - if too low then
this estimate can get inaccurate. As you zoom in it will be necessary to
increase this value in fairly large steps, eg from 1e8 to 1e9 and so on.

3d Plotting
-----------
Mandelbrots and Julias can be drawn directly in 3d by turning on the 3d X/Y
Plot option. Use the Linear height transform. See the 3d section of
!MainHelp for details.

Menu Options
------------
Julia Set: switches to the equivalent Julia set. Moving the mouse changes
the Real (x) and Imaginary (y) values as shown on top of the screen. Press
select to generate the fractal. The best places to choose are along the
Mandelbrot boundary. After seeing the Julia image you can jump back to the
Mandelbrot by using Display->Previous if you have only drawn the Julia once.

Quarternion: switches to the equivalent Quaternion map in a similar way to
above. The selected x values becomes q0 and y -> q2 in the Quaternion set.

Function: 9 different Mandelbrot functions: square, cubic, quartic,
Bruce Ikenaga's function, a function discovered by Ushiki called Phoenix,
Quazi (a variant of square), and Inverse square, cubic and quartic.

Method: selects Continuous Potential and/or Distance Estimator methods of
colouring.

Infill: provides 5 different colouring options for the interior. Colour
allows the interior to be set to any of the 256 colours - enter the value
0-255 in the menu entry provided. Max. Iter uses the value of Max Iter as
the colour. The other 3 generate a colour based on the last iterated value
of z.

Period Checking: This is a technique that attempts to predict whether a
point is in the interior of the set or not. The aim is to save calculation
time at high iteration levels (>200). At low iteration levels the mechanism
can slightly slow the calculations, so the option is provided to allow you
to turn it off. NOTE: this option currently only refers to the floating
point routines.

Accuracy
--------
Various levels of accuracy are used to give the fastest possible plot. The
accuracy is determined by calculating delta=width/x_pixels. Assuming
x_pixels=640 which it is in most modes, the following table shows the switch
over points:

Delta>   Width
2.5e-4   0.16    : 16 bit fixed point
2.0e-8   1.28e-5 : 32 bit fixed point, but not if FPA fitted.
2.5e-7   1.6e-4  : 32 bit floating point if FPA fitted.
4.4e-16  3.0e-13 : 64 bit limit of accuracy.
2.2e-19  1.4e-16 : 96 bit limit of accuracy. Only used by z=z²+c routine.

In practice the 64/96 bit limits start to become apparent before those
given. When nearing the maximum resolution (width<1.0e-15) turn off X/Y
Guessing in the Misc->Options panel - for some reason this technique is
currently interfering with the display. Also note that the x/y cordinates
can only be set using 64 bit accuracy, so zooming will become imprecise at
full 96-bit resolution. At maximum resolution the Mandelbrot image is 1000
times the distance between the Earth and Sun, so don't complain!

Algorithms
----------
For each pixel we calculate the x & y value and then iterate. For LSM The
colour is the iteration number unless uu+vv>4.0, when we set the colour to 0
(or as set by the Interior menu option). To speed up processing periodicity
checking is employed to detect when near the interior of the image - this is
where the values of u & v settle down to a set pattern.

For CPM the colour is computed as:
  colour=Max_Colour-sqrt(log(uu+vv)/2^iter)*slope

For the DEM algorithm, see p198 of "Science Of Fractal Images".

Square: z=z*z+c
  iter=0
  u=0; v=0;
  repeat
    uu=u*u;
    vv=v*v;
    m=uu-vv+x
    v=u*(v+v)+y
    u=m
    iter+=1
  until (iter>maxiter or uu+vv>4.0)

Cubic: z=z*z*z+c
  iter=0
  u=0; v=0;
  repeat
    uu=u*u;
    vv=v*v;
    u=uu*u-3*u*vv+x
    v=3*v*uu-vv*v+y
    iter+=1
  until (iter>maxiter or uu+vv>4.0)

Quartic: z=z*z*z*z+c
  iter=0
  u=0; v=0;
  repeat
    uu=u*u;
    vv=v*v;
    m=uu*uu+6*uu*vv+vv*vv+x
    v=4*u*v*(uu-vv)+y
    u=m
    iter+=1
  until (iter>maxiter or uu+vv>4.0)

Ikenaga:
  iter=0
  u=0; v=0;
  repeat
    uu=u*u;
    vv=v*v;
    m=u*(uu-3*vv+x-1)-v*y-x
    v=v*(3*uu-vv+x-1)+u*y-y
    u=m
    iter+=1
  until (iter>maxiter or uu+vv>4.0)

Phoenix:
  iter=0
  u=0; v=0; ux=0; uy=0
  repeat
    uu=u*u;
    vv=v*v;
    m=2*u*v+y*vx
    n=uu-vv+x+y*ux
    ux=u
    vx=v
    u=m
    v=n
    iter+=1
  until (iter>maxiter or uu+vv>4.0)

Quazi:
  iter=0
  u=0; v=0;
  repeat
    uu=u*u;
    vv=v*v;
    m=uu-vv;
    if (m<0) r=-m;
    m=m-x;
    v=u*v;
    v=v+v-y;
    u=r;
    iter+=1
  until (iter>maxiter or uu+vv>4.0)

Inverse:
  r=x*x+y*y
  x=x/r
  y=y/r
  then as per Square/Cubic/Quartic

--------------------------------------------------------------------------

Martin Map: uses the algorithm of Dr. Martin.
----------
Change the values of a, b or c to get different patterns. The zoom option
does not give more detail, but allows the size and position of the image to
be changed. The routine is infinite, so you will need to select Stop to end
the plot.

Martin plots points, the colours of which are set from the main Plot Options
dialogue box in the Effects menu. Choose Random plotting for best effects.

From the menu you can select whether a, b or c are set randomly. Due to the
way the algorithm works it is not possible to guess the size or position of
the resulting image. New variables are not chosen when zooming.

For each variable there is an associated maximum for the random number,
which can be changed from the data panel.

Algorithm:
   xx=py-sign(px)*sqrt(abs(b*px-c))
   py=a-px
   px=xx
   plotpoint(px,py)
where px,py start off at 0.

--------------------------------------------------------------------------
Midpoint
--------
The midpoint displacement algorithm is one of the simplest used to generate
fractal landscapes. Start with a square and randomly choose the heights of
each corner. Divide this square into smaller ones and set the height of each
unplotted corner to the average height of the surrounding points, +/- a
random displacement. This process is repeated until we reach a unit
square. As we proceed the maximum displacement is reduced proportionately.

Starting with just 4 random points produces a smooth rolling landscape. To
get a more varied landscape more of the squares are plotted with random
heights prior to performing the midpoint displacement. For more information
see The Science Of Fractals, especially p96.

Menu Options
------------
Random: when on a different landscape is plotted. Set to off to allow
re-generation of a landscape with changes in the data variables.

There are 5 data variables that can be used to control the process.

Roughness: Increase to generate more random seed points, giving more hills
and depressions. A value of 0 plots just the initial outer 4 points (1
square), 1 plots 4 squares, 2 plots 16 squares and so on.

Height: Specifies the initial maximum displacement as a power of 2. Thus 8
(the default) means 256. Increase this value to give steeper gradients.

Seed: The initial random value use to generate the landscape. A new seed is
chosen every time unless Random is set off.

Sea Level: An height less than the sea level will be plotted in blue. This
is useful when creating the source images for a Riemann globe.

Sea Colour: The physical colour number used for the sea. Blues are 128-131
and 136-139, but any colour may be chosen.

Notes On Usage
--------------
This algorithm works best in modes with square pixels, ie. modes 21, 13 etc.
Mode 15 will tend to produce more oblong shapes.

Try colour cycling for a psychedelic effect. The landscape palettes give
more realistic results - use Palette shifting to get a sea/land balance.

To generate a landscape use one of the 3d viewing functions within !Fractal.
The 3d palette should be set to Linear for the best effects, though
experiment. Try a Riemann sphere for a planet effect - this works best when
the sea level is set above 0 or when using a landscape palette.

Midpoint does not multi-task since it is pretty fast.

--------------------------------------------------------------------------

Newton
------
This function calculates the cube root of -1 ie. z*z*z-1=0, using the
Newton-Raphson method. There are three possible roots which are: z=1,
z=-0.5+0.8666i, z=-0.5-0.866i. Floating point arithmetic is required so
don't expect it to zip along. Initially 32 bit accuracy is used which is
reasonably fast, then it switches to 64 bit. The menu options are:

Plot Root: in this mode, the colour is chosen depending on which root we are
converging to. This is the quickest option, but not very spectacular.

Plot Iters: in this mode the colour is set from the number of iterations
required to reach the root. This produces Mandelbrot type displays of
infinite complexity, but it can take a lot of time.

There are 2 data variables:

Max Iter : iteration limit, mainly of use when using Plot Iters and zooming
in.

e : The accuracy check value. The iteration is stopped when a root is found
that solves the equation to within the 'e' accuracy value. Higher values of
'e' force greater accuracy and more iterations to be used, useful when
zooming in.

A 3d version can be drawn directly by turning on the 3d X/Y Plot option.
See the 3d section of !MainHelp for details.

--------------------------------------------------------------------------
Pickover - A Strange Attractor developed by Clifford Pickover
--------
This is a 3 dimensional shape controlled by 4 variables. To get a feeling of
the shape you really need to try the 3d viewing options of !Fractal - use
the Rotate & Elevate icons to set your viewing position or better still use
the cursor keys whilst plotting. The plot is infinite and is made with
points rather than lines to avoid too much clutter.

The menu options are:

Random a/b/c/d: Click to set/unset random selection of the variable when a
plot is started. For each variable there is an associated maximum, which can
be changed from the data panel. New variables are not chosen when zooming.
Once you have found an interesting shape, turn off random variables, and use
the 3d options to explore the shape from different view points. The default
variables were obtained in this way.

Random colour: when set a random colour is chosen after every 100 plots.

Step Colour: the colour value is increased after every 100 plots.

If neither Random or Step colour is set, then the plot is made in white
using exclusive or'ing to trace the current position.

You can change the viewpoint whilst plotting by pressing the cursor keys,
and then pressing the space bar to restart. See the 3d section in the
!MainHelp file for more details.

Algorithm
---------
    x=1; y=1; z=1;
    do
      xnew = sin(a*y) - z*cos(b*x)
      ynew = z*sin(c*x) - cos(d*y)
      znew = sin(x)
      plot px,pz                    where px/pz are 3d transform of x/y/z
    forever

--------------------------------------------------------------------------
Plasma
------
This function has been ported from Fractint. It is a variant on the midpoint
displacement technique - ie. set the colour of each corner randomly, then
set each corner of each interior rectangle to a value based on the
surrounding corners plus a random variant (the graininess value, the amount
of which you can change). The display looks wonderful when cycled but this
needs a full 256 colour programmable palette. You can improve the display
significantly by using !EditPal to design a suitable palette.

Alternatively try the Landscape palette and one of the 3d transforms. Due to
the recursive nature of the function it stops if you press Adjust (no
background plotting).

--------------------------------------------------------------------------
Popcorn
-------
An algorithm developed by Clifford Pickover featured in Scientific American
July 1989, then in Fractint (where the name Popcorn was given), and
contributed here by Joyce Haslam. There are 9 different equations used with
an option to plot the pattern in a wave like form or a pixel by pixel form
(Julia).

The equation is selected from the Popcorn->Types menu. Click on
Popcorn->Julia to activate the pixel mode plot. The Julia is slow due to the
repeated use of SIN and TAN, so use small values for limit and threshold to
speed things up.

Popcorn in non-Julia mode plots points, the colours of which are set from
the main Plot Options dialogue box in the Effects menu. For best resuls
choose Random but other interesting effects can be used. In Julia mode the
colour is set from the number of iterations.

The data items after the standard x/y width/height are:

Limit: for Julia the iteration limit, otherwise the iteration limit sets the
length of each arm plotted.

Step Rate: controls the effect each iteration has on previous values. Higher
values produce more exaggerated plots.

Detail: for the non-Julia plots - 0 gives maximum detail, higher values
give rougher images which allows quicker examination.

Threshold: for Julia, the escape value. Higher values take longer to
calculate but produce more detail.

n: The multiplier in the SIN and TAN equations. Try different values to see
the effect.

A 3d version of the Julia image can be drawn directly by turning on the
3d X/Y Plot option. See the 3d section of !MainHelp for details.

Algorithms
----------
The nine equations are as shown in the Popcorn->Types menu. They are
implemented in code as shown in the 2 examples below:

Julia: for each pixel set the x and y value then :
  repeat
    sqsum=x*x+y*y
    if sqsum < threshold
       xx=x-dt*sin(y+tan(n*y))           where dt=step rate
       y=y-dt*sin(x+tan(n*x))
       x=xx
       iter=iter+1
  until sqsum>=threshold or iter=limit
  colour=iter

non-Julia: for each nth x/y pixel where the value of n is increased with the
value of "detail".

  repeat
     xx=x-dt*sin(y+tan(n*y))             where dt=step rate
     y=y-dt*sin(x+tan(n*x))
     x=xx
     iter=iter+1
     plot x*scalar,y*scalar
  until iter=limit

--------------------------------------------------------------------------
Quaternion : Invented by William Hamilton, 1843
----------
A Quaternion is a 4d equivalent of a complex number, written as:
     Q = a+bi+cj+dk
where i, j and k are imaginary numbers. They are used here in a similar way
to Julia sets with Q -> Q²+q where q is a quaternion constant, made up of
q0, q1, q2 and q3 in this routine. The routine maps out a 2-dimensional
slice using x=a and y=c, with the values of b and d being set to choose
which slice of the 4d plane we are drawing.

The initial values chosen for q0 and q2 are the same as those for the Julia
Set, and you will note the image is superficially very similar. Changing q1,
q3, b or d however allows different planes to be examined, giving a great
area to investigate.

As with the Julia set, the best way to choose values for q0 and q2 is from
the Mandelbrot set - use the Quaternion menu option to pick a point from
near the boundary.

The menu options operate in the same way as for the Julia set.

Algorithm
---------
A 32 bit and floating point version are provided, but both will be slower
than Julia's due to the extra multiplications.

For each pixel we calculate the a (x) & c (y) value and then iterate. The
colour is the iteration number unless Q²>4.0, when we set the colour to 0
(or as set by the Interior menu option).

   iter=0;
   repeat
     iter + 1
     if (a²+b²+c²+d²>4) then escape
     new_a=a²-b²-c²-d²+q0
     b=2*a*b+q1
     c=2*a*c+q2
     d=2*a*d+q3
     a=new_a
   until iter>=max_iter

Notes: It is possible to use other functions such as Q->Q³+q as done for
Mandelbrot's. Also it is possible to produce a 3d mapping, though a lot of
the swirling detail apparently is lost. Iterating the function Mandelbrot
style gives a variation on the Mandelbrot shape.

--------------------------------------------------------------------------
Rossler : The Otto Rossler Strange Attractor.
-------
This strange attractor is similar to the Lorenz with a very distinctive
shape. The shape is three dimensional which looks like a treble cleff from
some angles. You can use !Fractal's Rotation and Elevation icons to control
the view position to explore the shape. There are three variables which may
be set or randomly chosen, and there are three colour schemes.

The plot is infinite. You can control the speed by setting the Step Rate
factor - smaller values will slow the plot so you can trace its shape.
Notice that the plot revolves around a point then leaps off in a strange
loop. Try altering the default values of a/b/c by small amounts and see the
effect this has on the shape and when the jump occurs. Alternatively try
using one or more random variables to see what shapes you can arrive at.

The menu options are:

Random a/b/c: Click to set/unset random selection of the variable when a
plot is started. For each variable there is an associated maximum, which can
be changed from the data panel. New variables are not chosen when zooming.
Once you have found an interesting shape, turn off random variables, and use
the 3d options to explore the shape from different view points.

Random colour: when set a random colour is chosen after every 100 plots.

Step Colour: the colour value is increased after every 100 plots.

If neither Random or Step colour is set, then the plot is made in white
using exclusive or'ing to trace the current position.

You can change the viewpoint whilst plotting by pressing the cursor keys,
and then pressing the space bar to restart. See the 3d section in the
!MainHelp file.

Algorithm
---------
    x=1; y=1; z=1;
    do
       new x=x-y*dt-z*dt            dt=step rate
       new y=y+x*dt+a*y*dt
       new z=z+b*dt+x*z*dt-c*z*dt
       draw px,pz                   px/pz are 3d transform of x/y/z
    forever

--------------------------------------------------------------------------
Unity
=====
This transformation was developed by Mark Peterson of Fractint and is a
simple "Newton" style algorithm, which is:

   One=x*x+y*y;  y=(2-One)*x;  x=(2-One)*y;

which is iterated for each screen pixel until 1-One=0 within the accuracy of
plotting. The colour is the number of iterations (+32 to avoid dark
colours). The plot looks very similar to a Henon map, with thin lines that
get thinner when you zoom in.

Unity uses integer arithmetic and thus soon hits a zoom limit.

--------------------------------------------------------------------------

3d Transforms
=============
These take a fractal image and transform it. The best images are those of
Mandelbrots using a standard or inverted palette (but feel free to
experiment). Except for Riemann, they do not multitask since they are quite
quick. They offer varying degrees of control.

There is a common menu option which allows you to re-display the source
image, and then store it again as the 3d source. This allows you to do three
things:

a) change the colours of the original image, by using the Effects->Palette
menu. For Render and 3d views this will change the displayed height.

b) Rotate the source image via the tools rotate icon.

c) Use a 3d image as the source of another (or same) 3d transform.

3d View and Riemann provide rotation directly - for the others use the
Rotate rotate tool icon.

Return to function: This menu option takes you directly back to the original
function, displaying the source image to allow zooming to re-commence.

Height Mapping
--------------
The 3d_Plane, 3d_View and Render functions use the pixel colour to determine
the height. Use the Effects->3d Details panel to control this mapping
process, described in the !MainHelp file. When these functions are selected
the min and max pixel colours are automatically calculated. Override these
values to smooth out peaks or clip the image. To reset the values use the
Initial button on the Image->Data panel.

3d Plane
--------
Presents an oblique view of an image, scaled to fit onto the screen. The
height is based on the source colour (0=low, 255=high). The data variables
are:

x Scalar: a value of 1 plots the x axis full size. Use smaller values to
accomodate the shift incurred by the viewing angle.

y Scalar: a value of 1 plots the y axis full size, but 0.6 provides a more
realistic image.

The rotation angle is used as the angle of the y axis, with 90° being the
far right and -90° the far left. Larger angles will tend to lower the
viewpoint and see more to the left or right. You can use the Rotation tool
icon  but note that the viewpoint angle is only an indication of the
apparent direction.

3d View
-------
This offers a more realistic 3d image than 3d Plane, and provides two
viewing options - either full rotation or a front end view with perspective
control. The data parameters are:

Distance: when Rotation=0 this parameter controls the vanishing point. A
value of 1 gives the maximum distortion, whilst larger values give more
subtle effects.

Sea Level: colours below sea level are plotted up to the sea level height
but in their original colour, thus smoothing out low values. Useful with the
Landscape palette (set Sea Level=119).

From the 3D_View menu you can set Smooth: when off contour lines are
accentuated, which works well with Mandelbrot images. When on contour lines
run into each other, which works best with landscapes such as Midpoint and
Fault functions.

Render
------
Draws a 3d representation as seen full on, using the colour as the height. A
light source is assumed from the bottom left corner and is used to add a
shadow effect. The shadow effect works best with the default palette.

From Render's menu you can select the elevation viewpoint, or you can use
the Elevation tool icon to control this. Note that only 4 angles are
available.

Riemann
-------
Takes the image and maps it onto a sphere, using a Riemann transformation.
Imagine a sphere placed on top of the image. Draw a line from each point on
the image to the north pole. A point is plotted where this line intersects
the sphere. Thus the centre of the image is mapped onto the south pole
whilst a point can can only be mapped onto the north pole if it is at
infinity. See the article in Fractal Report 16 by Roger Castle-Smith for a
full explanation.

There are two ways to use this function. For the best results turn on
Riemann Plot in the 3d Effects panel which will directly generate a Riemann
sphere for X/Y functions (Lyapunov, Julia, Mandelbrot, Newton, Unity etc).
This method allows all the values to be calculated out to infinity at the
north pole.

The alternative method is to draw the image and then select Riemann. The
image will be transformed onto the Riemann sphere, but obviously values near
the north pole can not be calculated. To overcome this limitation it is
possible to scale up the image size, though this will lead to some
distortion of the image.

The data values are :

Image Scale: the source image size in relation to the sphere size. Larger
values will mean that the source image is stretched up towards the north
pole. Not used when doing a direct Riemann plot.

Globe Scale: the globe size as a fraction of the total image size (0 - 1.0).
Thus 0.5 produces a globe half the total image size. Smaller values help
reduce the distortion introduced by the mapping process when using an image
as the source.

Fill Colour: The colour used to fill in black pixels. Use !Editpal to choose
a colour number for the palette you have selected.

----------------------------------------------------------------