//----------------------------//
ArtMatic 2 in 1 out components
//----------------------------//

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.

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

21 Math tools #

ArtMatic script function :Maths

parameters :
No parameters.

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 :
  script call : Maths.sub
  Direct x minus y, no parameters.
  
• y-x :
  script call : Maths.nsub
  Direct y minus x, no parameters.
  
• mul:
  script call : Maths.mul
  Direct x*y, no parameters.
  
• positive mul:
  script call : Maths.pmul
  Direct x*y clamped to zero : MAX(x*y,0). no parameters.
  
• div x/y :
  script call : Maths.div
  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 :
  script call : Maths.idiv
  returns y/x. Warning : this generates infinity when x is zero.
  
• power x^y :
  script call : Maths.powerxy
  Returns x to power y
  
• x *sign(y) :
  script call : Maths.ysign
  Returns x multiplied by sign of y. That is x turns to -x whenever y becomes negative.
  


• atan(y/x) :
  script call : Maths.atanxy
  Angle of x,y with OX in -0.5Π + 0.5Π
  
• atan(x/y) :
  script call : Maths.atanyx
  Angle of x,y with OY in -0.5Π + 0.5Π
  
• angle(x y) (O-2Pi) :
  script call : Maths.angle
  
• dist(x y) :
  script call : Maths.dist
  Euclidian distance : square root of x squared + y squared.
  atan(y/x) but scales the result to go from O-2Π
  
• 1/dist :
  script call : Maths.idist
  Inverse of euclidian distance, goes to infinity at zero.
  
• 0.5/(dist+1/16) :
  script call : Maths.halfidist
  Half inverse dist with offset to avoid infinity.
  
• blend y on low :
  script call : Maths.blendylow
  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 :
  script call : Maths.blendyhigh
  A procedural blend that blends y with x when x is high.
  
• blend x*y on low :
  script call : Maths.blendxylow
  A procedural blend that blends x*y with x when x is low.
  
• blend x*y on high :
  script call : Maths.blendxyhigh
  A procedural blend that blends x*y with x when x is high.
  
• morph log(e^x + e^y) :
  script call : Maths.morph
  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)) :
  script call : Maths.box
  A function that creates a square based (4*4) pyramid whose sides vanish to infinity.
  
• roofed min (4-abs(x) 4-abs(y)):
  script call : Maths.rbox
  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:
  script call : Maths.xlogxdy
  


• min :
  script call : Maths.min
  A straight MIN function without parameters and smoothing that computes faster than the minmax component.
  
• max :
  script call : Maths.max
  A straight MAX function without parameters and smoothing that computes faster than the minmax component.
  
• max+x :
  script call : Maths.maxpx
  Algorithm MAX(x,y)+x
  
• max-x :
  script call : Maths.maxmx
  Algorithm MAX(x,y)-x
  
• max-y :
  script call : Maths.maxmy
  Algorithm MAX(x,y)-y
  
• min+x :
  script call : Maths.minpx
  Algorithm MIN(x,y)+x
  
• min+y :
  script call : Maths.minpy
  Algorithm MIN(x,y)+y
  


• iteration smooth max:
  script call : Maths.smax
  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:
  script call : Maths.iterationscale
  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.
  

• Add:
  script call : SP_Maths.add
  Addition of scalar or vector data.
  
• Blend:
  script call : SP_Maths.mix
  Linear interpolation of scalar or vector data.
  
• Subtract (X-Y):
  script call : SP_Maths.sub
  Subtraction of scalar or vector data. For RGB unpacked output use 23 Packed Vector Maths #
  
• Difference |X-Y|:
  script call : SP_Maths.diff
  Absolute value of difference. For RGB unpacked output use 23 Packed Vector Maths #
  
• Multiply:
  script call : SP_Maths.mul
  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 (pack4 only):
  script call : SP_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 (pack4 only):
  script call : SP_Maths.DFdivide
  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 :
  return cross product of v1 x v2
• Dot Product :
  return the dot product v1 . v2
• Length :
  return euclidian dist of v1 - v2.
• Squared length :
  return euclidian squared dist of v1-v2.

ArtMatic script function :Affine

parameters :
A : Scale X (-16.0 : 16.0) E9 options
B : Scale Y (-16.0 : 16.0) E9 options
C : Add (-16.0 : 16.0) E9 options

discussion :
This Affine function is used to sum 3 input values.
Ax + By + C is essentially a line 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.
Starting E9 it can accept Packed RGB or RGBA inputs. In that case the output will be packed as well.
In the ArtMatic script language expressions like 3*X+4*Y+2 will map to this component.

Formula: Ax + By + C

ArtMatic script function :Multiply

parameters :
A : Offset x (-10.0 : 10.0) E9 options
B : Offset y (-10.0 : 10.0) E9 options
C : Add (-10.0 : 10.0) E9 options

discussion :
Multiplies the translated inputs and adds C (available E9). 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 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.

If you need a faster straight multiply use 21 Math tools# "mul" that just returns x*y.

ArtMatic script function :Distance

parameters :
A : Offset x (-10.0 : 10.0) E9 options
B : Offset y (-10.0 : 10.0) E9 options
C : Amplitude (-16.0 : 16.0) E9 options
D : Offset (-10.0 : 10.0) E9 options

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. Starting E9 an additional offset can adjust the result level.
formula : C*sqrt((x+A)^2 +(y+A)^2).

If you need a faster straight distance use 21 Math tools# "dist(x y)" that just returns length(x,y).

ArtMatic script function :Profile_Shapes

parameters :
A : Radius (0.0 : 64.0) E9 options
B : Width % (-1.0 : 10.0) E9 options
C : Height % (-1.0 : 10.0) E9 options
D : Curvature/Smooth % (0.0 : 1.0)

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 .

Script example: create a volume by intersecting 2 profiles
vec3 va =rotate(X,Y,Z);
vec1 fb = Profile_Shapes.disk(va.z,va.y); //zy plane
vec1 fc = Profile_Shapes.pentagon(va.x,va.y); //xy plane
vec1 fout1 = min(fc,fb);

• Lozenge:
  script call : Profile_Shapes.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:
  script call : Profile_Shapes.triangle
  
• Rectangle:
  script call : Profile_Shapes.rectangle
  
• Pentagon:
  script call : Profile_Shapes.pentagon
  
• Hexagon:
  script call : Profile_Shapes.hexagon
  
• Octagon:
  script call : Profile_Shapes.octagon
  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:
  script call : Profile_Shapes.arcade
  
• Disk:
  script call : Profile_Shapes.disk
  
• Gothic Arch:
  script call : Profile_Shapes.gothic_arch
  
• Persian Arch:
  script call : Profile_Shapes.persian_arch
  
• Horseshoe Arch:
  script call : Profile_Shapes.horseshoe_arch
  
• Pointed Horseshoe Arch:
  script call : Profile_Shapes.pointed_horseshoe_arch
  
• Trefoil Arch:
  script call : Profile_Shapes.trefoil_arch
  They provides basic architectural Arches DF shapes :
  
  
  
  
  
• Column concave:
  script call : Profile_Shapes.column_concave
  
• Column classic:
  script call : Profile_Shapes.column_classic
  
• Column greek:
  script call : Profile_Shapes.column_greek
  
• Column Scifi:
  script call : Profile_Shapes.column_scifi
  They provides basic architectural Arches DF shapes :
  
  
  
  
  
• Stairs 4 iy-:
  script call : Profile_Shapes.stairs_4iy
  
• Stairs inf ixy-:
  script call : Profile_Shapes.stairs_infix_y
  
• Dome:
  script call : Profile_Shapes.dome
  
• Pointed Dome:
  script call : Profile_Shapes.pointed_dome
  
• Dome Russian:
  script call : Profile_Shapes.dome_russian
  
• Power Dome:
  script call : Profile_Shapes.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:
  Possible options variations : infinite in x+ (fill), default (mirror x), infinite in x+ and y-
  
  
  
  
  
• Roof A ix-:
  script call : Profile_Shapes.roof_aix
  Architectural DF shapes useful for roof
  
• Roof B ix-:
  script call : Profile_Shapes.roof_bix
  Architectural DF shapes useful for roof
  
• Saucer:
  script call : Profile_Shapes.saucer
  
  
  
  
  
  
• Wall classic :
  script call : Profile_Shapes.wall_classic
  
• Wall classic roof 30:
  script call : Profile_Shapes.wall_classic_roof_30
  
• Wall classic roof 45:
  script call : Profile_Shapes.wall_classic_roof_45
  
• Wall stones:
  script call : Profile_Shapes.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:
  script call : Profile_Shapes.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 :
  script call : Profile_Shapes.framed_box
  Framed box features some edges at the corners. Framed box options are infinite in x+ (fill) and default (mirror x).
  
• Chisel Rect :
  script call : Profile_Shapes.chisel_box
  A rectangle with chiseled edges. Chisel Rect has the same options as the other polygons.
  
  
  
  
  
• Chisel Cross:
  script call : Profile_Shapes.chisel_cross
  A cross with chiseled edges. Chisel Cross has the same options as the other polygons.
  
  
  
  
  

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:
  script call : DFCurves.pwarch
  A power 2 infinite curve DF profile. 'Phase' can offset the curve in x.
  
• Power arch curve:
  script call : DFCurves.pwarch_curve
  A power 2 infinite DF curve
  
• Cubic disc profile:
  script call : DFCurves.cubic
  
• Cubic curve:
  script call : DFCurves.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:
  script call : DFCurves.exp
  
• Exp curve:
  script call : DFCurves.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:
  script call : DFCurves.spiral
  A linear growing spiral. 'Mutation' controls the length of the spiral.
  
  
  Spiral sweep with Exp curve
  
  
  
• Archimedes Spiral:
  script call : DFCurves.archimedes_spiral
  A power 2 growing spiral. 'Mutation' controls length of the spiral.
  
• Ellipse segment Y:
  script call : DFCurves.ellipse_sy
  '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.
  
• Ellipse segment X:
  script call : DFCurves.ellipse_sx
  
• Wide U:
  script call : DFCurves.wide
  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:
  script call : DFCurves.arc_segment
  A circular arc segment growing counter-clockwise with parameter 'Mutation'
  
• Infinity loop:
  script call : DFCurves.inf_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:
  script call : DFCurves.heart_curve
  Heart shaped curve.
  
• Dot Spiral:
  script call : DFCurves.dot_spiral
  
• Line Spiral:
  script call : DFCurves.line_spiral
  
• Radial line Spiral:
  script call : DFCurves.radial_spiral
  
• Morphed dot Spiral:
  script call : DFCurves.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:
  script call : DFCurves.bottle
  A simple Bottle shaped curve. Parameter B & D can mutate the shape of the bottle. Parameter "level" adjust the width of the curve and the shape has no inside or outside.
  Bottle is often used with a revolution profile (pass a xz disk in x or use the Revolution & Sweeps #
  component) to create a full 3D standing bottle object.
  
• Vase:
  script call : DFCurves.vase
  A simple Vase shaped curve. Parameter B controls the width while Parameter D the height of the Vase. As with Bottle, this shape is often used with a revolution profile to obtain a full 3D Vase.
  
  
• Wine glass :
  script call : DFCurves.glass
  A wine glass shaped curve. Parameter B controls the width while Parameter D the height. As with Bottle, this shape is often used with a revolution profile to obtain a full 3D glass.
  
  
• Champaign glass:
  script call : DFCurves.chglass
  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
  
  
  
• Convex tower:
  script call : DFCurves.stand
  
  provides a convex open curve. Parameter "level" adjust the width of the curve and the shape has no inside or outside.
  
  
• Mushroom tower:
  script call : DFCurves.stand2
  provides a convex curve closed by an arc evoking a mushroom shape. Parameter "level" adjust the width of the curve and the shape has no inside or outside.
  
• Petal:
  script call : DFCurves.petale
  A "petal" closed curve shape where mutation controls the angles and amount of pointed sides. When mutation is 0 the shape is pointed downward and upward at 1. Parameter "level" allows to adjust the distance field level and Level 1 is nominal. Petal can be used with rotation symmetries to build flowers or as a primitive for plants, space ships or architecture design.
  Introduced in Engine 8.5
  
  
  Petals and Pointed Arch with 9fold symmetries
  Example in ArtMatic Designer CTX/Libraries/Component 8.5/Geometry/Indian Flower.artm
  
  
• Dome tower:
  script call : DFCurves.dome_tower
  Dome tower provides a more accurate DF than Profile Shapes # 'Dome' when the curvature is high and should be used instead. The dome pillar is infinite in y- and negatives disks shapes the blending between the dome and the pillar. Parameter "level" allows to adjust the distance field level. Level 1 is nominal, other values will thin or expand the pillar radius. Dome tower is a bit similar to Mushroom tower in shape but has an inside and is infinite in y-. It is often to be used with a revolution profile to get a full 3D volume of revolution.
  Introduced in Engine 8.5
  
  Textured Dome tower using revolution sweep
  Example in Voyager CTX/Voyager Examples/Components/DF PathSweeps/SciFi Dome.vy
  
  
• Pointed Arch:
  script call : DFCurves.pointed_arch
  Pointed Arch, introduced in Engine 8.5, provides a persian/indian arch with mutation controlling the slope of the central spike. The shape is infinite in y-; Parameter "level" allows to adjust the distance field level and Level 1 is nominal. Higher level than 1 will make the spike of the arch more obvious. Pointed Arch can be used to carve an oriental door in architectural designs or for decorative designs in 2D.
  
• B-Ellipse:
  script call : DFCurves.ellipse
  B-Ellipse, introduced in Engine 8.5, provides a true 2D DF ellipse based on bezier curve DF solver and can be used to get a non-spherical dome shape. Mutation parameters controls the radius ratio between x & y. Parameter "level" allows to adjust the distance field level. Level 1 is nominal, smaller values will tend to make the smaller radius side less round. B-Ellipse shall be used with a simple sweep or a revolution profile or to get a full 3D volume. It is a very useful primitive for all sorts of objects from life forms to sci-fi space ships to usual objects and architectural design.
  
  
  Textured B ellipse using revolution sweep
  Example in Voyager CTX/Voyager Examples/Components/DF PathSweeps/SciFi B_ellipse.vy
  
  

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

ArtMatic script function :Logic_tools

parameters :
A : Blend x<->y (0.0 : 1.0) E9 options
B : Blend min/max (-2.0 : 2.0)
C : Smoothness % (0.0 : 50.0)

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) :
  script call : Logic_tools.weighted_union
  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) :
  script call : Logic_tools.max_n_blend
  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) :
  script call : Logic_tools.min_n_blend
  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):
  script call : Logic_tools.intersect
  Returns the intersection of x & y. (Logical AND)
  
  
  
  
  
• Subtract min(x,-y):
  script call : Logic_tools.subtract
  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) :
  script call : Logic_tools.intersect_abs
  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):
  script call : Logic_tools.manhattan
  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):
  script call : Logic_tools.contours
  Perform an union of the contours of both inputs shapes. The 'Thickness' parameter will adjust the size of the both contours.
  
  
  
  
  
• Chisel union :
  script call : Logic_tools.chisel_max
  
• Chisel intersect :
  script call : Logic_tools.chisel_min
  
• Chisel subtract :
  script call : Logic_tools.chisel_sub
  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 :
  script call : Logic_tools.subtract_y
  Returns the logical x -y and optionally morph with x if parameter "Blend" is <1.
  
• Subtract x & blend y :
  script call : Logic_tools.subtract_x
  Returns the logical y-x and optionally morph with x if parameter "Blend" is <1.
  
  
  
• Repulsive union:
  script call : Logic_tools.repulsive_union
  
• Ripple union:
  script call : Logic_tools.ripple_union
  
• Sym Ripple union:
  script call : Logic_tools.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:
  script call : Logic_tools.ripple_subtract
  
• Framed subtract:
  script call : Logic_tools.framed_subtract
  
• Partial subtract:
  script call : Logic_tools.partial_subtract
  Partially subtract B from A. This mostly subtracts B's outline from A leaving a core with A's contour.
  
• Edged union:
  script call : Logic_tools.edged_union
  
• Edged intersect:
  script call : Logic_tools.edged_intersect
  
• Edged subtract:
  script call : Logic_tools.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:
  script call : Logic_tools.cubic_s_union
  
• Cubic smooth intersect:
  script call : Logic_tools.cubic_s_inter
  
• Cubic smooth subtract:
  script call : Logic_tools.cubic_s_subtract
  Perform the main logical function (union, intersection and subtraction) using a cubic spline to smooth the edges of the logical operation.
  
  
  
• Bump intersect:
  script call : Logic_tools.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):
  script call : Logic_tools.underlay
  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):
  script call : Logic_tools.overlay
  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 :
  script call : Logic_tools.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 :
  script call : Logic_tools.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:
  script call : Logic_tools.minus_xor
  Uses the negative of the Xor logical operation.
  
  
  
  
  

ArtMatic script function :SP_Logic

parameters :
A : Offset y (-10.0 : 10.0) E9 options
C : Morph with x (0.0 : 25.0) E9 options
D : Smoothness % (0.0 : 20.0) E9 options

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.

3 new functions were added in 1.5 to facilitate texturing of DF primitives.

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.

• Union (max):
  script call : SP_Logic.max
  Implement the standard logical Union function. See 21 Logic tools #
  This algorithm has the 'Morph with x' parameter.
  
• Intersect (min):
  script call : SP_Logic.min
  The standard logical Intersect function with the extra 'Morph with x' parameter.
  
  
• Subtract (min-y):
  script call : SP_Logic.sub
  The standard logical Subtract function with the extra 'Morph with x' parameter.
  
  
• Chisel union:
  script call : SP_Logic.chmax
  
• Chisel intersect:
  script call : SP_Logic.chmin
  
• Chisel subtract:
  script call : SP_Logic.chsub
  Perform the main logical function with chiseled corners. "chisel offset" parameter sets the width of the chiseling.
  
  
• Edged union:
  script call : SP_Logic.emax
  
• Edged intersect:
  script call : SP_Logic.emin
  
• Edged subtract:
  script call : SP_Logic.esub
  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:
  script call : SP_Logic.dmax
  
• Arc intersect:
  script call : SP_Logic.dmin
  
• Arc subtract:
  script call : SP_Logic.dsub
  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:
  script call : SP_Logic.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:
  script call : SP_Logic.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:
  script call : SP_Logic.bump
  Adds a bump to x at the y zero crossing using spread - ABS(y)
  
• Chisel displace:
  script call : SP_Logic.choffset
  
• Chisel dent:
  script call : SP_Logic.chdent
  
• Chisel bump:
  script call : SP_Logic.chbump
  Same as "displace", "dent" & "bump" but using a 45 degree slope for the displacement.
  
• Circle displace:
  script call : SP_Logic.circle
  
• Circle dent:
  script call : SP_Logic.circledent
  
• Circle bump:
  script call : SP_Logic.circlebump
  Same as "displace" but a disk profile is used for the displacement.
  
• Union -y:
  script call : SP_Logic.unionneg
  
• Chisel Union -y:
  script call : SP_Logic.chunionneg
  
• Edged Union -y:
  script call : SP_Logic.eunionneg
  Union with the inverse of Y. When using Chisel & Edge the edges of the union are either chiseled or given and edge.
  
• Texture displace:
  script call : SP_Logic.texturedisplace
  The packed RGBA DF texture should be connected to Y (input 2). The DF of the texture is used to modulate the surface level of the object passed in X (input 1). Original shape and colors of object X are conserved when texture is negative unlike Texture Intersect. The "Texture blend" parameter blends with the texture the parts were X wins. When "Texture blend" is at maximum colors are completely determined by Y.
  
• Texture Intersect:
  script call : SP_Logic.textureintersect
  The packed RGBA DF texture should be connected to Y (input 2). Negatives (spaces) of the texture completely carves the object X volume. The "Texture blend" parameter blends with the texture the parts were X wins. When "Texture blend" is at maximum colors are completely determined by Y. "Feather adjust" adjust the level where colors from Y are blended.
  
• Fuzzy Intersect:
  script call : SP_Logic.fuzzyintersect
  The packed RGBA DF texture should be connected to input B. The range parameter sets how far the DF of the texture will expand around the object boundaries. Negatives (spaces) of the texture completely carves the object volume. The "level adjust" parameter adjust the DF level of the Y texture. Fuzzy Intersect is similar to the 24 Packed logic Fuzzy Intersect.
  
  

ArtMatic script function :Grid

parameters :
A : Frequency (0.0 : 50.0) E9 options
B : Scale Y (0.062 : 16.0)
C : Contrast % (0.0 : 100.0)
D : Width % (0.0 : 1.0)

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. For consistency in E9 the Period parameter became "freq" with default option to 1/value. The scale Y parameter determine the aspect ratio 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:
  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.
  


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

ArtMatic script function :Hexagons

parameters :
A : Amplitude (0.0 : 8.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 8.0) E9 options

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.

ArtMatic script function :Grids

parameters :
A : Contrast % (0.0 : 100.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 32.0) E9 options
D : Width % (0.0 : 1.0)

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.

• Radius 1 square grid:
  script call : Grids.unit_square
  Unit square grid.
  
• Square 45° grid:
  script call : Grids.squarefourtyfive
  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:
  script call : Grids.legacy
  
• Hexagons & triangles grid:
  script call : Grids.hexagons_triangles
  
• Triangles grid:
  script call : Grids.triangles
  
• Lozenges grid:
  script call : Grids.Lozenges
  
• Hexagons dual grid:
  script call : Grids.hexagons_dual
  
• Hexagons grid:
  script call : Grids.hexagons
  
• Hexagons & squares & triangles grid:
  script call : Grids.hexagons_mix
  

ArtMatic script function :OrbitAnalyzer

parameters :
A : Amplitude (0.1 : 16.0) E9 options
B : Trap radius (0.2 : 8.0)

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 boundaries 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 analyzer 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:

• Total distance:
  script call : OrbitAnalyzer.distance
  Sums and scale the distance between each consecutive points of the orbit.
  
• Max velocity:
  script call : OrbitAnalyzer.max_velocity
  Returns the maximum velocity (distance between each consecutive points).
  
• Min velocity:
  script call : OrbitAnalyzer.min_velocity
  Returns the minimum velocity (distance between each consecutive points).
  
• Escape Time:
  script call : OrbitAnalyzer.escape_time
  Returns the time it takes to escape the given radius set by 'Escape Radius' parameter A.
  
• Escape Time log:
  script call : OrbitAnalyzer.escape_timelog
  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 fractal.
  
• Max magnitude :
  script call : OrbitAnalyzer.max_magnitude
  Returns the maximum magnitude (distance from zero).
  
• Disk orbit trap :
  script call : OrbitAnalyzer.disk_orbittrap
  Traps the orbits with a zero centered disk of the given 'Trap radius'.
  
• x axis orbit trap :
  script call : OrbitAnalyzer.x_orbittrap
  Traps the orbits with the x line of the given 'Trap radius'
  
• y axis orbit trap :
  script call : OrbitAnalyzer.y_orbittrap
  Traps the orbits with the y line of the given 'Trap radius'.
  
• xy axis orbit trap :
  script call : OrbitAnalyzer.xy_orbittrap
  Traps the orbits with both.
  
• Escape dot :
  script call : OrbitAnalyzer.dot_escape_
  Returns the dot product of the last orbit direction with a given 'Direction'.
  
• Dot average :
  script call : OrbitAnalyzer.dot_average
  Integrates the dot product of all orbit directions with a given 'Direction'.
  Example: Libraries/Fractals/OA FerroMagnetModel.artm
  
  
• x average :
  script call : OrbitAnalyzer.x_average
  Weighted sum of positive x values. Example: Libraries/Fractals/OA\ PolyJuliaSets.artm
  
  
• y average :
  script call : OrbitAnalyzer.y_average
  Weighted sum of positive y values.
  
• Gaussian zone trap:
  script call : OrbitAnalyzer.gaussian_zone
  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:
  script call : OrbitAnalyzer.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:
  script call : OrbitAnalyzer.escape_angle
  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 basins of attraction various colors while visualising the escaping zones. Example: Libraries/Fractals 8.08/OAN Dragon Eangle.artm
  
  
• Orbit angle:
  script call : OrbitAnalyzer.orbit_angle
  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:
  script call : OrbitAnalyzer.instant_velocity_log
  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:
  script call : OrbitAnalyzer.instant_acceleration
  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:
  script call : OrbitAnalyzer.vorticity_estimate
  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.
  
• Instant vorticity:
  script call : OrbitAnalyzer.instant_vorticity
  

ArtMatic script function :Sines

parameters :
A : Amplitude (-16.0 : 16.0) E9 options
B : Phase X (-32.0 : 32.0) E9 options
C : Phase Y (-32.0 : 32.0) E9 options
D : Frequency (0.0 : 16.0) E9 options

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

• Sines Add (Sin x + Sin y):
  script call : Sines.add
  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):
  script call : Sines.mul
  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):
  script call : Sines.displace
  x is displaced by a scaled sine of y
  
• Hexa sines:
  script call : Sines.hexa
  Sines evaluated in a hexagonal lattice
  

ArtMatic script function :Circles

parameters :
A : Frequency (0.0 : 128.0) E9 options
B : Size (0.0 : 1.500)
C : Power (0.250 : 10.0)

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.

ArtMatic script function :Star_Field

parameters :
A : Amplitude (-2.0 : 4.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 32.0) E9 options

discussion :
Star Field generates a virtual, layered star-field 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.

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

ArtMatic script function :Facet

parameters :
A : Frequency (-128.0 : 128.0) E9 options
B : Amplitude (-2.0 : 2.0)
C : Phase (-32.0 : 32.0)

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.

Script examples:
vec2 va = Random_Fractal_Space(X,Y);
vec1 fout1 = Facet(va.x,va.y);

ArtMatic script function :TechNoise

parameters :
Algorithm slider : (0 : 37) integer
B : Amplitude (0.0 : 16.0)
C : Frequency (0.0 : 32.0) E9 options

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 :
  script call : TechNoise.city_blocks_sharp
  
• Mondrian :
  script call : TechNoise.city_blocks_sharp
  
• Signs :
  script call : TechNoise.city_blocks_sharp
  
• Techno Grid :
  script call : TechNoise.city_blocks_sharp
  
• Techno Maze :
  script call : TechNoise.city_blocks_sharp
  
• Techno :
  script call : TechNoise.city_blocks_sharp
  
• Sparse Rects :
  script call : TechNoise.city_blocks_sharp
  
• Techno Coral :
  script call : TechNoise.city_blocks_sharp
  
• Building :
  script call : TechNoise.city_blocks_sharp
  
• Building B :
  script call : TechNoise.city_blocks_sharp
  
• Computer dots :
  script call : TechNoise.city_blocks_sharp
  
• Street network :
  script call : TechNoise.city_blocks_sharp
  Street Mask has positive values at street level and 0 for the city blocks.
  
• Street mask :
  script call : TechNoise.city_blocks_sharp
  
• Patchwork City C :
  script call : TechNoise.city_blocks_sharp
  
• Alien City :
  script call : TechNoise.city_blocks_sharp
  
• High Rise City :
  script call : TechNoise.city_blocks_sharp
  
• Random High Rise :
  script call : TechNoise.city_blocks_sharp
  
• Tech Lines :
  script call : TechNoise.city_blocks_sharp
  
• Tech Marks:
  script call : TechNoise.city_blocks_sharp
  

ArtMatic script function :Pyramids

parameters :
A : Amplitude (0.0 : 8.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 16.0) E9 options

discussion :
Pyramids generates surfaces made by a sum of recursively scaled square based pyramids. When available an Aspect Ratio parameter D can change squares to rectangles.

• Pyramids random noise:
  script call : Pyramids.random
  Sum of randomly & recursively placed square-based positive or negative pyramids.
  
• Techno noise:
  script call : Pyramids.techno
  Sum of randomly & recursively placed square-based positive pyramids.
  
• Techno noise const lines:
  script call : Pyramids.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:
  script call : Pyramids.dfnoise
  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.
  

ArtMatic script function :Maze

parameters :
A : Amplitude (0.0 : 2.0)
B : Style (0.0 : 1.0)
C : Frequency (0.0 : 16.0) E9 options

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

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: Libraries/Component demo/Chrome cycle logo

ArtMatic script function :Random

parameters :
A : Amplitude (-10.0 : 10.0) E9 options
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 32.0)
D : Offset (-1.0 : 1.0) E9 options

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.



Script example:
Explicit :vec1 fout = Random_noise(X,Y);
Implicit equivalent :vec1 fout = random(X,Y);

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.

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.

ArtMatic script function :Fractal_noise

parameters :
A : Amplitude (-4.0 : 4.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 32.0)
D : Roughness (0.250 : 0.750)

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.

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:
  script call : Ridged_fractal.square
  
• Cubic ridges:
  script call : Ridged_fractal.cubic
  
• Power cubic ridges:
  script call : Ridged_fractal.power
  

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:
  script call : Fractal_Terrains.mountains
  
• Eroded Canyons:
  script call : Fractal_Terrains.canyons
  
• Eroded Ranges:
  script call : Fractal_Terrains.eroded_ranges
  
• Eroded Mounts:
  script call : Fractal_Terrains.eroded_mounts
  
• Eroded Sparse Canyons:
  script call : Fractal_Terrains.eroded_canyons
  

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.
  

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.

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

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:

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:
  script call : BubbleSkin.bubbles
  
• Smooth Voronoi:
  script call : BubbleSkin.smooth_voronoi
  
• Voronoi Skin A:
  script call : BubbleSkin.voronskinA
  
• Voronoi Skin B:
  script call : BubbleSkin.voronskinB
  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:
  script call : BubbleSkin.scales
  Each voronoi cell has a slanted plane at 45°.
  
• Voronoi Disks:
  script call : BubbleSkin.vorondiscs
  Each voronoi cell is rendered with a randomly oriented disk.
  
• Voronoi Fur:
  script call : BubbleSkin.voronfur
  Each voronoi cell is rendered with a randomised rounded cone to evoke a fur like texture.
  
• Power Voronoi:
  script call : BubbleSkin.voronpower
  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:
  script call : BubbleSkin.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:
  script call : BubbleSkin.voronsplits
  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:
  script call : BubbleSkin.vorondensity
  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:
  script call : BubbleSkin.random_dirbumps
  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:
  script call : BubbleSkin.density_powerdots
  (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:
  script call : BubbleSkin.density_jtlights
  (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.
  
  
  

ArtMatic script function :Cellular

parameters :
A : Amplitude (0.0 : 8.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 32.0) E9 options

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:

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.

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.

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