## //----------------------------// 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)
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

## Introduction

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"

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.

## 21 Math tools #

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.

algorithms :
• 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.

## 21 S:P Maths #

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.

algorithms :
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.
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

## 21 Ax+By+C

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.

## 21 Interpolate

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.

algorithms :
• 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.

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

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.

## 21 Distance

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.

## 21 Distance squared

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)

## 21 Line

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.

algorithms :
• 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.

## 21 Gaussian Dot

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.

## 21 Profile Shapes #

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 : Libraries/Graphic Design/Flower Marble Marquetry.artm

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 .

algorithms :
• 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-.

• 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.

## 21 DF Curves #

parameters :
A : Frequency (0. : 4.)
B : Mutation % (0. : 1.)
C : Level (0. : 2.)
D : Algorithm dependent

algorithms :
• 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,
• 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

## 21 Elevation Shapes #

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.

algorithms :
• 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:

## 21 Distance*(x + y)

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.

## 21 Min <-> Max

parameters :
A : Amplitude (-2. : 2.)
B : Min to Max (0. : 1.)
C : Smoothness % (0. : 32.)

## 21 Logic tools #

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.

algorithms :
• 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 in Libraries/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.

## 21 S:P Logic & Profiles #

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.

algorithms :
• 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.

## 21 Grid

parameters :
A : Period (1/Freq) (0.02 : 50.)
B : Scale Y (0.06 : 16.)
C : Contrast % (0. : 100.)
D : Width % (0. : 1.)

algorithms :
• White lines :
• Black lines :
• DF lines :
• Neon lines :
• Legacy :

## 21 Hexagons

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.

## 21 Grids #

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 Libraries/Components demo/Tiles Sizes Match 45 to see how various tilings, mirror spaces and grids can be used together.

algorithms :
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 :

## 21 Orbit Analyzer

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: Libraries/Fractals/OrbitsAN Newton Z3:2Z2 #dot+et
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:

algorithms :
• 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.

## 21 Sines #

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.

algorithms :
• 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

## 21 Circles

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.

## 21 Random Cones

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.

## 21 Star Field

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.

## 21 Ripples #

parameters :
A : Amplitude (0. : 8.)
B : Phase (-32. : 32.)
C : Frequency (0. : 16.)
D : Ripples (0. : 1.)

algorithms :
• 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.
Ripples are generated on a regular grid and mixed additively with negatives values allowed. The 'Ripples' parameter controls ripples frequencies.
Ripples are generated randomly and mixed additively. The 'Ripples' parameter controls both ripples density and ripples sines frequencies.

## 21 Facet

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.

## 21 Random Squares

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.

## 21 DF Patterns #

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).

algorithms :
• 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.

## 21 DF Waves #

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 : Libraries/Components demo/DFwaves

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.

algorithms :
• 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.

## 21 Tech Noise #

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.

algorithms :
• 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 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 :

## 21 Pyramids #

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.

algorithms :
• 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.

## 21 Circuitry

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.

## 21 ZigZag

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.

## 21 Maze

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.

## 21 Smooth Entrelas

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.

## 21 Lightning

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 :

algorithms :
• 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.

## 21 Dynamo

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.

## 21 Zebra noise

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.

## 21 Fractal Lines

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.

## 21 Pict/Movie SymTiled

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.

## 21 Blurred Pict/Movie

parameters :
A : Size ((1./512.) : 4.)
B : Contrast (0. : 4.)
C : Blur (0. : 1.)

## 21 Pict/Movie

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.

## 21 Random Noise

parameters :
A : Amplitude (0. : 1.50)
B : Phase (-32. : 32.)
C : Frequency (0. : 32.)

## 21 Low Freq Noise

parameters :
A : Amplitude (0. : 4.)
B : Frequency (0. : 4.)
C : Phase (-32. : 32.)

## 21 Perlin Noise

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.

## 21 Multi Perlin noise

parameters :
A : Amplitude (-12. : 12.)
B : Octaves (1. : 64.)
C : Frequency (0. : 32.)
D : Roughness (0.12 : 0.75)

## 21 Bump Noise

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.

## 21 Fractal Noise

parameters :
A : Amplitude (-4. : 4.)
B : Phase (-32. : 32.)
C : Frequency (0. : 32.)
D : Roughness (0.25 : 0.75)

## 21 MultiFractal Noise

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.

## 21 Ridged Fractal Noise

parameters :
A : Amplitude (0. : 16.)
B : Smoothness % (0. : 1.)
C : Frequency (0. : 32.)
D : Roughness (0. : 1.) for Cubic ridges and Power cubic ridges

algorithms :
• Square ridges :
• Cubic ridges :
• Power cubic ridges :

## 21 Fractal Terrains #

parameters :
A : Amplitude (0. : 16.)
B : Mutate % (0. : 1.)
C : Frequency (0. : 100.)
D : Roughness (0.12 : 0.75)

algorithms :
• Mountain Ranges :
• Eroded Canyons :
• Eroded Ranges :
• Eroded Mounts :
• Eroded Sparse Canyons :

## 21 Fractal Noises #

parameters :
A : Amplitude (0. : 16.)
B : Mutate % (0. : 1.)
C : Frequency (0. : 32.)
D : Roughness (0.12 : 0.88)

algorithms :
• 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.

## 21 Eroded Fractal

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.

## 21 Sparse fractal rocks

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:

## 21 Stone Clusters

parameters :
A : Amplitude (0. : 16.)
B : Phase (-32. : 32.)
C : Frequency (0. : 32.)
D : Roughness (0.25 : 0.75)

## 21 Lunar rocks

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.

## 21 Bubble rocks

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.

## 21 Stratified rocks

parameters :
A : Amplitude (0. : 4.)
B : Phase (-32. : 32.)
C : Frequency (0. : 32.)
D : Roughness (0.25 : 0.75)

## 21 Ridged noise

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:

## 21 Bubble & Skins #

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:

algorithms :
• 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.

## 21 Cellular

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:

## 21 Craters

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.

## 21 Volcanoes

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.

## 21 Compiled Tree :

parameters :
A : Scale 0:1
B : Iterations

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).