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

These functions maps 2D input to a 2D output and are mostly space transformations (mirroring, rotations, tiling etc) or distortions (displacements, complex transforms, warpings etc). Transforming space on top of the tree will alter the geometry of any components below. Some like "22 edge logic" are actually more like 2 combined 21 tiles, one that outputs one type of values in X and another in Y.
Some of these components can also act as two parallel 1D filters.
A good way to see what effect these functions have on a system is to use a basic structure where a 2D Vector function distorts a picture.

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

ArtMatic script function :Maths

parameters :
A : Scale (-25.0 : 25.0)
B : Rotation (-360.0 : 360.0) angle in degree
C : Offset x (-25.0 : 25.0) E9 options
D : Offset y (-25.0 : 25.0) E9 options

discussion :
Many useful 2D space transforms are provided as various algorithm in the 2D Maths tools tile.

• Affine (scale+rotate+translate):
  script call : Maths.affine
  Combine scaling, rotation and offset in a single transform. Options allows to control the order of transformations.
  Options:
  -Use post translate
  -Use post translate*scale
  Translation applied after the rotation + scale. The offset is interpreted in transformed space orientation.
  -Use pre translate
  -Use pre translate/scale
  Translation applied before the rotation + scale. The offset is interpreted in original space orientation, scaled when using pre-translate and unscaled when using pre translate/scale.
  When there is no rotation "Use pre translate/scale" is equivalent to post translate. With rotation the resulting motion can be quite different if translation is applied before or after the transform. When you want the translated position be the center of rotation use the pre-translate modes.
  
• Affine inverse:
  script call : Maths.affine_inverse
  Does the inverse transform if you set it with the same parameters as the above.
  
• Affine exp:
  script call : Maths.affine_exponential
  Like "Affine", Affine exp combine scaling, rotation and offset in 1 transform but the scaling is using exponentials. Scaling is set by exp('Scale') meaning 'Scale' at zero (exp(0)=1) is identity. 'Scale' goes from -8 to 8 which makes a zoom range of approximatively 1/2980x to 2980x.
  This transform, added in ArtMatic Engine 8.0, is particularly suited to animate objects and to zoom in fractals images. Affine exp has the same options as Affinep transform. When using it to zoom inside fractals use the "post translate" mode so that zoom and rotations are centered whatever the translations.
  Example file : Libraries/Components demo/Affine Exponential.artm,
  Libraries/Components demo/Mandelbrot Exp zoom.artm
  
• Polar Log sym:
  script call : Maths.polar
  Return a polar logarithmic space with x out as atan(ABS(x),y) and y out as log(x^2+y^2)
  
  
• Polar Log:
  script call : Maths.polar_log
  Return a polar logarithmic space with x out as atan(x/y) and y out as log(x^2+y^2). Polar Log sym and Polar Log transforms circles into circles. Lines in y are transformed into circles. When you rotate the resulting space you will obtain partial spirals. When space is tiled there are some precise combinaison of scaling and rotation that can yield perfect spirals when tiles of another level connects exactly. Log spirals below makes finding these values easier for tiling that have whole number period.
  In version 1.5 Polar Log has a new set of option that makes it easier to map various patterns seamlessly when setting the scale: Polar space options
  
  
  
• Log Spirals :
  script call : Maths.log_spiral
  Return a polar logarithmic space scaled and rotated to create spirals that can match various tiling as set by the optional menu. The combination of 'Branch' and 'jump' parameters creates the scaling and rotation suited to have a joining spiral given the particular tiling structure (square, triangle, hexagonal..) set by the options. They should be kept whole numbers most of the time. See various examples in the Libraries/Maths/ folder.
  


• Complex z^2:
  script call : Maths.complex_square
  Return Z^2+ (C+iD) in the complex plane. Parameters C & D sets the offset and the seed of the julia set when the transform is applied iteratively.
  
• Complex z^3:
  script call : Maths.complex_cube
  Return Z^3+ (C+iD) in the complex plane. Parameters C & D sets the offset and the seed of the julia set when the transform is applied iteratively.
  
• Complex Cz^N:
  script call : Maths.complex_power_n
  Return C * Z^N in the complex plane. N (integer) is ranging 2 to 12 and is set with third parameter; Parameters C real and C imaginary sacales the result. Keep C at (1,0) for a straight complex power.
  
• Complex inverse (1/Az):
  script call : Maths.complex_inverse
  Return the complex inverse 1/A(x+iy) without translation and with A set by parameters. Keep A at (1,0) for a straight complex inversion. Like Complex Log and Moebius transforms, Complex inverse transforms circles into circles.
  See also Complex inverse
  
  
• Complex inverse (C/z):
  script call : Maths.complex_c_inverse
  Return the complex inverse C/(x+iy) with C given by parameters C real and C imaginary.
  See also Complex inverse
  
  
• Complex z-1/z:
  script call : Maths.complex_ziz
  Subtract the complex inverse from z(x+iy).
  
• Complex Exp:
  script call : Maths.complex_exp
  Returns the complex exponential. The complex exponential function is given exp(Z) =e^x cos(y)+ i e^x + i sin(y) with Z=x+iy.
  See also 42 Complex C exp(Z)
  
• Complex Log:
  script call : Maths.complex_log
  Returns the complex logarithm, the inverse of exponential. Complex Log is defined by 0.5*log(x^2+y^2)) + i*atan(x/y). Complex Log is similar to Polar Log but with x & y exchanged (or Z rotated 90 degree). It transforms circles and lines in x into circles.
  
• Complex Sines:
  script call : Maths.complex_sines
  See also Complex sines
  
• Complex Hyperbolic Sines:
  script call : Maths.complex_hyperbolic_sines
  Returns the complex hyperbolic sines given by sinh(x) * cos(y)+ i cosh(x) * sin(y).
  
  
• Moebius BC:
  script call : Maths.moebius_bc
  Moebius transform Az+B / Cz+D here with A at 1 and B & C set by parameters. D is derived to satisfy AD-BC==1
  
• Moebius BC inverse:
  script call : Maths.moebius_bc_inverse
  Returns the inverse of Moebius BC with the same parameters.
  
• Moebius parabolic:
  script call : Maths.moebius_parabolic
  One fixed point Moebius transform. The parabolic property means also that the trace of the A B C D matrix is +- 2
  
• Moebius 2 fixed points:
  script call : Maths.moebius_fixed_points
  A 2 fixed point Moebius transform. Parameter A and B set the K factor. When (1,0) the space is untransformed. When the real part of K is negative space is contained in the unit sphere as shown in the example file at Libraries/Maths/Complex maths/2fixed point moebius K factor. Parameter CD sets one fixed point, the other taken in mirror as(-C,D).
  


• Abs + offset:
  script call : Maths.abs
  Returns the absolute value of x and y translated by 'Offset x' & 'Offset y'. It is similar to the Mirrors 4 tile but without the scaling.
  
• |x|- sign(x)*y:
  script call : Maths.abs_sign_x_m
  Without parameters this function returns a 180 degrees rotation of positive x. Resulting space is discontinuous around x=0, but symmetrical by a 180 rotation.
  
• |x|+ sign(x)*y:
  script call : Maths.abs_sign_x_p
  Without parameters this function returns a 180 degrees rotation of negative x. Resulting space is discontinuous around x=0, but symmetrical by a 180 rotation.
  
  
• Clamp line:
  script call : Maths.limit_line
  Clamp x y inputs below a specific line that can be rotated and moved using offset parameters. The effect of clamping is similar to a plane mirror but values will continue unchanged instead of being reversed. This is a great tool for DF shape Modelling but the operation may distort the field if the angle of the clamping line approches the orthogonal of the field direction.
  Examples:
  ArtMatic Designer CTX/Libraries/Maths/2D Spaces and vectors/22 Maths Clamp heart.artm
  ArtMatic Designer CTX/Libraries/Maths/2D Spaces and vectors/22 Maths Clamp.artm
  
  

ArtMatic script function :Scale

parameters :
A : Scale x (-10.0 : 10.0) E9 options
B : Scale y (-10.0 : 10.0) E9 options

discussion :
This simple primitive scales the two inputs independently. The scale parameters have a greater range than the similar Scale and Offset function. Note that the x output is solely a function off the x input, and the y output is solely a function of the y input, Hence, this component can be used as either a space transform function OR as two parallel 1D filters. When used as a space transform, this component acts as a magnification function.

Left output : A * x
Right output: B * y

ArtMatic script function :Scale_Offset

parameters :
A : Scale (-16.0 : 16.0) E9 options
B : Offset x (-32.0 : 32.0) E9 options
C : Offset y (-32.0 : 32.0) E9 options

discussion :
The Scale & Offset component simply scales the incoming space (by multiplying the x and y coordinates by the same factor) and allows it to be offset horizontally ( the 'Offset x' parameter) and/or vertically (the 'Offset y' parameter). Note that a scale value of -1 inverts the space. Since the x output is a function of the x input and is not influenced by the y input, this component can be used as two parallel 1D scaling filters.
To combine scaling rotations and translation use the affine transforms at Maths tools #.

Left output: (A * x) + B
Right output: (A * y) + C

ArtMatic script function :Rotate

parameters :
A : Angle (-180.0 : 180.0) E9 options
B : Center x (-32.0 : 32.0) E9 options
C : Center y (-32.0 : 32.0) E9 options

discussion :
Rotate space about a point set by 'Center'. The 'Angle' parameter is the angle of rotation that can be set in radian or degree depending on the chosen option. Existing values are remapped when changing the 'Angle' unit. 'Center x' and 'Center y' set the point about which the space is rotated. The default center is 0,0. If the canvas view has been shifted the resulting rotation will not be centered.
To combine scaling rotations and translation use the affine transforms at Maths tools #.

Script examples:
explicit: vec2 va = Rotate(X,Y);
implicit: vec2 va = rotate(X,Y,30); //will create a rotate tile with angle at 30

ArtMatic script function :Skew

parameters :
A : Skew Angle (-180.0 : 180.0) E9 options
B : Skew Amount (-2.0 : 2.0)
C : Scale (-4.0 : 4.0) E9 options

discussion :
Skew skews the incoming space. The 'Skew Angle' parameter determines the angle of the skewing. 'Skew Amount' influences the amount of skewing, and 'Scale' zooms the space.

• Default skew:
  script call : Skew.default
  
• Skew Lateral:
  script call : Skew.lateral
  This skewing ensures that the y is invariant.
  
• Skew Vertical:
  script call : Skew.vertical
  This skewing ensures that the x is invariant.
  

ArtMatic script function :EdgeLogic

parameters :
A : Offset y (-10.0 : 10.0)
B : Edge height (0.0 : 10.0) E9 options
C : Edge width (0.0 : 10.0) E9 options
D : Smoothness % (0.0 : 10.0)

discussion :
Various logic tools have the option to create an edge at the intersection in boolean operations. But it is often useful to get the edge independently so they can be shaded separately. The 22 Edge Logic tool sends the edge distance field (DF) on the first output and the boolean operation on the second. This order is consistent with other 3D objects that sends 2 outputs like DF Polyhedrons #, Buildings, DF Constructs # and DF Cities #.
The 42 "logic tools" introduced in AM 7. 0 can be used to mix various 2 DF Edge logic outputs.

Parameters :

• Offset y : Is added to input y prior the boolean operation.
• Edge height & Edge width : Sets the global edge width & height. For very large or very small object the range may be too small then you can uses the dynamic option menu to interpret the parameters as *10 or /10.
• Smoothness : As usual to smooth the resulting volume. Don't set it too high or the edge will disappear.

• Edge Union:
  script call : EdgeLogic.max
  Union input A with B and outputs the edge in x and the union in y
  
• Edge Intersect:
  script call : EdgeLogic.min
  Intersect input A with B and outputs the edge in x and the intersection in y
  
• Edge Subtract:
  script call : EdgeLogic.sub
  Subtract input B from A and outputs the edge in x and the result volume in y Edge Subtract Example.
  
  
  
  
  
• Chisel Edge Union:
  script call : EdgeLogic.chmax
  Union of xy -> out2 with Chisel edge to out1
  
• Chisel Edge Intersect:
  script call : EdgeLogic.chmin
  Intersect of xy -> out2 with Chisel edge to out1
  
• Chisel Edge Subtract:
  script call : EdgeLogic.chsub
  Subtract (x-y) -> out2 with Chisel edge to out1
  Chisel Edge Subtract Example (here the volume has been shrunk to better see the generated "chiseled" edges) :
  
  
  
  
  
• Echo Union:
  script call : EdgeLogic.echomax
  
• Echo Intersect:
  script call : EdgeLogic.echomin
  
• Echo Subtract:
  script call : EdgeLogic.echosub
  The main logic functions with 3 edge to out1. The offset between edges is the first parameter.
  When negative the edges are following the x volume and the y volume on positive.
  Echoes Intersect example :
  
  
  
  
  
• Plane Subtract:
  script call : EdgeLogic.planesub
  Instead of an edge Plane subtract outputs in out 1 the DF of a plane that follows the shape of the subtracted DF. (It will be a curved plane if the subtracted DF is a sphere for example). Practically it creates a cap over the source (input 1) object following the DF contours of the input 2 object.
  
  
  
  
  
• Plane Intersect:
  script call : EdgeLogic.planemin
  Plane Intersect outputs in out 1 the DF of a plane that follows the shape of the input 2 object. Practically it creates a cap over the source (input 1) object following the DF contours of the input 2 object.
  
  
  
  
  
• Edge Partial Subtract:
  script call : EdgeLogic.partialsub
  The first parameter is the subtract width. It subtracts partially B to A and returns the edge in out1 and the main volume in out2. Edge Partial Subtract Example.
  
  
  
  
  

discussion :
22 Undulations displace space using sine waves, thus "undulating" the coordinates. When the 'Amplitude' is 0, space is not distorted. In 8.08 amplitudes can be set for X and Y axis separately. A great variety of space distortions and patterns can be generated by adjusting the amplitudes and frequency. In 8.08 the phase parameter allow to animates the undulations and the Frequency parameter has the usual frequency options settings. In DF modes the frequency adjust the amplitudes to make the transform compatible with DF modeling. Low frequency DF undulation can be used for example to curve a DF city for 3D rendering in ArtMatic Voyager.

discussion :
Like Sin x, sin y, this component tiles space. In this case, space is tiled using a combination of sin and hexagonal transforms. The output of this function is both periodic and continuous, thus it is often used for sound design.


A plane and a rotating line passed through the Hexagonal Sin space.

ArtMatic script function :Orthogonal_Tiles

parameters :
A : Scale (0.0 : 16.0)
C : Frequency (0.0 : 10.0) E9 options

discussion :
Orthogonal Tiles # provides several methods for tiling space. The parameters are algorithm dependent. 'Frequency' sets the tile size and leaves the coordinates of each tile unchanged and centered at 0. The 'Scale' parameter scales the space in the tiles with 1 being no change. When Scale Y is present in the rectangle algorithms it can adjust the aspect ratio.

Tip: To create complex symmetry, follow this component with the Mirrors 4 component.

Warning: The output is highly discontinuous and is to be avoided in systems destined for ArtMatic Voyager.

• Unit Square Tiles:
  script call : Orthogonal_Tiles.unit_square
  Square tiling on the unit grid when frequency is at 1.
  
• Square Tiles 45°:
  script call : Orthogonal_Tiles.square_angled
  45° square tiling scaled by square root of 2 so that edges passes through the unit grid.
  
• Rectangle Tiles :
  script call : Orthogonal_Tiles.rectangles
  Rectangular tiling ; "frequency x" and "frequency y" can be adjusted independently.
  
• Square Tiles (displaced):
  script call : Orthogonal_Tiles.square_displaced
  
• Zoom Tiles (π displaced):
  script call : Orthogonal_Tiles.zoom_pi_displaced
  Theses algorithms feature a displacement parameter which creates non-repetitive tiling by applying random displacements for the tiles. When 'displacement' is non-zero, the tiling is non-repetitive.
  
  
  

ArtMatic script function :OrthoMirror_Tiles

parameters :
A : Frequency (0.0 : 32.0) E9 options
B : Aspect ratio (0.0 : 2.0)

discussion :
The input space is mirrored both vertically and horizontally and then tiled which makes it ideal for creating tiled wallpaper or kaleidoscope type effects. (For creating individual tiles for export, the Mirrors 4 component may be more appropriate.) In E9 the old 'Scale' parameter has been renamed frequency to ease alignement with other tiling functions.
To keep the same behavior as before just use 1/f parameter option. Parameter 'Scale' is applied both horizontally and vertically. Parameter 'Aspect ratio' applies only vertically and can be used to achieve rectangular mirrors tilings.

22 Other Tiles #

ArtMatic script function :Other_Tiles

parameters :
A : Amplitude (0.0 : 8.0)
B : Rotation (-180.0 : 180.0) angle in degree
C : Frequency (0.0 : 10.0)

discussion :
This component provides a collection of periodic regular tilings. 'Amplitude' scales the space in each tile while 'Rotation' rotates it. 'Frequency' sets the period of the tiling.

algorithms :

• Triangle Tiling:
  script call : Other_Tiles.triangles
  Tile orientation is constant.
  
• Triangle Tiling Alt:
  script call : Other_Tiles.triangles_alt
  Tile orientation is reversed alternatively.
  
• Triangle Tiling 6:
  script call : Other_Tiles.triangles_hex
  Tile orientation is using a sixfold rotation.
  
• Lozenges Tiling:
  script call : Other_Tiles.lozenges
  3 lozenges makes an hexagon when tiles are rotated 120°.
  
  
  
  
  
• Lozenges mirror Tiling :
  script call : Other_Tiles.lozenges_mirror
  
• Hexagonal Tiling:
  script call : Other_Tiles.hexagonal
  
• Hexagonal Zoom Tiling:
  script call : Other_Tiles.hexagonal_z
  
• Triangles 45°:
  script call : Other_Tiles.triangles_angled
  A square lattice split at 45° where the tile orientation alternates.
  
• Cairo 18° Tiling:
  script call : Other_Tiles.cairo_narrow
  
• Cairo 30° Tiling:
  script call : Other_Tiles.cairo_wide
  

ArtMatic script function :Mirror_Tiles

parameters :
A : Frequency (0.0 : 16.0) E9 options
B : Phase (-10.0 : 10.0) E9 options

discussion :
Mirrors N Tiles implements a series of tiling with mirror symmetries around the edges. Parameters will vary with algorithms.
The tilings are periodic and many uses N rotational foldings. The 'Phase' parameters moves the Y coordinate in the given orientation options.
In E9 the old 'Tile size' parameter has been renamed frequency to ease alignement with other tiling functions. Use it with 1/value to sets the period of the tiling if needed. The "60 degrees" means the underlying lattice is a triangular lattice. The "45 degrees" means lattices cell centers are spaced at 45°
"skewed 36" refers to a skewed lattice with a ratio of tan(36°) between x and y while "skewed 72" to a ratio of tan(72°)
The last 4 algorithms provides semi-regular mirror tilings of several polygons.
The Options popup allows to set the mirrors orientations.

• Unit Threefold Mirrors:
  script call : Mirror_Tiles.threefold_unit
  3 rotations folding in a square lattice.
  
• Threefold Mirrors 60°:
  script call : Mirror_Tiles.threefold_60
  3 rotations folding in a triangular lattice.
  
• Fourfold Mirrors 45° :
  script call : Mirror_Tiles.fourfold_45
  4 rotations folding in a 45° lattice.
  
• Fivefold Mirrors skewed 72° :
  script call : Mirror_Tiles.fivefold_skewed
  5 rotations folding in a skewed 72° lattice
  
• Sixfold Mirrors 60°:
  script call : Mirror_Tiles.sixfold_60
  6 rotations folding in a triangular lattice.
  
• Sixfold Mirrors 45° :
  script call : Mirror_Tiles.sixfold_45
  6 rotations folding in a 45° lattice.
  
• Heightfold Mirrors :
  script call : Mirror_Tiles.eightfold
  8 rotations folding in a square lattice.
  
• Heightfold Mirrors 45° :
  script call : Mirror_Tiles.eightfold_45
  8 rotations folding in a 45° lattice.
  
• Ninefold Mirrors 60° :
  script call : Mirror_Tiles.ninefold_60
  9 rotations folding in a 60° lattice.
  
• Tenfold Mirrors 45° :
  script call : Mirror_Tiles.tenfold_45
  10 rotations folding in a 45° lattice.
  
• Tenfold Mirrors skewed 36° :
  script call : Mirror_Tiles.tenfold_skewed_36
  10 rotations folding in a skewed 36° lattice
  
• Tenfold Mirrors skewed 72° :
  script call : Mirror_Tiles.tenfold_skewed_72
  10 rotations folding in a skewed 72° lattice
  
• Twelvefold Mirrors 60° :
  script call : Mirror_Tiles.twelvefold_60
  12 rotations folding in a 60° lattice.
  
• Twelvefold Mirrors 45°:
  script call : Mirror_Tiles.twelvefold_45
  12 rotations folding in a 45° lattice.
  
• Sixteenfold Mirrors:
  script call : Mirror_Tiles.sixteenfold
  16 rotations folding in a square lattice.
  
• Sixteenfold Mirrors 45°:
  script call : Mirror_Tiles.sixteenfold_45
  16 rotations folding in a 45° lattice.
  
  
  
  
  
• Twentyfold Mirrors 45°:
  script call : Mirror_Tiles.twentyfold_45
  20 rotations folding in a 45° lattice.
  


• Square & triangles Mirrors:
  script call : Mirror_Tiles.square_triangles
  
• Hexagons, squares & triangles mirror:
  script call : Mirror_Tiles.hexagons_squares_triangles
  Semiregular tiling of Hexagons, triangles and squares.
  
• Decagons & pentagons mirror:
  script call : Mirror_Tiles.decagons_pentagons
  Semiregular tiling of decagons and pentagons.
  
  
  
  
  
• Pentagonal crystal mirror:
  script call : Mirror_Tiles.pentagonal_crystal
  The pentagonal crystal mirror is especially interesting as tiling with regular pentagons is impossible. This algorithm offers a quasi crystal semiregular solution quite pleasing esthetically.
  
  
  
  
• Alternate Heightfold:
  script call : Mirror_Tiles.alternate_eightfold
  Inspired by indian/persian musharabia this tiling uses 8 fold symetries inside an alternate 45° square grid. Height branch squared stars often emerges from the set of symetries.
  
  
  

ArtMatic script function :Split_n_Move

parameters :
A : Angle (-3.142 : 3.142)
B : Offset x (0.0 : 10.0) E9 options
C : Offset y (0.0 : 10.0) E9 options

discussion :
Splits the incoming space (plane) in two and moves each side in opposite directions. Infinity is generated in the space between the split planes so that the output of this component can be used as a mask for wipe effects.

ArtMatic script function :infinity_disk_gate

parameters :
A : Limit (-1.0 : 64.0) E9 options

discussion :
Modified in ArMatic engine 8.07, this component generates infinity values or remove infinities according to the following algorithms :

• Pass infinity:
  Returns Infinity whenever the length of vector (x,y) is greater than 'Limit'. When the tree is in RGB mode infinity is shaded with the Depth cue color.
  
• Discard infinity:
  Any incoming Infinities values will be remapped to the parameter A value, thus clearing infinities.
  

ArtMatic script function :Mirror

parameters :
A : Rotation (-180.0 : 180.0) E9 options
B : Offset x (-50.0 : 50.0) E9 options
C : Offset y (-50.0 : 50.0) E9 options
D : Smoothness % (0.0 : 1.0)

discussion :
Mirrors N Tiles implements a series of tiling with mirror symmetries around the edges. Parameters will vary with algorithms.
The tilings are periodic and many uses N rotational foldings. The 'Phase' parameters moves the Y coordinate in the given orientation options.
In E9 the old 'Tile size' parameter has been renamed frequency to ease alignement with other tiling functions. Use it with 1/value to sets the period of the tiling if needed. The "60 degrees" means the underlying lattice is a triangular lattice. The "45 degrees" means lattices cell centers are spaced at 45°
"skewed 36" refers to a skewed lattice with a ratio of tan(36°) between x and y while "skewed 72" to a ratio of tan(72°)
The last 4 algorithms provides semi-regular mirror tilings of several polygons.
The Options popup allows to set the mirrors orientations.

• Offset Output:
  script call : Mirror.offset_out
  3 rotations folding in a square lattice.
  
• Offset Mirror:
  script call : Mirror.offset_mirror
  3 rotations folding in a triangular lattice.
  

Decagons & pentagons mirror :
Semiregular tiling of decagons and pentagons.

Pentagonal cristal mirror :
The pentagonal crystal mirror is especially interesting as tiling with regular pentagons is impossible. This algorithm offers a quasi crystal semiregular solution quite pleasing esthetically.

ArtMatic script function :Mirrors_3

parameters :
A : Scale (-4.0 : 4.0) E9 options
B : Offset x (-8.0 : 8.0) E9 options
C : Offset y (-8.0 : 8.0) E9 options

discussion :
Mirror space into three parts with a 120 degree rotational symmetry. Use this and the other "mirror" components for kaleidoscopic effects. 'Scale' scales the incoming space and the offset parameters provide horizontal and vertical offsets of the resulting space. 'Offsets' are applied after the mirroring.

ArtMatic script function :Mirrors_4

parameters :
A : Scale (-4.0 : 4.0) E9 options
B : Offset x (-8.0 : 8.0) E9 options
C : Offset y (-8.0 : 8.0) E9 options

discussion :
This component returns ABS(x),ABS(y) which mirror the incoming space to make it symmetrical about the x and y axes. It has no option and uses a simple absolute value with optional scaling. Keep 'Scale' at 1 for strict mirroring and DFRM compatibility.'Offsets' are applied after the mirroring. To mirror a single axis you can use the 11 Abs x component.
Use N-Fold Mirrors with N=4 when mirror orientation is required.

ArtMatic script function :NFMirrors

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

discussion :
This component provides a number of different mirroring algorithms involving N rotational mirrors. Parameters options are available for all folding symmetry orientation options. Various algorithms basically sets the number of rotational symmetries. 'Offsets' are applied after the mirroring. Keep 'Scale' at 1 for strict mirroring and DFRM compatibility.
In E9 the old Scale (period) has been renamed frequency to ease alignement with other tiling functions. To keep the same behavior as before just use 1/f parameter option.

• Skewed 6 Mirrors:
  script call : NFMirrors.skewed
  This algorithm was left for legacy and compatibility with older versions though it is mathematically incorrect. It creates a kaleidoscopic mirroring of space about three axes that are rotated 120 degrees apart.
  
• Threefold Mirrors:
  script call : NFMirrors.threefold
  
• Fourfold Mirrors :
  script call : NFMirrors.fourfold
  
• Fivefold Mirrors:
  script call : NFMirrors.fivefold
  
• Sixfold Mirrors:
  script call : NFMirrors.sixfold
  
• Heightfold Mirrors:
  script call : NFMirrors.heightfold
  
• Ninefold Mirrors:
  script call : NFMirrors.ninefold
  
• Tenfold Mirrors:
  script call : NFMirrors.tenfold
  
• Twelvefold Mirrors:
  script call : NFMirrors.twelvefold
  
• 45° Mirrors:
  script call : NFMirrors.fourtyfive
  

ArtMatic script function :Branch_N

parameters :
A : Branch number (1 : 50) integer
B : Offset x (-8.0 : 8.0) E9 options
C : Offset y (-8.0 : 8.0) E9 options
D : Smoothness % (0.0 : 8.0)

discussion :
Branch N mirrors space as in the other "mirror" tiles but provides parametric control of the number of rotational folding mirrors as well as choices of mirror orientations. The 'Branch number' 'parameter allows you to achieve from 2 to 50 rotational symmetries. Unlike the other mirror functions, the axis symmetry can be made seamless (continuous) using the 'Smoothness' parameter which allows to create continuous surfaces. The 'offset x' and 'offset y' parameters are the horizontal and vertical offsets of the output mirrored space.

Parameter options provide a number of different symmetries. When inward is chosen, the orientation matches the one used by 3D Mirrors & Rotates # .

• Orient outward (x-,y-)
• Orient inward (x-,y+)
• Orient outward (x+,y-)
• Orient inward (x+,y+)

ArtMatic script function :Disk_Mirror

parameters :
A : Disk Size (0.250 : 50.0)
B : Mirror concavity (0.0 : 1.0)
C : Offset y (-8.0 : 8.0) E9 options
D : Offset x (-8.0 : 8.0) E9 options

discussion :
Disk Mirror provides a circular mirroring of the incoming space. This is another component that can be used to constrain space to prevent it from reaching infinity. The 'Disk Size' parameter controls the radius above which the space is mirrored. 'Offset' x and y controls the center of the mirroring disk.
When 'Mirror concavity' is close to 1 the mirror reflects the inside and values in-between will distort the space to blend between orientations. Keep it at zero for a strict circle inversion.

ArtMatic script function :Disk_Inverse_Ring

parameters :
A : Disk number (2 : 12) integer
B : Scale (-8.0 : 8.0)
C : Offset y (-1.0 : 1.0) E9 options

discussion :
Mirrors the 2D space with a set of N tangents Mirroring circles arranged in a ring. 'Disk number' sets the number of disk mirrors while 'Scale' controls their radius and the underlying ring radius. When applied recursively disk inversions may creates fascinating fractals. 'Offset y' offsets the radius of an overall disk mirror that can go outward when positive or inward when negative. In general you will keep y at -1 (regions outside the overall disk mirror the inside), or 0,1 (regions inside the overall disk mirror the outside);

discussion :
Complex inverse inverts space using the complex number division 1/Z, Z=(x+iy). The transformation divides (x,y) by its squared distance to zero so that infinity becomes (0,0) and (0,0) is mapped to infinity.
The Complex inversion has the remarkable property to transform lines into circles.
See also Complex Division.
Note : the euclidian distance or length(x,y) is also called the magnitude of the complex x+iy.

discussion :
Complex Moebius is a space transform based on the division of two complex polynomials (AZ+B/CZ+D). When used in an iterative (looped) system the result is fascinating geometries that sometimes have several attractors. See the 25 Components chapter for examples of other Moebius transforms.

ArtMatic script function :Polar_Space

parameters :
A : Polar scale (0.500 : 32.0) E9 options
B : Distance scale (-32.0 : 32.0)
C : Phase x (-3.142 : 3.142)

discussion :
Use this component to interpret x and y as polar coordinates where x is the angle and y is distance. In version 1.5 Polar Space has a new set of option that makes it easier to map various patterns seamlessly when setting the scale:Polar space options

ArtMatic script function :Random

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

discussion :
This component provides two narrow band random functions of the (x,y) space. the 'Amplitude' value controls the scale of the output noise.
The result can be used as displacement or as dual function generation depending on the algorithm, available since E9. It can be generated implicitly in the script language with random(X,Y,Z).

Script example: use random for x & y separately
vec2 vra =Random.balanced(X,Y);
vec1 fb = TechNoise.signs_sharp(X,vra.y);
vec1 fc = PictMovie(vra.x,Y);
vec1 fout1 = mix(fb,fc,0.75);

• displace:
  script call : Random.displace
  
  legacy behavior for distortion of x y space. If you place a noise component before a 2D tile you will warp the space in which the tile is rendered.
  
  
• balanced:
  script call : Random.balanced
  
  generates 2 independents noise functions ranging -1 : 1 when amplitude is unity.
  
  
• unbalanced:
  script call : Random.unbalanced
  
  generates 2 independents noise functions ranging 0 : 1 when amplitude is unity.
  
  

ArtMatic script function :Random_Fractal_Space

parameters :
A : Amplitude (0.0 : 32.0)
B : Phase (-32.0 : 32.0) E9 options
C : Frequency (0.0 : 32.0)
D : Roughness (0.200 : 0.800)

discussion :
This noise function outputs a 2D vector valued fractal noise. Unlike the other noise functions, Random Fractal Space is not a displacement which results in the new coordinates being truly random. Place this component before a Grid to create veined textures, or place it before any other surface generator to create beautiful random textures. As usual 'Roughness' parameter controls the fractal dimension.
'Frequency' has the usual frequency options settings.

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

discussion :
"Low Freq Random" displaces the (x,y) space with a narrow band low frequency noise. 'Amplitude' controls how much coordinates are displaced.

See also the 21 Low Freq noise tile.

discussion :
A Perlin noise-based component that combines the output of two uncorrelated Perlin Noise functions for each output to displace the input space. The 'Amplitude' parameter controls the amount of displacement of the incoming values. 'Phase' offsets the noise in x. 'Frequency' has the standard frequency options and controls the scale of the noise.

discussion :
To displace the input space, "Multi Perlin displace" uses two uncorrelated Multi-Perlin noises functions for each coordinates. The Multi-Perlin noise sums Perlin Noise functions at various frequencies according to the 'Octaves' parameter.
The 'Amplitude' parameter controls the amount of displacement. 'Frequency' has the standard frequency options and controls the scale of the noise. 'Roughness' controls the fractal dimension and has a visible effect only when octaves is above 2.

ArtMatic script function :Turbulence

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

discussion :
This is a 2D fractal displacement function whose 'Amplitude' parameter controls the amount of displacement added to the input space. This component is great for creating turbulence, fire, marble and clouds. 2D Turbulence is based on two parallel fractal noises. See the notes for 21 fractal noise to learn more about fractal noises.
"2D turbulence" is sensitive to the Max iterations for fractals preference, as most fractal noises/displacement functions. The 3D equivalent of this component can be found at 32 Turbulence 3D .
'Frequency' has the standard frequency options while 'Roughness' controls the fractal dimension.

discussion :
"Time turbulence" is similar with 2D turbulence described above but with time causing automatic phase shift. This function is unusual in that it is sensitive to the flow of time -- even with its parameters locked and without keyframes. It is a great primitive for creating flow and smoke effects for animation and video processing. 'Amplitude' controls the amount of displacement of the input values. The 'Feedback' parameter loops the system so that lower frequencies distorts higher ones according to feedback values when non-zero. 'Pace' controls the speed of the time-induced animation.
'Frequency' has the standard frequency options settings.

discussion :
A 2D fractal displacement noise created by summing vector-valued Perlin noise functions of varying fractal dimension (roughness). "Multi-Fractal" describes fractals with varying fractal dimension (a measure of the surface roughness). See the scalar version of MultiFractal noise.

Multi Fractal displace creates rich and natural textures - especially when used in ArtMatic Voyager. 'Amplitude' controls the amount of displacement of the input values. Smoothness controls the roughness of the displacement texture.
'Frequency' has the standard frequency options while 'Roughness' controls the fractal dimension.


A Multi-Fractal displaced cone rendered in ArtMatic Voyager.

discussion :
A multi-fractal 2D vector function based on a "ridged" version of the Perlin noise function as discussed in the 2D Scalar (21) components chapter. See 21 Ridged Fractal noise. 'Amplitude' controls the amount of displacement of the input space.
'Frequency' has the standard frequency options while 'Roughness' controls the fractal dimension.

ArtMatic script function :Chaos_displaceA

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

discussion :
A composite multi-fractal displacement function based on a cubic-clipped Perlin noise function. 'Frequency' has the usual frequency options settings while 'Roughness' controls the fractal dimension.


Chaos displace can turn a simple cone into a rich featured island.

ArtMatic script function :Chaos_displaceB

parameters :
A : Amplitude (0.0 : 2.0)
B : Feedback (-1.0 : 1.0) E9 options
C : Frequency (0.0 : 32.0)
D : Roughness (0.250 : 0.750)

discussion :
A composite multi-fractal displacement function based on an algorithm similar the 21 Bubble Rock component. As with Chaos displace A it can turn simple surface into highly complex fractal terrains.
'Frequency' has the usual frequency options settings.

discussion :
A fractal displacement function based on a triangular lattice random linear noise. Crystal Displace is discontinuous and will produce sharp edges when used in ArtMatic Voyager. The 'Roughness' parameter controls the fractal dimension as with other fractal noises.
'Frequency' has the usual frequency options settings.

discussion :
As with the 22 Orbiters component, bubbles creates cells enclosing their own space : Each bubble has 0 at its center and is surrounded by 0. Cells are randomly placed and space is blended between cells or "Bubbles" so the resulting space is continuous while highly distorted. 'Bubble size' controls the size and overlapping of bubbles.
This component is terrific for creating non-repeating and organic looking textures and random patterns.
'Frequency' has the standard frequency options settings.


Bubble space shaded with Shaded main gradient (Libraries/Components demo/22 Bubble space texture.artm)

discussion :
Create a multitude of irregularly-spaced tiles of the incoming space using Voronoi diagrams. Resulting space is discontinuous. 'Scale' affects the size of coordinates within each facet while 'Frequency' sets the period of the facet non periodic texture. "Delta size" adjust how much facets coordinates are randomized in scale. Large values provide a great variation of sizes. See also the 24 XYza Voronoi tiles that offers more options of shapes and shadings.

discussion :
Compiled trees are groups of tiles that can be used in place of single tiles as a kind of macro or subroutine. 22 CTs can hold groups of 2D space transformations or can be used to manipulate 2 parallel streams of datas : scalar single values (1D), 3D or 4D packed vectors.

usage :
Select a 22 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.

22 CT can be used recursively if the option "Allow feedback" is set. In that case output is fed to the input at second iteration and the transform will be applied N times, N being set by the "Recursions" parameter. Recursions over 2D space transforms provide a simple and efficient way to generate 2D fractals.
22 CT allows recursion with feedback ON with packed RGBA streams as well as scalar input/outputs. The types of ins and outs has to match for the feedback to function properly. If ins and outs are packed RGBA, a 22 CT can process 8 values. This vector usage of 22 CT is often needed for plant design where each level has to send both transformed space coordinates and textured DF RGBA data to the next. Examples can be found in Voyager Library/3D Models/DF Plants folder.
Starting E9 it can accept packed data in any input slot if the corresponding output slot is packed as well.