Fractal Science Kit Overview
The Fractal Science Kit fractal generator is a Windows program that generates a fractal image from a set of properties that you can set to control the fractal generation process. Example properties include the type of fractal, the size of the image, and parameters to control orbit generation, data normalization, oversampling, embossing, smoothing, gamma correction, etc.
Some of the properties are Fractal Programs that define the fractal equation, the complex transformations applied to the fractal data, and the instructions that map the data to colors for display. You can work with a set of Built-in Programs or develop your own set of fractal programs using the interactive programming environment provided by the Fractal Science Kit fractal generator.
The Fractal Science Kit fractal generator is targeted at the following population:
- High school or college students interested in fractals
- Mathematicians interested in visualizing their craft
- Teachers and/or parents interested in stimulating young minds
- Artists/hobbyists interested in algorithmic/mathematical art
Download the 30-day evaluation copy of the Fractal Science Kit fractal generator today!
The following sections highlight the features that make the Fractal Science Kit fractal generator your best choice for exploring the world of fractals.
Multiple Fractal Types
The Fractal Science Kit fractal generator supports 3 basic Fractal Types:
To support these disparate fractal types, the Fractal Science Kit fractal generator is partitioned into 3 major components, each serviced by a different fractal generation framework. While there are many shared concepts/resources (e.g., complex transformations), the basic framework for each fractal type is quite different.
See the Fractal Image Gallery for examples of each of the fractal types.
Mandelbrot Fractals
The
Fractal Science Kit fractal generator defines Mandelbrot Fractals
via Fractal Equations.
There are over 180 built-in Fractal Equations including Mandelbrot, Mandelbar, Cubic, Lambda, Phoenix, Tetrate, Newton, Halley, Nova, Barnsley, Magnet, as well as studies in convergent fractals, polynomial fractals, root-finding method based fractals, Julia maps, fractals based on trigonometric and hyperbolic functions, and fractals based on exponential formulas. See Built-in Fractal Equations for a complete list.
See the Fractal Image Gallery for examples.
Orbital Fractals
The
Fractal Science Kit fractal generator defines Orbital Fractals
via Orbital Equations.
There are over 50 built-in Orbital Equations including Sierpinski Triangle, Sierpinski N-gons, Koch Snowflake, Apollonian Gasket, Circle Inversion fractals, Kleinian Group fractals, Dragons, Dimers, Rep-N Tiles, IFS fractals, Quadratic Attractors, Cubic Attractors, Symmetric Icons, Symmetric Attractors, Frieze Group, Wallpaper Group, Hyperbolic Attractors, and many more. Many of these fractal programs define properties that can be used to produce countless different variations. Some of the programs search for interesting parameter settings based on user defined criteria and produce unique fractals every time they are run! See Built-in Orbital Equations for a complete list.
See the Fractal Image Gallery for examples.
L-System Fractals
The
Fractal Science Kit fractal generator defines L-System Fractals
via L-System
Programs.
There are 12 built-in L-System Programs including KochSnowflake, Hilbert, SierpinskiTriangle, KochIsland, PeanoSZ, SierpinskiSquare, Dragon, and more. In addition, hundreds of these programs can be found on the Internet. L-System fractals can be run as stand-alone programs or in the context of the built-in L-System Orbit Trap.
See the Fractal Image Gallery for examples.
Orbit Trap Support
A popular
method of generating fractals is to define a set of geometric objects located on
the complex plane called Orbit Traps and during the
fractal iteration, keep statistics related to how close the orbit points come to
the Orbit Traps. Orbit Traps
provide a fertile ground for new and unusual fractals. You can combine the
built-in traps with your own Orbit Trap
instructions to produce unique fractal designs. The Fractal Science Kit fractal
generator supports
most of the common traps, including: Circle,
Cross, Epicycloid,
Flower, Hypocycloid,
Line, Oscillator,
Polygon, Rectangle,
Rose, Sectors, Shape,
Spiral, Super Ellipse,
Swirl, and more. Many unusual traps are supported as well, including:
Apollonian Gasket, Apollonius
Grid, Borromean Rings,
Circle Inversion, Circular Vine,
Elliptic Circles, Fractal
Gasket, Hyperbolic Circles,
Isogonal Polygon, Kleinian
Group, Koch Triangle,
L-System, Parabolic Circles,
Parabolic Grid, Penrose Kite, Schottky Group,
Sierpinski Triangle, Sound
Ornament, Spirolateral,
Star Polygon, Tangent Circles,
Unit Circle Group, and many more. See
Orbit Trap Types and
Built-in Orbit Traps for a
complete list.
See the Fractal Image Gallery for examples.
The Orbit Trap Properties Pages allow
you to define a list of traps and specify how to process them. You can blend the
traps together using various blending techniques (e.g., harmonic mean) or
process them separately. You can modify the trap's position/angle per iteration,
based on values of the current/previous orbit points. You can control the trap
envelope. You can transform input points prior to passing them to the trap.
These are but a few of the many different Orbit Trap options available.
Some of the orbit traps are stand-alone fractals in their own right. For
example, the Kleinian Group trap allows you to
produce Quasifuchsian, Single
Cusp, and Double Cusp,
Two-Generator Group fractals described in the book
Indra's
Pearls - The Vision of Felix Klein by David Mumford, Caroline
Series, and David Wright. The Schottky Group trap
explores the world of nesting Schottky disks and groups of
Mobius maps that form the basis for the
Two-Generator Group fractals above. Schottky Group
fractals are also described in the book
Indra's
Pearls. The
L-System trap allows you to create an orbit trap
using a set of statements that define an L-System
or Lindenmayer System.
Lindenmayer System fractals were developed in 1968 by Aristid
Lindenmayer. The Apollonian Gasket and
Circle Inversion traps produce fractals based on iteratively reflecting
sets of mutually tangent circles in other circles using a complex mapping called
inversion. Other traps (e.g.,
Isogonal Polygon, Sound Ornament,
Spirolateral, Star Polygon) can produce
beautiful mathematical art when combined with complex transformations and other
supported features.
Interactive Programming Environment
The Fractal Science Kit
fractal generator provides an interactive programming environment with
Application Windows for viewing the fractal
image, modifying the properties that define the fractal, examining the data
behind the fractal, and viewing/editing the fractal programs, macros (inline
functions/methods), and color gradients, used by the Fractal Science Kit to produce the final image.
A set of Properties Pages allow you to view/edit all the properties associated with a fractal. Properties control every aspect of the resulting fractal image and the Fractal Science Kit supports a rich set of properties for choosing colors, controlling image processing tasks (e.g., smoothing, sharpening, embossing, anti-aliasing), controlling Data Normalization (e.g., contrast stretching, histogram equalization, data scaling via a transfer function), selecting/editing the Fractal Programs (equations, data collection programs, transformations, and color controllers), and much more.
There are 12 different Program Types. While this may seem overwhelming at
first glance, be assured that each type is responsible for performing a
small, well defined task, which can be handled by the default configuration
until you choose to explore that area of the application. What's more, because
of this partitioning, there are countless opportunities for combining programs
in new and unusual ways.
The Fractal Science Kit fractal generator provides a rich framework for exploring the world of fractals. It handles the common processing steps required to generate a fractal image so that you can concentrate on the fun part; developing the fractal formulas/equations, complex transformations, and coloring schemes that define the fractal.
Programming Language Support
The
Programming Language you use to develop your
Fractal Programs, supports
a complete set of control structures including if statements,
while
loops, for loops, switch statements, inline functions/methods, arrays, and user
defined objects. The complex data type is the fundamental variable type, and
arithmetic operators and functions handle complex operands/arguments. A rich set
of built-in functions/methods are included, and you can develop your own library
of functions/methods for use throughout the application.
Each
fractal program can define a set of Program
Properties to appear on the properties pages
associated with the program. The user can interactively change the values of the
properties to control program execution. Properties
include enums, function proxies, option maps, options, option arrays, constants,
and data tables. Most of the properties result in one or more constants that
you will use in your program to control program flow. The user interacts with
the properties on the properties pages which sets the values of the constants
used by your program.
See the Fractal Programming tutorial to learn the key concepts involved in writing your own fractal programs.
Programs written using the L-System Language are also supported.
Macro Support
Macros
are the set of
Objects, Inline Functions,
Inline Methods, and #Define Statements, available to all your programs. At first, you may not need any
macros other than the built-in macros. In fact, it
is recommended that you read through the built-in macros
so you know what is available, and to get an idea how to define your own macros
when the time comes. As you begin to develop fractal programs, you will find
that you want to use a piece of code you have already written in another
program. Creating a function or method in My Macros
solves this problem. All the macros in My Macros
can be used in any of your programs. Since the functions/methods are compiled
inline and highly optimized, there is virtually no overhead for calling a macro.
Macros increase your productivity by allowing you to define blocks of code in
a central location and include that code in your fractal program simply by referencing
the macro name. Macros can define arguments that allow you to pass information
to the macro code when you call the macro. Inline functions/methods can include arguments passed by-value
or by-reference and can return a complex value or
an object. Inline functions/methods can include local variables, loops, calls to
built-in functions, calls to inline functions and methods, etc.
Rich set of Built-in Functions/Methods
A rich set of over 500 built-in functions/methods are included, and you can develop
your own library of functions/methods for use throughout the application.
Built-in functions include math functions, geometry functions, trigonometric
functions, hyperbolic functions, array functions, debug methods, random number
functions, polynomial functions, root-finding methods, color functions, gradient
functions, texture functions, (color) controller functions, transformation
access functions, orbit trap
functions, noise functions, circle functions, Mobius transformation functions,
affine transformation functions, vector functions, triangle
functions, and many more. See Built-in
Functions and Built-in Macros for
details.
Extensive Documentation
This documentation covers every aspect of the application. The
different Fractal Types are defined, and each of the different Application Windows is
discussed as are the
Properties Pages that control the fractal framework. For each of the 12
different Program Types, the documentation gives all the information necessary
to write programs of that type, including information on the program structure,
when/how the program is used
by the framework, and examples to get you started.
The Programming Language syntax is fully documented, including details on writing inline functions/methods (Macros), and examples are provided for each programming construct. The L-System Language is also described.
Information on each of the built-in functions/methods is included (see Built-in Functions and Built-in Macros).
Online Tutorials and Example Fractals
When you're ready to begin using the Fractal Science Kit fractal generator, a set of in-depth Tutorials help you learn how to generate Mandelbrot Fractals, Orbit Traps, Orbital Fractals, and L-System Fractals. In addition to covering the basic concepts, these tutorials explain how you can use complex transformations and color controllers to take control of every aspect of the fractal image processing. A Fractal Programming tutorial introduces you to the key concepts involved in writing your own fractal programs.
Finally, a downloadable collection of illustrative Fractal Examples are available to get you started quickly. Each of the examples generates a base fractal and the online description includes experiments to illustrate key concepts that you can use to produce hundreds of variations. The description also includes a gallery of images, and the fractal properties files used to generate the images so you can examine the fractal programs behind each image.
Illustrative Examples
Hundreds
of built-in equations, transformations, orbit traps, and color controllers,
allow the casual user to produce stunning fractal images while providing the
experienced fractal developer a rich set of illustrative examples on which to
build his/her own programs. The more than 40,000 lines of source code for the built-in
fractal programs and the
built-in macros (inline functions/methods) are accessible via the
Program Browser and
Macro Editor, respectively.
See Built-in Programs for a complete list.