home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / graphics / fractal_1 / !Fractal / Help / Mandelbrot < prev    next >
Text File  |  1996-10-09  |  10KB  |  266 lines
  1. Mandelbrot
  2. ==========
  3. The classic fractal, supplied here in 9 different flavours. Thanks to Joyce
  4. Haslam and Michael Rozdoba for providing the maths for the enhanced versions.
  5.  
  6. The initial zoom uses integer maths, then switches to floating point
  7. routines. The point at which the switch occurs depends on the zoom level and
  8. whether you have an FPA chip. Without an FPA, the floating point routines
  9. will unfortunately be very slow.
  10.  
  11. Level Set, Continuous Potential and Distance Estimator Methods
  12. --------------------------------------------------------------
  13. Three methods of calculating Mandelbrots are provided. The Level Set method
  14. (LSM) is the one seen in most other Mandelbrot generators. LSM creates a
  15. stepped image, resulting from plotting the number of iterations it takes
  16. before the function tends to infinity. The Continuous Potential method (CPM)
  17. is calculated in a similar way except that the colour plotted is dependant
  18. on the value of the result, resulting in a much smoother transition of
  19. colours which can look very professional.
  20.  
  21. CPM requires use of floating point and so will be slow without a maths
  22. coprocessor. You will normally need to set Limit to a value >500 to get a
  23. smooth transition, and will need to experiment with the Slope value to get a
  24. good colour mapping. You will also need to use a palette that has smooth
  25. transition of colours, such as Grey256 or Landscape2, and of course a
  26. graphics board of showing these to their best! Alternatively try the Black &
  27. White palette for an interesting Moire pattern.
  28.  
  29. CPM also looks good in 3d Mandelbrots since it gives a much smoother
  30. terrain. See the Script file MountMandy for an example. The image generated
  31. is similar to that seen in books like "The Science Of Fractal Images".
  32.  
  33. The Distance Estimator Method (DEM) enhances detection of the boundary
  34. region of the Mandelbrot set. Normally for each pixel we calculate whether
  35. that point is in (result tends to 0) or outside (result tends to infinity)
  36. of the Mandelbrot set. Since there is so much detail within the set it is
  37. easy to miss an interior point near the boundary since we are dealing with
  38. discrete values at each pixel location. The DEM overcomes this by looking
  39. either side of the current pixel in fractional amounts (ie. less than a
  40. pixel's width) to see if an interior region is present. The distance we look
  41. either side is set by the Threshold parameter - smaller values limit the
  42. search.
  43.  
  44. When using DEM on the standard Mandelbrot plot you will notice it displays
  45. extended fine filaments. If you zoom in you will find these filaments are
  46. very fine indeed, requiring a lot of zooming to obtain resolution. The
  47. benefit of DEM is that these boundary regions are where all the interesting
  48. shapes are, so using DEM allows you to see these potential locations at low
  49. magnifications.
  50.  
  51. To use DEM you need to turn off X/Y Guessing (in the Misc->Options panel)
  52. since we need to calculate the values at each pixel and cannot guess their
  53. values. It is also useful to set Min_Iter=Max_Iter so that only the boundary
  54. is plotted, and Colour=255 to display the interior in white. As you zoom in
  55. it will be necessary to increase the value of Overflow - if it is too low
  56. the boundary line becomes distorted.
  57.  
  58. DEM requires a lot more computation than the other techniques so it is
  59. slower. Also DEM requires 24*Max_Iter bytes for workspace, so be careful on
  60. high iterations. You can combine the DEM and CPM techniques.
  61.  
  62. Data Values
  63. -----------
  64. x0, y0, width and height: the co-ordinates in the real & imaginary plane.
  65.  
  66. Max Iter: the bailout value. If the value of Limit has not been reached
  67. after Max Iterations, then the calculation is stopped, assuming the interior
  68. of the set has been reached. High Max Iter values will slow down plotting
  69. but increase detail, and becomes necessary as you zoom in. DEM requires
  70. 24*Max_Iter bytes for workspace.
  71.  
  72. Min Iter: if the calculation stops prior to Min Iter then the point will not
  73. be plotted. Setting Min Iter allows exclusion of low iteration colour
  74. values. With LSM, for iterations > Min Iter, the colour is set to
  75. Iter-Min Iter to extend the colour range into higher iterations. Set
  76. Min Iter=Max Iter to only plot the interior. 
  77.  
  78. Limit: when the value of the function exceeds Limit the calculation is
  79. stopped. The default value of 4.0 is sufficient for the Level Set method and
  80. is hard wired into the integer routines. For the Continous Potential method
  81. values >500 are required to get smooth transitions between values.
  82.  
  83. Slope: used to transform the potential value when using CPM into a colour
  84. number. As you zoom in and increase Max_Iter you will need to increase the
  85. Slope - unfortunately there is no easy way to calculate the best value for
  86. you. Altering slope alters the spread of colours across the potential.
  87.  
  88. Max Colour: used in CPM mode, it sets the maximum logical colour to plot.
  89. Normally this will be 255 but higher values allow a greater range of
  90. gradients at the expense of colours wrapping around.
  91.  
  92. Threshold: a value 0-1.0, used in DEM mode. It specifies the fraction of a
  93. pixel to examine for the interior of the set. If it is too low no extra
  94. detail is shown, whilst if it is too high the filaments become too wide,
  95. resulting in lost detail. This parameter needs modifying depending on
  96. function, Max Iter, Limit, Mandelbrot or Julia_Set, which is why this
  97. parameter cannot be set automatically.
  98.  
  99. Overflow: This is the DEM equivalent to Limit. Lowering Overflow makes the
  100. point more likely to be considered as part of the interior - if too low then
  101. this estimate can get inaccurate. As you zoom in it will be necessary to
  102. increase this value in fairly large steps, eg from 1e8 to 1e9 and so on.
  103.  
  104. 3d Plotting
  105. -----------
  106. Mandelbrots and Julias can be drawn directly in 3d by turning on the 3d X/Y
  107. Plot option. Use the Linear height transform. See the 3d section of
  108. !MainHelp for details.
  109.  
  110. Menu Options
  111. ------------
  112. Julia Set: switches to the equivalent Julia set. Moving the mouse changes
  113. the Real (x) and Imaginary (y) values as shown on top of the screen. Press
  114. select to generate the fractal. The best places to choose are along the
  115. Mandelbrot boundary. After seeing the Julia image you can jump back to the
  116. Mandelbrot by using Display->Previous if you have only drawn the Julia once.
  117.  
  118. Quarternion: switches to the equivalent Quaternion map in a similar way to
  119. above. The selected x values becomes q0 and y -> q2 in the Quaternion set.
  120.  
  121. Function: 9 different Mandelbrot functions: square, cubic, quartic,
  122. Bruce Ikenaga's function, a function discovered by Ushiki called Phoenix,
  123. Quazi (a variant of square), and Inverse square, cubic and quartic.
  124.  
  125. Method: selects Continuous Potential and/or Distance Estimator methods of
  126. colouring.
  127.  
  128. Infill: provides 5 different colouring options for the interior. Colour
  129. allows the interior to be set to any of the 256 colours - enter the value
  130. 0-255 in the menu entry provided. Max. Iter uses the value of Max Iter as
  131. the colour. The other 3 generate a colour based on the last iterated value
  132. of z.
  133.  
  134. Period Checking: This is a technique that attempts to predict whether a
  135. point is in the interior of the set or not. The aim is to save calculation
  136. time at high iteration levels (>200). At low iteration levels the mechanism
  137. can slightly slow the calculations, so the option is provided to allow you
  138. to turn it off. NOTE: this option currently only refers to the floating
  139. point routines.
  140.  
  141. Accuracy
  142. --------
  143. Various levels of accuracy are used to give the fastest possible plot. The
  144. accuracy is determined by calculating delta=width/x_pixels. Assuming
  145. x_pixels=640 which it is in most modes, the following table shows the switch
  146. over points:
  147.  
  148. Delta>   Width
  149. 2.5e-4   0.16    : 16 bit fixed point
  150. 2.0e-8   1.28e-5 : 32 bit fixed point, but not if FPA fitted.
  151. 2.5e-7   1.6e-4  : 32 bit floating point if FPA fitted.
  152. 4.4e-16  3.0e-13 : 64 bit limit of accuracy.
  153. 2.2e-19  1.4e-16 : 96 bit limit of accuracy. Only used by z=z²+c routine.
  154.  
  155. In practice the 64/96 bit limits start to become apparent before those
  156. given. When nearing the maximum resolution (width<1.0e-15) turn off X/Y
  157. Guessing in the Misc->Options panel - for some reason this technique is
  158. currently interfering with the display. Also note that the x/y cordinates
  159. can only be set using 64 bit accuracy, so zooming will become imprecise at
  160. full 96-bit resolution. At maximum resolution the Mandelbrot image is 1000
  161. times the distance between the Earth and Sun, so don't complain!
  162.  
  163. Algorithms
  164. ----------
  165. For each pixel we calculate the x & y value and then iterate. For LSM The
  166. colour is the iteration number unless uu+vv>4.0, when we set the colour to 0
  167. (or as set by the Interior menu option). To speed up processing periodicity
  168. checking is employed to detect when near the interior of the image - this is
  169. where the values of u & v settle down to a set pattern.
  170.  
  171. For CPM the colour is computed as:
  172.   colour=Max_Colour-sqrt(log(uu+vv)/2^iter)*slope
  173.  
  174. For the DEM algorithm, see p198 of "Science Of Fractal Images".
  175.  
  176. Square: z=z*z+c
  177.   iter=0
  178.   u=0; v=0;
  179.   repeat
  180.     uu=u*u;
  181.     vv=v*v;
  182.     m=uu-vv+x
  183.     v=u*(v+v)+y
  184.     u=m
  185.     iter+=1
  186.   until (iter>maxiter or uu+vv>4.0)
  187.  
  188. Cubic: z=z*z*z+c
  189.   iter=0
  190.   u=0; v=0;
  191.   repeat
  192.     uu=u*u;
  193.     vv=v*v;
  194.     u=uu*u-3*u*vv+x
  195.     v=3*v*uu-vv*v+y
  196.     iter+=1
  197.   until (iter>maxiter or uu+vv>4.0)
  198.  
  199. Quartic: z=z*z*z*z+c
  200.   iter=0
  201.   u=0; v=0;
  202.   repeat
  203.     uu=u*u;
  204.     vv=v*v;
  205.     m=uu*uu+6*uu*vv+vv*vv+x
  206.     v=4*u*v*(uu-vv)+y
  207.     u=m
  208.     iter+=1
  209.   until (iter>maxiter or uu+vv>4.0)
  210.  
  211. Ikenaga:
  212.   iter=0
  213.   u=0; v=0;
  214.   repeat
  215.     uu=u*u;
  216.     vv=v*v;
  217.     m=u*(uu-3*vv+x-1)-v*y-x
  218.     v=v*(3*uu-vv+x-1)+u*y-y
  219.     u=m
  220.     iter+=1
  221.   until (iter>maxiter or uu+vv>4.0)
  222.  
  223. Phoenix:
  224.   iter=0
  225.   u=0; v=0; ux=0; uy=0
  226.   repeat
  227.     uu=u*u;
  228.     vv=v*v;
  229.     m=2*u*v+y*vx
  230.     n=uu-vv+x+y*ux
  231.     ux=u
  232.     vx=v
  233.     u=m
  234.     v=n
  235.     iter+=1
  236.   until (iter>maxiter or uu+vv>4.0)
  237.  
  238. Quazi:
  239.   iter=0
  240.   u=0; v=0;
  241.   repeat
  242.     uu=u*u;
  243.     vv=v*v;
  244.     m=uu-vv;
  245.     if (m<0) r=-m;
  246.     m=m-x;
  247.     v=u*v;
  248.     v=v+v-y;
  249.     u=r;
  250.     iter+=1
  251.   until (iter>maxiter or uu+vv>4.0)
  252.  
  253. Inverse:
  254.   r=x*x+y*y
  255.   x=x/r
  256.   y=y/r
  257.   then as per Square/Cubic/Quartic
  258.  
  259. Spider:
  260. Not really a Mandelbrot, whilst the Julia version is just a fudge, but there
  261. are many similarities. Does not use the periodicity checker and only uses a
  262. floating point algorithm. Function is:
  263.   c(0) = z(0) = pixel
  264.   z(n+1) = z(n)^2 + c(n)
  265.   c(n+1) = c(n)/2 + z(n+1)
  266.