ArtMatic 2 in 1 out components

//----------------------------//

Introduction

Math tools #

S:P Maths #

Ax+By+C

Interpolate

Multiply (x+A)*(y+B)

Distance

Distance squared

Line

Gaussian Dot

Profile Shapes #

DF Curves #

Elevation Shapes #

Distance*(x + y)

Radial

Min <-> Max

Logic tools #

S:P Logic and Profiles #

Grid

Hexagons

Grids #

Orbit analyzer

Sines #

Circles

Random Cones

Star Field

Ripples #

Facet

Random Squares

DF Patterns #

DF Waves #

Tech Noise #

Pyramids #

Circuitry

ZigZag

Maze

Smooth Entrelas

Lightning

Dynamo

Zebra noise

Fractal Lines

Pict/Movie SymTiled

Blurred Pict/Movie

Pict/Movie

Random noise

Low Freq noise

Perlin noise

Multi Perlin noise

Bump noise

Fractal noise

MultiFractal noise

Ridged fractal noises #

Fractal Terrains #

Fractal noises #

Eroded Fractal

Sparse fractal rocks

Stone Clusters

Lunar rocks

Bubble rocks

Stratified rocks

Ridged noise

Bubble and Skins #

Cellular

Craters

Volcanoes

21 Compiled tree

21 components can hold any 2D functions of the form F(x,y). They are often used to mix the output of two separate components (or branches) or to provide a surface (terrain), a texture (patterns) or an alpha channel value (mask). Several components are creating DF 2D profiles and patterns for **Building 3D Objects : DFRM guide**.
Most of the 21 components are 2D scalar functions but some can accommodate vector inputs like S:P Maths #

. In general we use X and Y capital case to refer to vector values and x y lower case to refer to scalar values.

An essential in-depth discussion of ArtMatic structures Trees and components is found in **ArtMatic Designer References** and in **Building trees**.

**Frequency Options**

Most noises and fractal surfaces generator have a Frequency options pop up that sets how the frequency parameter is interpreted. In general these functions are "adaptive" in term of frequency content as discussed in "Adaptive, Band-Limited Noise Functions"

- use direct frequency :

Frequency parameter used directly - use Voyager km :

Frequency is scaled so that 1 corresponds to 1 km in ArtMatic Voyager space. - use 1/frequency :

Frequency inverse (1/freq) is taken as the effective frequency. - Voyager DF mode :

Amplitude is linked with frequency : In this mode amplitude is scaled by 1/freq. Starting ArtMatic 8.0 engine the amplitude is set internally so that realistic results are obtained with an amplitude close to 1. "realistic results" basically means that if the mountain is 10 km wide its height will go up to 2000 meters but not much more. An amplitude of 1 is a correct DF ratio for use in DF modeling in most cases.

Fractal based noises functions have adaptive resolution and are band-limited to reduce high-frequency noise. They are recommended for use with ArtMatic Voyager. The number of iterations and resolution are determined by the zoom level and the fractal iterations preference. By being adaptive, the functions can deliver maximum detail at any zoom level but won't generate higher frequencies when the frequencies gets above pixel size to minimize aliasing.

NOTE: With very high zoom levels, you may need to increase the Maximum Iterations for Fractals setting in the Preferences dialog.

**parameters : **

Algorithm dependent

**discussion : **

Math tools # provides a large number of mathematical functions of 2 variables. This component performs the mathematical operation determined by chosen algorithm. Some of these functions have equivalent components with more parameters. The Math tools implementation of such functions may be faster and should be used where speed is important. Note that the operations assumes scalar inputs : if you connect RGBA streams, the Alpha is going to be taken as the scalar input but the output will stay scaler. To process RGBA streams and output a RGBA stream use S:P Maths # instead.

**x-y :**

Direct x minus y, no parameters.**y-x :**

Direct y minus x, no parameters.**mul :**

Direct x*y, no parameters.**positive mul:**

Direct x*y clamped to zero : MAX(x*y,0). no parameters.**div x/y :**

Returns x/y. To divide the DF field value of a RGBA stream use 'S:P Maths # : DF divide' instead as Maths tools now always outputs scalar value.**(ADD LINK Here).**

This is useful for trees and fractals, particularly when using recursive 22 CT with 4D spaces and RGBA data as discussed below. Remember the w component of the S-Space is holding the scaling information. Warning : this generates infinity when y is zero.**div y/x :**

returns y/x. Warning : this generates infinity when x is zero.**power x^y :**

Returns x to power y**x *sign(y) :**

Returns x multiplied by sign of y. That is x turns to -x whenever y becomes negative.**atan(y/x) :**

Angle of x,y with OX in -0.5Π + 0.5Π**atan(x/y) :**

Angle of x,y with OY in -0.5Π + 0.5Π**angle(x y) (O-2Pi) :**

**dist(x y) :**Euclidian distance : square root of x squared + y squared.

atan(y/x) but scales the result to go from O-2Π**1/dist :**

Inverse of euclidian distance, goes to infinity at zero.**0.5/(dist+1/16) :**

**blend y on low :**A procedural blend that blends y with x when x is low.

Inverse of euclidian distance but scaled so that it ranges 0-8.**blend y on high :**

A procedural blend that blends y with x when x is high.**blend x*y on low :**

A procedural blend that blends x*y with x when x is low.**blend x*y on high :**

A procedural blend that blends x*y with x when x is high.**morph log(e^x + e^y) :**

This is a morphing algorithm. Its equation is: log(exp(x) + exp(y)). The result is a smooth blending of two functions when their values are close but works like a maximum function when the values are far apart.**min(4-abs(x) 4-abs(y)) :**

A function that creates a square based (4*4) pyramid whose sides vanish to infinity.**roofed min(4-abs(x) 4-abs(y)) :**

A function that creates a plateau with a square based (4*4) pyramid base. This is a useful function for placing a particular element (such as a tree or a road) in ArtMatic Voyager.**0.5*x*log(x)/y :**

**min :**

A straight MIN function without parameters and smoothing that computes faster than the minmax component.**max :**

A straight MAX function without parameters and smoothing that computes faster than the minmax component.**max+x :**

Algorithm MAX(x,y)+x**max-x :**

Algorithm MAX(x,y)-x**max-y :**

Algorithm MAX(x,y)-y**min+x :**

Algorithm MIN(x,y)+x**min+y :**

Algorithm MIN(x,y)+y**iteration smooth max :**

provide a smoothed max where the smoothing gets smaller when iterated towards higher frequencies.Unlike the normal maximum algorithm, smooth max adjusts the smoothing to the iteration level of compiled trees in order to avoid small scale elements being smoothed too much. This is often used in recursive compiled trees used to generate trees and vegetation for ArtMatic Voyager.**iteration scale x/y^i :**

Scales the x with x powered to the iteration index. This algorithm (see illustration below) is critical for creating iterative fractal-like structures, including branching plants. Iteration Scale performs scaling is inverted with respect to the number of iterations of the loop which contains it. It is useful for iterative fractals where space needs to inverse scaled with respect to the number of iterations. It is especially useful for creating distance fields (DF) where the field amplitude needs to be inverse-scaled with respect to the space. Most of the iterated DFRM fractals and iterative tree examples provided with ArtMatic Voyager make use of this component.

**parameters : **

A : Amplitude x (0. : 2.)

B : Amplitude y (0. : 2.)

C : Algorithm dependent

**discussion : **

This component can work on scalar input (1D) as well as 3D or 4D packed input (usually RGB or RGBA packed data). When the input is packed, the output is packed. This is both convenient and spare some packing tile to optimize trees that handles various streams of RGBA data. It is in particular quite efficient in the end of a CT when the output needs to be packed anyway.

For arithmetic operations (Add to Multiply) infinity in input 1 is transmitted unchanged and Infinity in input 2 is treated as transparent.

When dealing with RGB Alpha data the same maths applies to all channels, unlike the 24 Packed Maths # component which mostly handle the alpha differently than the RGB.

If one of the component is scalar and the other RGBA it is converted to (alpha, alpha, alpha,alpha) prior to the operation. The component can handle RGBA in input 1 and RGB in input 2 (in that order only). In that case the alpha of 1 is preserved and the operation affects only the RGB data.

Note: option "allow negatives values" is the default for vector calculation. When working with color values (RGB or RGBA) you may want to use "zero floor" to avoid negative colors.

**Add :**

Addition of scalar or vector data.**Blend :**

Linear interpolation of scalar or vector data.**Subtract (X-Y) :**

Subtraction of scalar or vector data. For RGB unpacked output use**23 Packed Vector Maths #****Difference |X-Y| :**

Absolute value of difference. For RGB unpacked output use**23 Packed Vector Maths #****Multiply :**

Multiplies X and Y. The function is equivalent to Multiply All of 24 Packed Maths for RGBA data. For RGB see**23 Packed Vector Maths #**.**Alpha Compose :**

Available only when inputs is packed RGBA, Alpha Compose simply adds input Y to X according to its alpha value. The final alpha is the maximum of both inputs. Alpha Compose is the natural mode for alpha layers compositing. Parameter C scales the Y alpha prior the operation and can be used to blend in Y.

Note that Infinities are stripped and converted to alpha channel value -1. Resulting Alpha is the maximum of inputs alphas.

See Also the 24 version at**24 Packed Alpha Compose**.

Examples :Libraries/Image Processing/Compositing 3Layers **DF divide :**

This is a convenient function often used to divide a DF field with space scale value. A RGBA stream is passed in input A and the divider (often the S space scale value)in input B. It returns a packed RGBA stream where A has been divided by B; It has no meaning for image compositing and should be used to scale DF field only.**Cross Product :**

**Dot Product :**

**Length :**

**Squared length :**

Only for 3D packed inputs. See 23**Packed Vector Maths #**for reference.

Example: Libraries/Graphic Design/MotionGraphics.artm

**parameters : **

A : Scale X (-16. : 16.)

B : Scale Y (-16. : 16.)

C : Add (-8. : 8.)

**discussion : **

Ax + By + C is essentially a plane equation. It scales and mixes both input and adds the offset C. It can be used as a weighted mixer or as a linear surface generator (a tilted plane). Pass the output to a gradient to generate a linear gradient of variable scale and direction.

**parameters : **

A : Blend or Angle % (0. : 1.)

**discussion : **

**Interpolate** mixes two incoming components/branches by interpolating between the incoming values. It is a simple way to crossfade between two branches of a tree since the mix is handled with a single parameter rather than the 3 parameters required for using Ax + By + C. The "Blend" parameter determines the relative mix of the two incoming branches. When set to 0, the output is the left-hand input. When the parameter is set to its maximum value (1), the output is the same as the right-hand input. When the parameter is set to in-between values, the parameter represents the relative contribution of the two inputs.

**Linear Interpolation :**

linear interpolation uses x+ interpolate*(y-x)**Rotate Interpolation :**

Rotate interpolation uses x cos(Angle) + y sin(Angle) with 'Angle' going from -180 degrees to 180 degrees. When "Angle" is zero x is left unchanged while 90 degrees will outputs y only.

Rotate interpolation is the preferred interpolation mode for sound and DF application because it keeps the magnitude (or gain) of the vector (x,y) constant. It can also be used as a rotation for a single coordinate axis.

**parameters : **

A : Offset x (-4 : 4)

B : Offset y (-4 : 4)

**discussion : **

Multiplies the inputs and sends out the result. Some may use this as a math primitive, others may use it as a mixer to combine two surfaces, and others may use it as a surface generator. When mixing two surfaces, the resulting surface often features interesting interactions of the two inputs that retain some aspects of the two inputs. While the equation is quite simple, the results are often complex and quite surprising. This component is often very useful for designing systems for ArtMatic Voyager as the resulting image generally intersperses areas dominated by the first input with areas dominated by the second input which provides complex topographies.

**parameters : **

A : Offset x (-4. : 4.)

B : Offset y (-4. : 4.)

C : Amplitude (-16. : 16.)

**discussion : **

Calculate the Euclidean distance or **length** given by the square root of x*x+ y*y. The Distance component generates a sort of blunt-nosed cone when it is given the points of the plane as its input. If the 1D sphere component follows the distance component, the result is a perfect half-sphere. Parameters A and B offset the output and parameter C acts as a multiplier/zoom. A negative C value reverses the cone direction to point it upwards.

**parameters : **

A : Amplitude (-4. : 4.)

**discussion : **

Similar to the Distance function, but the square root is not computed. Hence, it runs much faster as the true classical Distance and should be used in iterative cases when the square root can be applied after just once after the iterations. This is a very valuable primitive and can often be used in place of the Distance function where maximum performance is required.

Formula :A(x*x+y*y)

**parameters : **

A : Rotation (-180. : 180.)

B : Contrast % (0. : 100.)

C : Width (0. : 5.)

**discussion : **

A single "line" (with a saw-wave profile) is generated when the input is undistorted space. This component is a commonly used primitive. It is also useful as a mixer for mixing the output of two components.

Line has now various algorithm to address many needs and situations and can provide lines that can be sharp at very high resolutions for graphic design application.

Contrast: Sets the slope of the line edges. Contrast uses a non linear scale so 100% is actually 100*100, that is 10 000.

For Screen resolution graphics it is usually fine to use contrast values below 4 that provides a smooth transition and anti-aliases naturally. But for High resolution outputs, to get a sharp lines you will need to use a very High contrast value so that lines keeps sharp at 10,000 pixel or more rendering.

Width: The width of the line is the point where, at a given contrast, the line gets fully white (1) or fully black.

Notes: With very high contrast the width of the line should be over zero or it will be visible only at very high resolutions. The contrast is not automatic and you need to adjust it for the target of resolution. What looks good on a screen rendering will not be o.k. for a High res print.

**White lines:**

Shades lines in white over black. Equation : Width+1 - contrast *ABS(x). Values beyond the "saw" are zero (Output is clipped to zero (no negatives) ). The line width sets the width while C the height of the line.**Black lines:**

Shades lines in black over white.

Equation: Width + contrast *ABS(x). Output is clipped.**DF lines :**

Equation: Width - ABS(x). In DF mode there is no scaling and values goes to - infinity around the line. Parameters: Amplitude is the distance to the zero crossing so contrast is fixed at 1. Width set the line width by adding a constant to the DF field. DF line can be used in 3D DF modeling. Output is balanced.**Neon lines:**

Shades lines in white over black with a non linear fallout to simulate a neon effect. Output is clipped.**Packed RGBA lines :**

The line can be colored and then the output is a Packed RGBA value that can be mixed with other RGBA values.The RGB color is taken procedurally from the "color ramp" parameter. Negative values sets a gray scale from white to black, while positive value cycles the hues from dark to white. Output is balanced.**Legacy:**

The old line shader kept for compatibility. It is likely to disappear in the near future so use the white line mode and tweak the parameter to get a similar result.

**parameters : **

A : Amplitude (0. : 16.)

B : Size (0.125 : 8.0)

**discussion : **

Gaussian Dot generates a gaussian bump surface using exp(-dist*dist), dist being the euclidean distance to the origin (x = 0, y = 0). The maximum value lies at the origin and the output approaches zero as the input's distance from zero exceeds the "Size" parameter which makes it practical for constraining inputs that tend towards infinity. Practically-speaking, it is the surface equivalent of the Gaussian bell curve.

**parameters : **

A : Radius (0. : 64.)

B : Width % (-1. : 10.)

C : Height % (0. : 10.)

D : Curvature/Smooth % (0. : 1.)

**discussion : **

Profile Shapes provides a large number of shape primitives for 3D modeling and 2D graphic design / decorative arts.
They are distance fields where the zero crossing is the contour of the shape. Since they expand before and after the zero boundary they can be enlarged or reduced by a simple offset and may be shaded in many ways. They also provide a surface that can be used as a terrain as well as a DF primitive.

Example :

For 3D application "Profile Shapes" gives basic shapes for creating architectural objects to render in ArtMatic Voyager. When combined with the appropriate 3D components, Profile Shapes can create a mind-boggling range of shapes. Even a simple systems that uses 32 Revolution & Sweeps # and Profile Shapes can create thousands of object shapes. When using Profile Shapes for 3D modeling, make sure that Allow Negative Values is on if it is available as a parameter option. It is on for those algorithms that do not include it as a parameter option. Use the algorithm popup to choose the shape. The parameter names may change with the shape and are self-explanatory.
Learn more about DF modeling in **Building 3D Objects : DFRM guide**.

This Roman-style church makes use of several Profile Shapes instances. Find out more about technics for 3D modeling with "Profiles Shapes". **Click Here** to review working with DF profiles.

Algorithm Notes: The shapes are focused on architectural shapes and basic polygons. Where iy- or ix- appears in the name, it indicates that the shape is infinite in the -y or -x direction. For example Column Greek iy- is a column that has a top but is unbounded on the bottom (the minus y direction). The Radius parameter (A) sets the global size of the shape. The Width (parameter B) and Height (parameter C) provide independent width and height control. In some cases, Width also modulates the shape. Curvature (parameter D) smooths all or certain angles most of the time. In some cases, it will modify the shape or curvature. The ornamentation/borders/frames of walls and columns are also increased with the fourth parameter. The options usually offers ways to make the shape unbounded (infinite) in a one or both directions and determines if the shape growth direction .

**Lozenge :**

The original algorithm, "Lozenge", is a simple four-sided pyramidal surface."Lozenge" that can be used in non-DF mode with the option "zero floor" ON. The Lozenge shape is frequently used as a primitive in recursive compiled trees in place of the Gaussian Dot or Line.**Triangle :**

**Rectangle :**

**Pentagon :**

**Hexagon :**

**Octogon :**

They provides basic regular polygons : the width and height parameters stretch the space to create irregular polygons. At width 0 and height 0 you get a regular polygon of the given radius size. The triangle through disc algorithms feature the parameter options below. These options determine how changes in Radius/height influence the shape and if its unbounded in a given axis:

- growth up only,
- growth up & down,
- growth down,
- growth up, infinite in x+,
- growth up, infinite in y-,
- growth up, infinite in x+ & y-.

**Arcade :**

**Disk :**

**Gothic Arch :**

**Persian Arch :**

**Horseshoe Arch :**

**Pointed Horseshoe Arch :**

**Trefoil Arch :**

**Column concave :**

**Column classic :**

**Column greek :**

**Column Scifi :**

**Stairs 4 iy- :**

**Stairs inf ixy- :**

**Dome :**

**Pointed Dome :**

**Dome Russian :**

**Power Dome :**

Provides various profiles dome shapes for 3D architecture and design. They can be used on any map but use a disc in xz for classical domes: Dome, Pointed Dome, Russian Dome:- infinite in x+ (fill),
- default (mirror x),
- infinite in x+ and y-

**Roof A ix-:**

**Roof B ix-:**

**Saucer:**

**Wall classic :**

**Wall classic roof 30 :**

**Wall classic roof 45 :**

**Wall stones :**

The Various wall profiles provides basic shapes for 3D architecture wall designs (with roof or not). Wall classic through Framed box feature the following parameter options: infinite in x+ (fill), default (mirror x) and infinite in x+ and y- **Chinese Roof & wall :**

This profiles provides a more complex curved roof inspired by Chinese architecture. When infinite in x is chosen as an option the roof will expand towards the zero when applied to any path profiles.**Framed Box :**

Framed box features some edges at the corners. Framed box options are infinite in x+ (fill) and default (mirror x).**Chisel Rect :**

A rectangle with chiseled edges. Chisel Rect has the same options as the other polygons.

**Chisel Cross :**

A cross with chiseled edges. Chisel Cross has the same options as the other polygons.

**parameters : **

A : Frequency (0. : 4.)

B : Mutation % (0. : 1.)

C : Level (0. : 2.)

D : Algorithm dependent

**discussion : **

**DF Curves #** provides a set of various curves profiles for 3D modeling and 2D graphics. The DF field is computed using complex mathematics to provide a accurate distance estimate to the function, often using newton/ralphson iterative technics to solve 5 degree polynomials or analytically unsolvable functions. Thus they are generally slower than the Profiles shapes # functions or other curve approximations available elsewhere in Artmatic engine but they give a perfectly accurate DF field suited for 3D modeling in Voyager. As 2D functions they need to be combined with other primitives to create bounded 3D objects.

Some curves are available in lines only while others are provided as an oriented profile as well. Objects created with profile version will be filled while others will be hollow. Infinite curves like Cubic and Exp have been clipped to a large disc to avoid numerical instability for large values.

Parameter 'Level' sets the radius of the line in Curve mode. It has no effect for profile curves.

Extraordinary 3D objects can be modeled by combining several of this primitives.

Learn more about DF modeling in **Building 3D Objects : DFRM guide**.

**Power arch profile:**

A power 2 infinite curve DF profile. 'Phase' can offset the curve in x.**Power arch curve:**

A power 2 infinite DF curve**Cubic disc profile,****Cubic curve:**

A simpler cubic curve function than the 41 Bezier curve. 'Mutation' changes the slope of the cubic end points. 'Phase' can offset the curve in x. The curve is available as profile and DF curve modes.**Exp profile,****Exp curve:**

A curve set using t=(x,exp(x)). 'Mutation' scales the exponential slope and negative values will curve on the left side. 'Phase' can offset the curve in x. The curve is available as DF profile and DF curve modes.**Spiral:**

A linear growing spiral. 'Mutation' controls the length of the spiral.

*Spiral sweep with Exp curve*

**Archimedes Spiral:**

A power 2 growing spiral. 'Mutation' controls length of the spiral.**Ellipse segment X,**

**Ellipse segment Y:**

'Mutation' controls the aspect ration of the ellipse while Parameter D sets the 'Arc length'. The segment is centered in x or y and the curve is symmetrical in x or y.

When 'Arc length' is at maximum the ellipse if filled to provide a DF profile.**Wide U:**

U shape curve where parameter D 'Arc length' sets the horizontal length and B the upward or downward curvature. Designed to make curved wings or fins this curve can also be used for plates, bowls or whatever.**Arc segment:**

A circular arc segment growing counter-clockwise with parameter 'Mutation'**Infinity loop:**

A parametric curve using x,y=(- cos(t)^2 , 0.5*sin(A*t)^2) that cross itself. It creates an infinity sign when A is 2. The 'Mutation' parameter slides from 1.5 to 4 using steps of 0.5.

*Infinity loop sweep with Ellipse segment*

**Metal Heart:**

Heart shaped curve.**Dot Spiral,****Line Spiral,****Line Spiral half radial,****Morph Spiral:**

A power X growing spiral, x being controlled by 'Mutation'. Parameter steps controls the amount of samples along the curve. 'level' controls the radius of discs or line. In the Dot and Morph mode the dot radius is also scaled by the distance between steps, unless level is set at 1 in which case radius is kept constant. The various algorithms changes the path rendering style in a similar way provided by**2D Motion Path render**.

The equation is quite easy : t^x *sin(t), t^x *cos(t) and you can implement it using 42**2D Motion Path render**for more controls on the rendering.

*Morph Spiral sweep with Power arch*

**Bottle:**

A simple Bottle shaped curve. Parameter B & D can mutate the shape of the bottle.**Vase:**

A simple Vase shaped curve. Parameter B controls the width while Parameter D the height of the Vase.

**Wine glass:**

A wine glass shaped curve. Parameter B controls the width while Parameter D the height.

**Champaign glass:**

A Champaign glass shaped curve. Parameter B controls the width while Parameter D the height.

*Still life using various curves : Bottle, Vase, Wide U etc*

**parameters : **

Algorithm slider : (0 : 30)

B : Radius (0. : 32.)

C : Amplitude (0. : 64.)

**discussion : **

This component creates a variety of basic shapes for terrains (elevation maps). It is useful for creating terrains in ArtMatic Voyager. The algorithms popup menu or "Algorithm slider" parameter determines the shape created. Algorithms include a variety of cones, pyramids and cubes with various contours as well as a star shape and various building shapes. The parameter options give the option of having negative values which can be useful when using it with ArtMatic Voyager.

**Cone squared :**

Inverted distance function squared.**Cone linear :**

Inverted distance function.**Cone dome :**

Inverted distance function passed through a (d*(2-d)) filter that makes the slope at the peak flat.**Cone round :**

Inverted distance function passed through an arc-shape filter.**Cone cubic :**

Inverted distance function passed trough a cubic spline.**Cone step low :**

Inverted distance function passed trough a low frequency step filter.**Cone step high :**

Inverted distance function passed trough a higher frequency step filter.**Pyramid squared :**

Pyramid passed trough a power 2 filter.**Pyramid linear :**

Pyramid.**Pyramid dome :**

Pyramid passed trough a (d*(2-d)) filter that makes the slope at the peak flat.**Pyramid round :**

Pyramid passed trough an arc-shape filter.**Pyramid cubic :**

Pyramid passed trough a cubic spline filter.**Pyramid step low :**

Inverted distance function passed trough a low frequency step filter.**Pyramid step high :**

Inverted distance function passed trough a higher frequency step filter.**Cubes Cluster squared :**

Cluster of cubes squared.**Cubes Cluster linear :**

Cluster of cubes.**Cubes Cluster dome :**

Cluster of cubes passed through a (d*(2-d)) filter that makes the slope at the peak flat.**Cubes Cluster round :**

Cluster of cubes passed trough an arc-shape filter.**Cubes Cluster cubic :**

Cluster of cubes passed trough a cubic spline filter.**Cubes Cluster step low :**

Cluster of cubes passed trough a low frequency step filter.**Cubes Cluster step high :**

Cluster of cubes passed trough a higher frequency step filter.**Cubes Cluster LF A :**

**Cubes Cluster LF B :**

**Cubes Cluster LF C :**

**Cubes Cluster cone :**

**Star 4 :**

A four branch star terrain.**Cube :**

**Bulding A :**

**Bulding B :**

**Bulding C :**

**Bulding D:**

**parameters : **

A : Offset (-2. : 2.)

B : Amplitude (-2. : 2.)

**discussion : **

This component provides a pseudo illumination effect on a bump when shaded in gray levels. As a surface it creates a positive bump on the right side of a 45 line passing trough zero and a negative bump the other side. Its value approaches 0 the further one gets from the origin (0,0).

**parameters : **

A : Frequency (0.50 : 12.)

**discussion : **

When the input is undistorted space, this component's output is the angle between the x-axis and the input point. The output is symmetrical about the x-axis and yields a lighting effect on a virtual cone when the input is the points of the plane. The frequency parameter controls the arc of the lighted and shadowed areas.

**parameters : **

A : Amplitude (-2. : 2.)

B : Min to Max (0. : 1.)

C : Smoothness % (0. : 32.)

**discussion : **

MinMax returns the minimum of (x,y) when parameter 'Min to Max' is zero, the maximum of (x,y) when 'Min to Max' is 1, and a blend of the two otherwise.

It can be used as a mixer to combine two surfaces by selectively choosing values from one input or the other rather than combining the values.
Parameter 'Amplitude' multiplies the result and shall usually be 1. The 'Smoothness' parameter controls the continuity of the transition between the two inputs.

Using **Min <-> Max** with 'Min to Max' at 0.5 will blend the min and the max at equal weight yielding the **Median**.

When parameter 'Min to Max' is 1 or 0 the function is identical with the **21 Logic tools #** Union or Intersection

**parameters : **

A : Blend x<->y (0. : 1.)

B : Blend min/max (-2. : 2.)

C : Smoothness % (0. : 50.)

**discussion : **

Logic Tools provides a number of algorithms for combining surfaces and DF objects using a variety of logic (boolean) operators. They are particularly useful for 2d graphics, terrain design and DF 3D modeling.
(Learn more about DF modeling in **Building 3D Objects : DFRM guide**).

The 'Smoothness' parameter avoid sharp discontinuities by blending fields at the edges of the boolean operation. In general 'smoothness' is implemented using a square power blending function. The Cubic smooth (union,intersection and subtract) algorithms provides a 'smoother' smoothing by using cubic blending curves.

**Weighted union max(x,x*A+y) :**

Returns the maximum of x and y+ (x*A) + B. You can think of it as bending the right-hand input (y) to follow the left-hand input (x) before the Maximum of both is returned. When parameter A ("x weight") is zero, this component behaves as a simple maximum function. When A ("x weight") is 1, the component performs a simple addition. Parameter B provides an offset that increases the elevation of y before the Maximum is taken.

This function is especially useful for designing systems for ArtMatic Voyager where it can be used to limit certain surface features (such as stone clusters) to certain elevations. Practically, it allows one component to be made sensitive to another component.

**Max & Blend (union) :**

Union is equivalent to logical OR. The Max and Blend implementation further blends the union with a blend of x and y. Parameter B controls the mixing of the Max and Blend values. When B is 1, the output is the strict Maximum of x and y. When B is 0, the output is the Blend(x,y,a) output, a being Parameter A. The Blend output is not a strict interpolation of the x and y inputs. The value of the x-input acts to limit the value to keep the output from going to infinity. This is useful for DFRM optimization in cases where the tree results in the distance estimate being too small (which makes rendering take too long). For instance, blending two fields sometimes results in a field that approaches -infinity too slowly which can cause ArtMatic Voyager to spend extra time to find the true object boundary. This happens when merging a sphere and an infinite cylinder with a straight interpolate. When using Logic Tools, use the x-input for the finite shape and the y-input for the shape that is infinite in one or more directions.

In all following examples 'x' is a triangle while 'y' is a disk.

The example file can be found inLibraries/Components demo/21 logic tools . Change the main logic algorithm to see the various logic behavior.

**Min & Blend (intersection) :**

Returns the intersection of x & y (Logical AND) and further blend the intersect with a blend of x and y. If parameter B is 1, the result is min(x,y), that is, the straight intersection. With parameter B at 0, the result is a straight interpolation.

**Intersect min(x,y) :**

Returns the intersection of x & y. (Logical AND)

**Subtract min(x,-y) :**

This algorithm cuts off the object where y is positive. In other words the volume y is subtracted from volume x.

Of course they have to intersect for this operation to change x.

**Intersect with -abs(y) :**

This algorithm essentially flattens the x-input object with the contour of input y. For example, a sphere intersected with a horizontal plate will squashed into a disk. The 'Thickness' parameter will adjust the size of the contour y.

**Minus max abs (Manhattan dist) :**

The Manhattan distance is defined as max(|x|,|y|). It creates a square shaped distance function instead of the normal circular euclidian distance. This algorithm generates a square contour around the zeroes intersects of both input fields. It may require some adjustment of the parameters 'Thickness'.

**Minus min abs (contours) :**

Perform an union of the contours of both inputs shapes. The 'Thickness' parameter will adjust the size of the both contours.

**Chisel union :**

**Chisel intersect :**

**Chisel subtract :**

Perform the main logical function (union, intersection and subtraction) with chiseled corners. 'Chisel offset' parameter sets the width of the chiseling. The example below shows the chisel union of the triangle and the disc.

**Subtract y & blend x :**

Returns the logical x -y and optionally morph with x if parameter "Blend" is <1.**Subtract x & blend y :**

Returns the logical y-x and optionally morph with x if parameter "Blend" is <1.

**Repulsive union :**

**Ripple union :**

**Sym Ripple union :**

Perform the Union logical function tweaking the intersection zone by various functions. The repulsive case will cut a hole around y, while ripple case will add a small undulation around the intersects. Theses algorithms are often use with a bit of smoothing in DF modeling to achieve an "organic" look.

**Ripple subtract :**

**Framed subtract :**

**Partial subtract :**

Partially subtract B from A. This mostly subtracts B's outline from A leaving a core with A's contour.**Edged union :**

**Edged intersect :****Edged subtract :**

Perform the main logical function (union, intersection and subtraction) with added edges at their intersection.

'Border thickness' parameter sets the edge radius. For more control on the edge you may use S:P Logic and Profiles # versions.

Parameter B 'NE Level' controls the level of the non-edge border part of the created volume. At its maximum, it will leave just the edges.**Cubic smooth union :**

**Cubic smooth intersect :**

**Cubic smooth subtract :**

Perform the main logical function (union, intersection and subtraction) using a cubic spline to smooth the edges of the logical operation.
**Bump intersect :**

Perform the intersect logical operation and adds a bump or a hole at the intersection."Thickness" sets the size of the Bump while "Bump Offset" controls the bump location. Bump intersect is great for adding details to the boolean operation, and can be used also to apply a bump texture when used with a volumetric DF pattern in input y. Similar effects can be achieved with S:P Logic &Profiles displace, dent and bump algorithms.

**Underlay (x top) :**

Meaningful when values are balanced the new values goes behind the old. Unlike minimum the zeroes of the old values overlay the newer. Negatives are transparent. Underlay and overlay are great to keep the contours of shapes.

**Overlay (y top) :**

Meaningful when values are balanced (negatives as positives) the new values goes over the old. Unlike maximum the zeroes of the new values overlay the older regardless of their values. Negatives are transparent.

See the color version examples at 44 Memory w Logic #Overlay

**Xor :**

With Logical Xor 2 positives turns negative so the intersection of inputs gets emptied. Zero crossings of both inputs are preserved when they intersects.

**Union Xor :**

Union Xor sets the intersection of x and y to positive and preserves the zero crossings of both x AND y. It is similar to Union but keeps the contours (the zero crossings)

**Minus Xor :**

Uses the negative of the Xor logical operation.

**parameters : **

A : Offset y (-10. : 10.)

C : Morph with x (0. : 10.)

D : Smoothness % (0. : 20.)

**discussion : **

S:P Logic & Profiles implement all important logic functions that can work indifferently on Scalar or Packed RGBA vectors. When the input is packed, the output is packed.

Logic & Profiles is the preferred tool to perform volumetric modeling : See **Building 3D Objects : DFRM guide**.

If one of the component is scalar while the other is RGBA it is converted to (1,1,1,alpha) equivalent to a white 3D DF object when alpha is the DF. The given functions are meant to work with RGBA DF input in 3D modeling but the straight min & max will work for RGB values. With RGB values, only max and min make sense so other algorithms will revert to "Union (max)", or "Intersect (min)". Infinity in input 1 is transmitted unchanged and Infinity in input 2 is treated as transparent.

The Algorithm pop up provides icons which give a preview of the DF profile when used on x y coordinates.

The boundary between a pure logic operator and a profile shape is blurry. In fact any logic function can be used to generate a profile, as well as a profile shape can be use as a logic function to mix two input volumes. The icon generated by the function actually shows the profile shape emerging from the logic operation between X & Y.

All functions have as first parameter 'Offset y' which allow to adjust the level of input y DF field. Some algorithms have an extra parameter 'Morph with x' that will optionnaly mix the logical result with the x input when above zero.

Option popup applies to thickness and spread parameters only.

**Union (max) :**

Implement the standard logical*Union*function. See**21 Logic tools #**

This algorithm has the 'Morph with x' parameter.**Intersect or min(x,y) :**

The standard logical*Intersect*function with the extra 'Morph with x' parameter.

**Subtract or min(x,-y) :**

The standard logical*Subtract*function with the extra 'Morph with x' parameter.

**Chisel union :**

**Chisel intersect :**

**Chisel subtract :**Perform the main logical function with chiseled corners. "chisel offset" parameter sets the width of the chiseling.

**Edged union :**

**Edged intersect :**

**Edged subtract :**Perform the main logical function and adds an edge at the intersect of X & Y. Edge width and height parameter sets the size of the edge along x and y direction separately. The naming 'width' or 'height' is relative to input orientation so it may appear reversed at times. When in RGBA the edge is colored with AuxColor C.

Perform the main logical function and adds an edge at the intersect of X & Y. When in RGBA the edge is colored with AuxColor C.**Arc union :**

**Arc intersect :**

**Arc subtract :**Perform the main logical function with an Arc to blend X & Y at the intersect of X & Y. Arc logic functions distorts less the DF field than normal a smooth union.

- The smoothness parameter has effect only for color blending with packed RGBA inputs.
- When in RGBA the edge is colored with AuxColor C.

**Displace :**Displaces x at the y zero crossing by 'Thickness' parameter; Displace logic is similar to partial subtract but is offsets x symmetrically around zero. The chisel percent parameter will chisel the outer edge of the intersect.

**Dent :**Cuts x at the y zero crossing using spread - ABS(y) . Thus parameter spread will change width of the cut while parameter 'Thickness' will set its depth.

**Bump :**

Adds a bump to x at the y zero crossing using spread - ABS(y)**Chisel displace :**

**Chisel dent :**

**Chisel bump :**

Same as "displace", "dent" & "bump" but using a 45 degree slope for the displacement.**Circle displace :**

**Circle dent :**

**Circle bump :**

**Chisel Union -y :**

**Edged Union -y :**

Union with the inverse of Y. When using Chisel & Edge the edges of the union are either chiseled or given and edge.

Note: Union, Intersection, Subtract & Chisel union have an additional parameter "morph in x" that allows to blend with the DF field passed in x after the Boolean operation.

**parameters : **

A : Period (1/Freq) (0.02 : 50.)

B : Scale Y (0.06 : 16.)

C : Contrast % (0. : 100.)

D : Width % (0. : 1.)

**discussion : **

This component generates a grid pattern when it is fed the points of the plane. The Grid is not necessarily square as the 'Scale Y' parameter can change the Y period independently of X when set at a ratio != 1. It is a very useful function when examining how the various vector functions (2->2) distort space. The scale parameters determine the spacing of the horizontal and vertical bars. The amplitude parameter determines the "height" or the "arc" of the grid bars.
Shading rendering of the grid is similar to the ones used in the 21 Line tools #
algorithms.

**White lines :**

**Black lines :**

**DF lines :**

**Neon lines :**

**Legacy :**

**parameters : **

A : Amplitude (0. : 8.)

B : Phase (-32. : 32.)

C : Frequency (0. : 8.)

**discussion : **

Hexagons creates a surface of infinite tiled hexagonal pyramids. The size of hexagons is determined by the 'frequency' parameter while Amplitude controls the height.

"Phase" offset the pattern in x.

**parameters : **

A : Contrast % (0. : 100.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

D : Width % (0. : 1.)

**discussion : **

This component generates grid-like patterns that are shaded with the 21 Line tools # algorithms. The underlying math now ensures that the frequency scaling matches the other tile components.

For example see the

**Radius 1 square grid:**

Unit square grid.**Square 45° grid:**

Square grid at 45 degree. Size of grid is set so that it will intersect the square grids edges at the same frequency.**Legacy : hexagons & triangles:**

**Hexagons & triangles grid :**

**Triangles grid :**

**Lozenges grid :**

**Hexagons dual grid :**

**Hexagons grid :**

**Hexagons & squares & triangles grid :**

**parameters : **

A : Amplitude (0.01 : 16.)

B : Trap radius (0.01 : 8.)

C and D : Algorithm dependent

**discussion : **

Orbit analyzer is a great practical tool to shade many kind of 2D fractals.

When a 2D transform is applied recursively, each transform application defines a new point in the orbit. Depending on how this obit goes one can usually decide a shading strategy :

- the orbit quickly moves far away from origin. It is called *divergent*.

- the orbit quickly moves to a fixed points or a fixed set of points. It is called *convergent*.

- the orbit is chaotic or takes a very long time to converge or diverge. It is often the case at the boudaries of well defined regions, like typically the borders of the Mandelbrot set.

**Orbit analyzer** is usually used with a **23 Looper** above that will recurse the 2D transform, often compacted in a **Compiled Tree**.

You can use several Orbit analyser to extract various information from the orbits and mix them to create complex shading of the functions. Not all algorithms gives useful information with all kind of functions, but there is always some that will work even with the most difficult chaotic system. Best is to try and change the output amplitude and tweak the parameters to see what features are brought out.

Several Orbit analyzer tile can be used to mix various algorithms like in the example:

Except the output 'Amplitude' that scales the result globally, parameters varies according to the algorithms.

Orbit Analyzer proposes the following algorithms to extract information from the iterations's orbits:

**Total distance :**

Sums and scale the distance between each consecutive points of the orbit.**Max velocity :**

Returns the maximum velocity (distance between each consecutive points).**Min velocity :**

Returns the minimum velocity (distance between each consecutive points).**Escape Time :**

Returns the time it takes to escape the given radius set by 'Escape Radius' parameter A.**Escape Time log(d)/B^i :**

Returns a processed time it takes to escape the given radius. This works fine with Z^N fractals that has infinity escaping orbits and where the power is obvious : Set parameter B to match the power of the factal.**Max magnitude :**

Returns the maximum magnitude (distance from zero).**Disk orbit trap :**

Traps the orbits with a zero centered disk of the given 'Trap radius'.**x axis orbit trap :**

Traps the orbits with the x line of the given 'Trap radius'**y axis orbit trap :**

Traps the orbits with the y line of the given 'Trap radius'.**xy axis orbit trap :**

Traps the orbits with both.**Escape dot :**

Returns the dot product of the last orbit direction with a given 'Direction'.**Dot average :**

Integrates the dot product of all orbit directions with a given 'Direction'.

Example:Libraries/Fractals/OA FerroMagnetModel.artm

**x average :**

Weighted sum of positive x values. Example:Libraries/Fractals/OA\ PolyJuliaSets.artm

**y average :**

Weighted sum of positive y values.**Gaussian zone trap :**

Traps the orbits with a Gaussian zone given by 'Trap radius' and position set by 'Offset' (x,y) parameters.

Example:Libraries/Fractals/OA FerroMagnetModel.artm

**Gaussian terrain :**

Introduced in engine 8.06**Gaussian terrain**Accumulates Gaussian zone traps given by radius and position using decreasing amplitudes to achieve a coherent terrain for 3D rendering. Amplitudes for each iterations follow the 1/(powerbase ^ i) rule where i is iteration number and powerbase ranges 1 to 5 when parameter 'Power damp %' goes from 0 to 1.

Clearly when 'Power damp %' is 0 there is no damping of amplitude (1/(1 ^ i)==1) while at 1 amplitude diminish very fast by 1/(5 ^ i).

Example:Libraries/Components demo/OA GaussianTerrain.artm

**Escape angle (8.08) :**

When the orbits are not diverging the angle of the last orbit direction with the given reference (parameter 'Direction') is returned without scaling (range 0, Pi). Otherwise the escaping points (divergent orbits) are shaded using negative values scaled by the 'Amplitude' parameter. Thus the 'Amplitude' parameter affects only fractals that have regions where orbit escapes. This mode is practical to give bassins of attraction various colours while visualising the escaping zones. Example:Libraries/Fractals 8.08/OAN Dragon Eangle.artm

**Orbit angle (8.08) :**

The angle between last orbit direction with the given reference (parameter 'Direction') is returned whatever the orbit state : convergence or divergence or others. Unlike with "Escape angle" the returned angle is scaled by the 'Amplitude' parameter.**Instant velocity log (8.08) :**

The instant velocity is defined by the magnitude of the last orbit vector (last point minus previous point). The log of the magnitude is returned by this mode and scaled by Amplitude parameter. Divergent orbits (that is orbits that escape towards infinity) will get very high values quickly.**Instant acceleration (8.08) :**

The instant acceleration is defined by the change of length of the last orbit vectors. Divergent orbits will get very high values quickly and acceleration and velocity are often going together.**Vorticity estimate (8.08) :**

This mode integrates an estimation of "vorticity" that is the quantity of rotation in the course of the orbit. As the rotation sum can span many full turns this mode is often used with looping gradient as there is no upper limit on resulting values that can be adjusted by the 'Amplitude' parameter.

**parameters : **

A : Amplitude (-16. : 16.)

B : Phase X (-32. : 32.)

C : Phase Y (-32. : 32.)

D : Frequency (0. : 16.)

**discussion : **

21 Sines # renders a series of surfaces based on Sines.

**Sines Add (Sin x + Sin y):**

Sines addition : generates an egg-crate like surface when given undistorted space as its input. The frequency parameter controls the size of the surface's 'cells' and the phase parameters shift the pattern vertically and horizontally.**Sines Mul (Sin x * Sin y):**

Sines multiplication : The output of Sin x * Sin y is similar to that of the sin x + sin y though it has more of a checkerboard effect on a raw plane. Amplitude effects the steepness/color contour of the cell walls.**Sines displace (x + A Sin y):**

x is displaced by a scaled sine of y**Hexa sines:**

Sines evaluated in a hexagonal lattice

**parameters : **

A : Frequency (0.06 : 6.28)

B : Size (0. : 1.50)

C : Power (0.25 : 8.)

**discussion : **

Circles generates an arrangement of tiled cones. The frequency parameter determines the spacing of the cones. The size parameter determines the size/shape of the bases; at the minimum value the base has a circular shape; at the maximum value, the cones appear to have square bases. The power parameter acts as a contrast/brightness control on the component's output. To see the output as cones, use the derivative function as the final component as in the image to the left.

**parameters : **

A : Amplitude (-4. : 4.)

B : Cone size (1. : 6.)

C : Frequency (0. : 16.)

**discussion : **

Technically-speaking, this component generates an arrangement of randomly-sized and placed cones whose appearance can seem like motes or "space-dust". Amplitude controls the contrast/cone height. Bubble size controls the cone base size, and frequency controls the spacing and can act like a zoom control.

**parameters : **

A : Amplitude (-2. : 4.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

**discussion : **

Star Field generates a virtual, layered starfield that is great for creating cosmic textures and images as well as for bump textures.
Animating the phase parameter creates a sense of depth by moving the layers at different speeds.

**parameters : **

A : Amplitude (0. : 8.)

B : Phase (-32. : 32.)

C : Frequency (0. : 16.)

D : Ripples (0. : 1.)

**discussion : **

Ripples generates various patterns of sinusoidal ripples according to the algorithms below. The ripples # parameter determines the number of concentric rings per tile. The 'Frequency' parameter determines the overall pattern size and the 'Phase' parameter animates the ripples. The new mode "random Add" is much more suited for natural looking textures while other modes are fine for graphics.

'Frequency' abides to the standard **frequency options**.

**Ripples #** was changed in ArtMatic engine 8.07

**Regular max+:**

The legacy algorithm : Ripples are generated on a regular grid and mixed using Maximum with zero clipping. The 'Ripples' parameter controls ripples frequencies.**Regular add:**

Ripples are generated on a regular grid and mixed additively with negatives values allowed. The 'Ripples' parameter controls ripples frequencies.**Random add:**

Ripples are generated randomly and mixed additively. The 'Ripples' parameter controls both ripples density and ripples sines frequencies.

**parameters : **

A : Frequency (0.12 : 8.)

B : Amplitude (-2. : 2.)

C : Phase (-32. : 32.)

**discussion : **

Facet is a discontinuous function that generates a mosaic-like surface. It uses an algorithm similar to bubbles but generates the same value (altitude) for each individual bubble.

**parameters : **

A : Scale X (-8. : 8.)

B : Scale Y (-8. : 8.)

C : Amplitude (0.12 : 4.)

**discussion : **

This component generates discrete random rectangles when the component's input comes from the raw plane or another component with two outputs. The scale parameters determine the horizontal and vertical sizes of the rectangles and the amplitude is a multiplier to the output. Note that the output is discontinuous and does not tend to work well with the derivative component.

**parameters : **

A : Amplitude (-16. : 16.)

B : Phase (-16. : 16.)

C : Frequency (0.03 : 32.)

D : Smoothness % (0. : 1.)

**discussion : **

DF Patterns implements a series of procedural patterns useful for design and architecture. When Amplitude is 1 the distance field is exact and the pattern can be used in 3D for texturing and volumetric terrains within Voyager. The output is balanced and unlimited which makes them useful also for graphic effects like wipes.

Usually the phase parameter controls an offset in x or z (the pattern can be 3D internally) but is sometimes used to modulate a 5th parameter like density or orientation probabilities.

Note: DF implies that amplitude is linked with frequency so that the value of the field is a good approximation of the distance to the zero crossing, that is the surface of the object. That means practically that for high frequencies the amplitude gets pretty small and for a 2D graphic use you will need to scale the output to compensate (or scale the space before and keep the DF frequency low).

**Maze TR :**

A random maze pattern on an orthogonal grid with branches oriented top right.**Maze BL :**

A random maze pattern on an orthogonal grid with branches oriented bottom left.**Maze Grid :**

A random connected line pattern. Phase parameter changes the probability (cyclically) of vertical versus horizontal connecting lines.**Maze Interlaced :**

A random grid pattern with the illusion that segments goes under or above crossing lines. Can provide a good primitive for Islamic art design when used with advanced tilings geometry.**Chinese Maze :**

A random orthogonal pattern with various lines and dots.**Loose Chinese Maze :**

A lower density random orthogonal pattern with various lines crossing or not.**Alien writing :**

Lines of fantasy characters within an orthogonal grid.**Signs bands :**

Lines of fantasy characters within an orthogonal grid.**V broken lines :**

**H broken lines :**

**Recursive blocks + :**

**Recursive blocks :**

**Recursive blocks density :**

**Recursive blocks density & zero :**

**Recursive Splits :**

**Recursive triangles + :**

**Recursive triangles :**

**Recursive triangles density :**

**Cross 45 panels :**

**TetraMaze :**

**Saw Splits Affine:**

This pattern is build with rotated lines that split recursively and randomly the previous interval.**Mutation maze 2D :**

**Octa density segments :**

A DF pattern organized on an octagonal grid. Mutation parameter controls the segments density.**Octa mutation network :**

A network maze DF pattern organized on an octagonal grid at full density. The Mutation parameter randomizes the pattern.**Chisel maze :**

A complex maze2D pattern where the mutation parameter controls the overlapping of the chisel various shapes.**Organic maze :**

Pattern created by the random overlapping of 8 orientations of smooth shapes.**NF16 Random faults :**

Pattern created by the random overlapping of 16 directional lines cuts on a disc mask.**Displaced chisel saw :**

Saw DF pattern with random chisel bumps and dents. Mutation parameter randomizes the placement of bumps and sets their size.

**parameters : **

A : Frequency (0. : 4.)

B : Mutation % (0. : 1.)

C : Level (0. : 2.)

D : Phase (-6.28 : 6.28)

**discussion : **

**DF Waves #** provides a set of various periodic curves profiles for 3D modeling and 2D graphics. The DF field is computed using complex mathematics to obtain a true distance estimate to the zeros of the function, often using iterative technics to solve equations that are not analytically solvable. Thus they give a perfectly accurate DF field suited for 3D modeling in Voyager as well as an accurate elevation to render a 2D curve of invariant thickness. As 2D functions they need to be combined with other primitives to create bounded 3D objects. For 2D graphics you may want to connect the output to other tiles to shade the curve in various ways.

Most curves algorithms comes with 2 flavors : 'profile' & 'curve'. 'profile' keeps the opposite signs around the zeros of the wave curve while 'curve' render the wave as a line using level-ABS(C), C being the curve DF field.

**parameters:**

'Frequency' controls the scale of the wave. The effect of 'Mutation' depends on which algorithm is selected and is discussed below. 'Level' offsets the zero crossing of the curve while 'phase' moves the periodic curve laterally.

Examples :

*Two periodic curve intersects on the 2D plane.
A true DF field is not only useful for 3D DF modeling, it provides a constant thickness for 2D graphics curves.*

**Sine profile,****Sine curve:**

Sine DF curve. 'Mutation' sets the amplitude.**Arch profile,****Arch curve:**

x squared rendered as a periodic true DF field. 'Mutation' sets the curvature.**U Wave profile,****U Wave curve:**

An orientable U wave where 'Mutation' slants the wave left or right.**Saw profile 30:**

Creates an asymmetric DF saw wave profile smoothable with parameter B. Peek is at x==0. This algorithm is suited to create stairs going down when inputs (x,y) are rotated 30°. Use -x for stairs going up.**Saw profile 45:**

Creates a symmetric DF saw wave profile, smoothable with parameter B and dephased so that y=0 at x==0. The profile is balanced around y==0 when parameter 'level' is at 1 (middle).

Notes: Unfortunately blending or adding 2 exact distance fields does not necessary yield an exact DF. Only boolean operations like min , max and the functions provided by the various logical tools will preserve the original DF.

**parameters : **

Algorithm slider : (0 : 37)

B : Amplitude (0. : 16.)

C : Frequency (0. : 32.)

**discussion : **

This noise component creates a variety of "techno" patterns that can be useful for creating decorative patterns and also for designing ArtMatic Voyager cities and artificial terrains. Use parameter A to select the pattern. A variety of mazes, patchworks and cityscape-like patterns are available. Most patterns come in both a sharp and a soft variety. Generally, the "soft" version should be used whenever this component is used to create surfaces and textures for ArtMatic Voyager as the "sharp" version can have discontinuities (sharp edges) that can cause problems in ArtMatic Voyager.

The various "City" noises provides city-like terrains that share the same street network and that can be combined when set at the same frequency.

Use this component set to the Street Network or Streets Mask pattern along with the minimum or multiply function to shape another surface to a city map as shown above. All the patterns with "city" and "street" in the name use the same street networks so they can be mixed together as long as they use the same frequency setting.

**City blocks :**

**Mondrian :**

**Signs :**

**Techno Grid :**

**Techno Maze :**

**Techno :**

**Sparse Rects :**

**Techno Coral :**

**Building :**

**Building B :**

**Computer Dots :**

**Street Network :**

Street network provides a map of streets with sidewalks and buildings of various heights. The street level values are well below zero, the sidewalks are at 0, and the buildings have elevations above 0.**Street Mask :**

Street Mask has positive values at street level and 0 for the city blocks.**Patchwork City C :**

**Alien City :**

**High Rise City :**

**Random High Rise :**

**Tech Lines :**

**Tech Marks :**

**parameters : **

A : Amplitude (0. : 8.)

B : Phase (-32. : 32.)

C : Frequency (0. : 16.)

**discussion : **

Pyramids generates surfaces made by a sum of recursively scaled square based pyramids.

**Pyramids random noise:**

Sum of randomly & recursively placed square-based positive or negative pyramids.**Techno noise:**

Sum of randomly & recursively placed square-based positive pyramids.**Techno noise const lines:**

Similar to above but the height of the smaller pyramids is scaled so that the slope of the pyramid remains constant.**Pyramids noise DF:**

Similar to above but with the Amplitude linked to frequency so that at Amplitude 1 the terrain can be used as a DF compliant function for 3D modeling.

**parameters : **

A : Amplitude (0. : 8.)

B : Phase (-32. : 32.)

C : Scale (0. : 4.)

**discussion : **

This procedural component creates a randomized pattern that juxtaposes several predefined patterns. A typical pattern is shown at left.

**parameters : **

A : Amplitude (0. : 8.)

B : Phase (-32. : 32.)

C : Scale (0. : 4.)

**discussion : **

This procedural component creates a randomized pattern that juxtaposes several predefined patterns. A typical pattern is shown at left.

**parameters : **

A : Amplitude (0. : 2.)

B : Style (0. : 1.)

C : Frequency (0. : 8.)

**discussion : **

Maze is a texture function that creates maze patterns. Parameter B (Style) determines the maze pattern.

**parameters : **

A : Amplitude (0. : 8.)

B : Phase (-32. : 32.)

C : Scale (0. : 4.)

**discussion : **

This procedural component creates a randomized pattern that juxtaposes several predefined patterns. The amplitude, phase and frequency control the contrast, offset and spacing of the resulting pattern.

**parameters : **

A : Amplitude (-2. : 2.)

B : Rotation (-3.14 : 3.14)

C : Offset (-50 : 50)

D : Mutation %

**discussion : **

Lightning is a surface function that creates branching patterns of lines that can evoke lightning or simple tree. For a realistic lightning effect the surface shall be connected to a fractal displacement noise.

'Offset' controls the branch offset and 'Rotation' the branch angle from the father branch. The combination of 'Rotation' and 'Offset' parameters can create various overall shapes. Usually they will be set at opposite signs.

Lightning can be used in ArtMatic Voyager as a sprite or as geographic element to provide the structure of a river canyon system with branching rivers for example.

In 8.08 various flavors for Lightning are available :

**Surface mode (legacy):**

Lines are of infinite lenth.**DF mode:**

Lines are of rendered in DF mode and are clamped at a distance. 'Mutation' controls the spread and fade of the lightning. At zero the lines are infinite and smoother fades are obtained with low 'Mutation' values.**Electric lines :**

Lines are clamped at a distance and shaded to better evoke an electric arc. 'Mutation' works as in DF mode.

**parameters : **

A : Rotation (-2. : 2.)

B : Phase X (-2. : 2.)

C : Phase Y (-2. : 2.)

**discussion : **

Dynamo is a fascinating component whose behavior is impossible to explain and whose formula is quite complex. It has a very non-linear response. The images below are all taken from a simple system whose only changes are to Dynamo's parameters and the zoom level.

**parameters : **

A : Amplitude (0.25 : 2.)

B : Thickness (0. : 2.)

C : Frequency (0.25 : 8.)

**discussion : **

This component generates a zebra stripe pattern. The Amplitude influences the lines' waviness. 'Thickness' determines the lines' thickness and frequency determines the stripe spacing.

**parameters : **

A : Amplitude (0.12 : 2.)

B : Phase (-32. : 32.)

C : Frequency (0.12 : 8.)

**discussion : **

This (non-adaptive) component generates a system of veined lines and is actually the absolute value of fractal noise. It is great for creating marble-like textures.

**parameters : **

A : Size (1./512.) : 4.)

B : Contrast (0. : 4.)

**discussion : **

This variation of the Pict/Movie component creates symmetrically mirrored tiles. For information about all of the Pict/Movie components, see the chapter Using Pictures and Movies.

**parameters : **

A : Size ((1./512.) : 4.)

B : Contrast (0. : 4.)

C : Blur (0. : 1.)

**discussion : **

This variation of the Pict/Movie component creates a blurred version of the input movie/pict. The 'Blur' parameter controls how much blur is applied. Note that the Blurred Pict/Movie component doesn't tile the image.

Gray scale 8 bits images are supported in most file formats. 16 bits images are supported in grayscale PNG format. Blurred Pict/Movie with input in 16 bits is recommended for 3D applications (terrains or DF objects) to minimize pixel sampling artifacts. The blurred buffer is using 16 bits per pixels. Beautiful halo, chrome and other effects can be created with this component. With the higher bit resolution that minimise quantization artefacts **Blurred Pict/Movie** can also be used for 3D bump-mapping and pict-based terrain rendering.

Note that the original AND the blurred (16bits) buffers are kept in memory, so this component may need a lot of memory when using several instances. You may consider to downsize the sources images (lowering resolution has little consequences on the blurred version anyway) when using several images with it.

A color+alpha version is available with the **RGBa Blurred Pict/Movie** component.

To choose an image from the disk and manage inputs learn more at **Image and Movies Inputs**.

Example file:

**parameters : **

A : Size ((1./512.) : 4.)

B : Contrast (0. : 4.)

C : Tiling (0. : 1.)

**discussion : **

This component lets you insert a gray scale picture file or movie into an ArtMatic system. All of the Pict/Movie components have the same A & B parameters (Size and contrast) with a third parameter, C, that varies by component. The 'Size' parameter scales the input. When Size is 1, the input picture will fill the canvas at the default zoom level (set by clicking the **Default view** button). The contrast parameter adjusts the gain of the output values. Use 1 (default) for nominal gain. The 'Tiling' parameter determines the input's tiling. When Tiling is 0, no tiling is done. The larger the Tiling value, the closer together the tiles will be. The 21 versions of this component use a black and white version of the input movie/pict and use the current gradient to color the resulting image. By preceding the tile with space distortion functions, you can warp and distort the image.

For Color images you can use the **23 RGB Pict/Movie** or the
**24 RGBa Pict/Movie** .

To choose an image from the disk learn more at **Image and Movies Inputs**.

Example Files: many examples are provided in the Libraries/ Image Graphic effects & Image Processing.

**parameters : **

A : Amplitude (0. : 1.50)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

**discussion : **

This component generates random noise (like the snow on a television). Unlike Random Squares, this component's output while "noisy" is continuous with smooth transitions between the noise grains. This component is often used as a primitive for generating textures. It is a simpler and faster implementation than **Perlin Noise** but is less perfect as the underlying computation lattice can easily be detected.

**parameters : **

A : Amplitude (0. : 4.)

B : Frequency (0. : 4.)

C : Phase (-32. : 32.)

**discussion : **

This is a low frequency version of "random noise" that is great for creating smoothly changing textures. Starting ArtMatic Engine 8.0 Low freq Random respects the standard **frequency options** settings.

**parameters : **

A : Amplitude (0. : 4.)

B : Level (0. : 2.)

C : Frequency (0. : 32.)

**discussion : **

Perlin noise is the fundamental continuous random noise function in Computer Graphics. It is band limited and provides a great primitive for many textures or textures modulations, as well as pink noise (narrow spectrum noise) for sound applications.

Noise which can yield a variety of surface textures that can resemble stucco or cells in a petri dish and more.
Perlin Noise is equivalent to Multi-Perlin noise with its octaves set to 1.

**parameters : **

A : Amplitude (-12. : 12.)

B : Octaves (1. : 64.)

C : Frequency (0. : 32.)

D : Roughness (0.12 : 0.75)

**discussion : **

This component creates a rich noise by adding "octaves" of Perlin noise with each octave having higher frequencies of the previous one. When the octaves parameter B is at its maximum there are about six layers of noise.

Roughness sets the fractal dimension of the result, which is related to the frequency scaling between each octaves. For a standard fractal surface this is typically set to 0.5 meaning frequencies are doubled for each octaves.

It can be used to create large-scale modulation or rolling plains in ArtMatic Voyager when the frequency is set very low (.01 to .03). Review the introduction topic Frequency Options by **clicking here.**

**parameters : **

A : Amplitude (0. : 8.)

B : Phase (-8. : 8.)

C : Frequency (0. : 32.)

**discussion : **

Bump noise gives the impression of raised and embossed textures - created by the subtraction of one Perlin noise function from another. The generated surface is rougher than the other types of noise.

**parameters : **

A : Amplitude (-4. : 4.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

D : Roughness (0.25 : 0.75)

**discussion : **

The fractal noise component is generated by summing different frequencies of noise. The amplitude of each noise "layer" decreases as its frequency increases with a typical ratio of 1/f where f is the frequency value. Frequencies double between each "layer". Parameter D 'Roughness' controls the overall fractal dimension. The default is 0.5 and corresponds to a doubling of frequencies (and halving of amplitudes) at each noise layer.

This is a very useful noise for creating natural textures and for "texturing" its input. This noise has a certain degree of structure which makes it great for creating marbled textures and clouds and other natural textures. This component is iterative and is sensitive to the Max iterations for fractals preference.

Review the introduction topic Frequency Options by **clicking here.**

**parameters : **

A : Amplitude (0. : 4.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

D : Roughness (0. : 1.)

**discussion : **

2D fractal noise with varying fractal dimension (roughness) created by summing Perlin noise functions at increasing frequencies. "Multi-Fractal" indicates that the fractal dimension (a measure of the surface roughness) changes randomly over the surface -- unlike simple fractals whose fractal dimension is constant. As you can see below the apparent roughness varies unlike Fractal Noise whose roughness is constant. Parameter D 'Roughness' controls the overall fractal dimension. The default is 0.5 and corresponds to a doubling of frequencies (and halving of amplitudes) at each noise layer.

**parameters : **

A : Amplitude (0. : 16.)

B : Smoothness % (0. : 1.)

C : Frequency (0. : 32.)

D : Roughness (0. : 1.) for Cubic ridges and Power cubic ridges

**discussion : **

This component is especially well-suited to creating mountain ranges for ArtMatic Voyager. The Roughness parameter determines the texture of the ground. This is a composite noise function that uses Ridged Fractal Noise for low frequencies (large scale changes) and a Multi-fractal Noise for high frequency content. The result is a rich natural terrain that is more realistic than pure Ridged Fractal Noise.

Review the introduction topic Frequency Options by **clicking here.**

**Square ridges :**

**Cubic ridges :**

**Power cubic ridges :**

**parameters : **

A : Amplitude (0. : 16.)

B : Mutate % (0. : 1.)

C : Frequency (0. : 100.)

D : Roughness (0.12 : 0.75)

**discussion : **

Fractal terrains offers more realistic landscapes primitives than pure fractal noise with erosion simulation. The "Mutate" parameter affects the phase and orientation of erosion patterns while roughness deepens the erosion. 'Roughness' controls the overall fractal dimension. 'Frequency' abides to the standard **frequency options**.

Eroded Canyons Example:

Eroded B Mounts Example:

**Mountain Ranges :**

**Eroded Canyons :**

**Eroded Ranges :**

**Eroded Mounts :**

**Eroded Sparse Canyons :**

**parameters : **

A : Amplitude (0. : 16.)

B : Mutate % (0. : 1.)

C : Frequency (0. : 32.)

D : Roughness (0.12 : 0.88)

**discussion : **

This component supplies a number of fractal and terrain textures. The roughness parameters controls the fractal dimension hence the sensible roughness of the surface.

Review the introduction topic Frequency Options by **clicking here.**

Fractal Power Balanced Example:

**Crystal noise + :**

The Crystal Noise algorithm has sharp edges and is useful both as a surface/texture generator (i.e. when the input is space) or as a mixer. It is a good primitive for mountains or torn paper or granite-like textures. This function only generates positives values.**Orthoquintic noise :**

**Orthoquintic alveolic noise :**

The orthoquintic noises use Quintic interpolated random noise and its derivative. They features a strong orthogonal bias and is great for alien bio-techno looking terrains and textures. The "alveolic" version is sparser and has less orthogonal bias.**Orthoquintic MF noise :**

Multi fractal version of the Quintic interpolated random noise. As with all multi-fractal noises the fractal dimension varies from one place to the other but the average "roughness" is still controllable by the roughness parameter.**Fibrous noise A :**

**Fibrous noise B :**

**Fibrous MF noise :**

**River world MF noise :**

The fibrous noise series uses cubic interpolated random noise and its derivative.**Fractal power balanced :**

The basic Perlin noise is raised to a power from 2 to 6 depending on the mutation value. This creates bumps over a flat areas and makes a good primitive for rocks or grainy textures. The higher the power the sparser the bumps.**Fractal power + :**

Same as above but the noise is passed into an absolute value to yield positive values only.**Multifractal cliffs :**

MultiFractal Cliffs uses a smooth clamp function on the basic Perlin noise to create sharp slope and flat areas.**Multifractal fibers :**

Combines several numerical manipulations to create another variant of fibrous fractals.

**parameters : **

A : Amplitude (0. : 8.)

B : Erosion level (0. : 1.)

C : Frequency (0. : 32.)

D : Roughness (0.25 : 0.75)

**discussion : **

This component is great for creating textures weathered by erosion in ArtMatic Voyager. The textures are smoother than the ridged noise surfaces as if wind and water erosion has worn the surfaces. Eroded Fractal adds "rivers" to a Perlin noise base. The Erosion parameter controls the length and amplitude of the "rivers". The image below is an image of an Eroded Fractal terrain as seen in ArtMatic Voyager.

**parameters : **

A : Amplitude (0. : 8.)

B : Sparseness (0. : 1.)

C : Frequency (0. : 32.)

D : Roughness (0.25 : 0.75)

**discussion : **

This component is great for creating irregularly spaced rocks/mounds/hills (depending on the surface amplitude). The Sparseness parameter determines the density of the features. Sparse fractal noise is a useful primitive for simulating dust and scratches in ArtMatic textures or to add fine rock details in an ArtMatic Voyager landscape. It has been modified in ArtMatic Engine 8 so the first few octaves of the noise are less "perlin noise" like by using voronoi patterns to shape the largest rock.

Sparsely Spaced Fractal Rocks Example:

**parameters : **

A : Amplitude (0. : 16.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

D : Roughness (0.25 : 0.75)

**discussion : **

Clusters of stones with varying stone sizes and amount. This component is great for creating clusters of variously-sized terrain based stones for ArtMatic Voyager.

'Frequency' abides to the standard **frequency options** while 'Roughness' controls fractal dimension.

**parameters : **

A : Amplitude (0. : 4.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

D : Roughness (0.25 : 0.75)

**discussion : **

This component adds lunar-like rocks to ArtMatic Voyager surfaces. This is a multi-fractal noise with added sparse bump clusters. It is more natural looking than standard fractal noise with varying degrees of roughness and bumps that tend to occur in clusters.

**parameters : **

A : Amplitude (0. : 4.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

D : Roughness (0.25 : 0.75)

**discussion : **

A Multi fractal noise where fine details and rougher textures tend to fill the lower elevation of larger-scale elements. This component is frequently used in ArtMatic Voyager to create irregular bubble-shaped mounds and rocks.

**parameters : **

A : Amplitude (0. : 4.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

D : Roughness (0.25 : 0.75)

**discussion : **

A skewed and quasi-orthogonal fractal noise function great for creating stratified ArtMatic Voyager terrains. 'Frequency' abides to the standard **frequency options**.

**parameters : **

A : Amplitude (-4. : 4.)

B : Octaves (1. : 128.)

C : Frequency (0. : 32.)

D : Roughness (0.25 : 0.75)

**discussion : **

Ridged Noise is similar to the Multi Perlin Noise function but uses ridged Perlin noise function as its basis. This component is great for adding ridged contours to systems used with ArtMatic Voyager. The Octaves controls the number of layers of ridges. The "ridges" are obtained passing a perlin noise through an inverted absolute value filter (1-abs(n)). Result is then squared to achieve smoother "valleys". Ridged Noise is great as a base for irregular dunes or mountains. 'Frequency' abides to the standard **frequency options**.

Each successive octave is at a higher frequency with a lower amplitude:

Ridged Noise with about octaves=4 can be a good starting point for dunes. When the amplitude is negative it looks more like round stone clusters as shown below:

**parameters : **

A : Amplitude (-10. : 10.)

B : Level or Mutation % (0. : 1.)

C : Frequency (0. : 32.)

**discussion : **

Bubble and skins offers various procedural noises on a continuous implementation of the voronoi noise.

'Frequency' abides to the standard **frequency options** while 'Amplitude' controls the elevation heights.
Voronoi Skin B Example:

**Bubbles Voronoi :****Smooth Voronoi :****Voronoi Skin A :****Voronoi Skin B :**

Implements variations of a smooth 2D Voronoi texture. While Smooth and Bubble Voronoi renders the distance field directly the others flatten the edges of each cells.

**Voronoi Scales 45 :**

Each voronoi cell has a slanted plane at 45°.**Voronoi Disks :**

Each voronoi cell is rendered with a randomly oriented disk.**Voronoi Fur :**

Each voronoi cell is rendered with a randomised rounded cone to evoke a fur like texture.**Power Voronoi :**

Each voronoi cell is rendered with as a power raised bump either negative or positive. It creates a smoothable spongeous texture nice for corals or organic skins.**Mutation Faults :**

Each 2D voronoi cell is rendered as (hollow) line segment whose orientation depends on the 'Mutation' parameter. At minimum the segments are oriented vertically, and at maximum they will be randomly oriented. With high smoothing values the function can also be used to render terrains or sculpt DF objects.

**Voronoi splits :**

Split each voronoi cell into 2 or 3 regions oriented randomly. The 'Mutation' parameter controls the probability to have a 3 split rather than 2 and changes the random rotation. There is a 3D version in the**3D Bubble & skins**tile.

**Voronoi density :**

The 'Mutation' parameter controls the density probability and slightly changes the random rotation. At zero 'Mutation' the voronoi cells are mostly zero.

**Voronoi density**can be used to create rocks, terrain as well as a less regular voronoi skin.

*Voronoi density rocks with low density rendered in ArtMatic Voyager*

**Random dir bumps :**

Overlap of directional bumps. Parameter B 'Mutation' changes the direction of the slope in each bump. At minimum they will strongly be oriented horizontally, vertically at maximum, and randomly in the middle. The noise will have strong directional bias when mutation is away from 0.5 and has an organic look reminiscent of reaction-diffusion algorithms. A full 3D implementation is available in the**3D Bubble & skins**tile.

**Density power dots :**(8.07)

Each voronoi cell is rendered with a power raised bump. Bumps are raised from squared to power 8 randomly. The density of bumps is controlled by the Mutations parameter. When amplitude is negative tt creates a smooth spongeous texture nice for corals or organic skins.

**Density star lights :**(8.07)

This algorithm provides a less homogenous and more realistic stars background 2D noise. Lights halo fades according to the inverse distance to the center. Parameter 'Mutations' controls the stars density. It can be used also to creates various sized spikes on a surface.

The function is available in 3D as well in the**3D Bubble & skins**component.

**parameters : **

A : Amplitude (0. : 8.)

B : Phase (-32. : 32.)

C : Frequency (0. : 32.)

**discussion : **

This component creates a Voronoi cellular elevation texture. Cellular is often used in conjunction with the Smooth Floor filter component (with the roof parameter set near 1) to flatten the "cells" so they look like cracks in the ground:

**parameters : **

A : Amplitude (0.12 : 8.)

B : Phase (-32. : 32.)

C : Frequency (0.03 : 8.)

**discussion : **

Craters is an elevation texture function generally used to create realistic craters when creating planet-like terrains. 'Frequency' abides to the standard **frequency options** while 'Amplitude' controls the elevation heights.

**parameters : **

A : Amplitude (-16. : 16.)

B : Displacement (0. : 1.)

C : Frequency (0. : 16.)

**discussion : **

Volcanoes is an elevation function generally used to add randomly placed volcanoes when creating planet-like terrains. 'Frequency' abides to the standard **frequency options** while 'Amplitude' controls the elevation heights. Negative 'Amplitude' will make volcanoes become holes or lakes in the terrain.

**parameters : **

A : Scale 0:1

B : Iterations

**discussion : **

Compiled trees are groups of tiles that can be used in place of single tiles as a kind of macro or subroutine. 21 CTs can be seen as scalar valued 2D function of the form F(x,y), that is surfaces, and are usually used to generate complex scalar or colored terrains when the output is a packed RGBA stream. Entire planets with various color-textured terrains can be described with a set of 21 RGBA CTs mixed together with a 34 Packed_random_Mix for example.

**usage : **

Select a 21 tile and use "**New compiled tree**" to create a new CT from the selection (**Tree Edit** menu or type 'n' key).

To save a CT on disk to use the function elsewhere use "**Save compiled tree**" from the **Tree Edit** menu.

You may also copy and paste the entire CT by using **Copy Tile** and **Paste Tile** from the **Edit** menu.

You may iterate the tree by "Iterations" number when the tree contains an Iterations tile to modify and accumulates various values. "Scale" provide an optional scaling of outputs and is set at 1 by default (no scaling).