User:Le Forgeron

I use this page to pre-document some experimental code (as experimental, not distributed in official release)

Interesting documents & link

They should not be incorporated as such in the documentation, but can provide some interesting informations

Splines

Imported from Megapov
Relicensing from ABX is needed before allowing distribution
(some bugs get fixed in the process)

Also check the megapov documentation for better explanation or clarification.

Accessing splines data

Not only the value of a spline can be evaluated with the traditional SPLINE_IDENTIFIER ( FLOAT [, SPLINE_TYPE] ), it is also possible to get back the actual pieces of information from a spline.

dimension_size( SPLINE_IDENTIFIER ) provides the number of entries in the spline.

For each entry, the spline can be accessed like an array, the first element is the float of the path list and the second element the associated vector.

SPLINE_IDENTIFIER[ INDEX ][0] is a float
SPLINE_IDENTIFIER[ INDEX ][1] is a vector
INDEX should evolve as an integer from 0 to dimension_size(SPLINE_IDENTIFIER)-1

Additional types of splines

Sor spline

the curve followed by a sor can be evaluted by a spline of sor_spline type with a bit of manipulation: the y value of the sor must be used as the float of the path, and the x value become one of the component of the vector. The component of the vector never get negative with a sor spline.

spline{
   sor_spline
  -1.000000,0.000000*x
   0.000000,0.118143*x
   0.540084,0.620253*x
   0.827004,0.210970*x
   0.962025,0.194093*x
   1.000000,0.286920*x
   1.033755,0.468354*x
}

sor{
  7
  <0.000000, -1.000000>
  <0.118143,  0.000000>
  <0.620253,  0.540084>
  <0.210970,  0.827004>
  <0.194093,  0.962025>
  <0.286920,  1.000000>
  <0.468354,  1.033755>
}

akima spline

That spline will go through all its points, smoothly.

spline {
  akima_spline
  time_Val_1, <Vector_1> [,]
  time_Val_2, <Vector_2> [,]
    ...
  time_Val_n, <Vector_n>
}

tcb spline

Also know as Kochanek-Bartels spline, tcb stand for tension, continuity and bias.

The first and last point of such spline are not reached.

spline {
  tcb_spline [TCB_PARAMETERS]
  time_Val_1 [TCB_PARAMETERS], <Vector_1> [TCB_PARAMETERS][,]
  time_Val_2 [TCB_PARAMETERS], <Vector_2> [TCB_PARAMETERS][,]
    ...
  time_Val_n [TCB_PARAMETERS], <Vector_n> [TCB_PARAMETERS]
}

TCB_PARAMETERS:
  [tension FLOAT] [continuity FLOAT] [bias FLOAT]

The tension, continuity and bias are fully optional. Depending on the place where they appear, they control the spline in different ways:

Placed right after the tcb_spline keyword, they set the default values for all ends of the spline segments. This placement is ignored in case of copying spline without adding new controls because previous defaults were already propagated to each side of control points.
Placed between the time_value and the corresponding vector, the tcb parameters determine the properties of the spline segment ending in the vector that follows these parameters (as well as for the spline segment beginning at this vector if not overriden with the third position).
For tcb parameters following a vector, the properties of the spline segment beginning after this vector are set.

What is controlled by these parameters?

tension controls how sharply the curve bends.
continuity controls how rapid speed and direction change.
bias controls the direction of the curve as it passes through the control point.

x splines

X-Splines are an alternative to traditional splines that was introduced by Carole Blanc and Christophe Schlick in 1995.

XSplines have the very nice property that they can interpolate (go through) a control point as well as just approximate it. Sharp edges are also possible, but the curve is always C2 continuous, hence the sharp edges are only possible when the first derivative drops to zero.

An X-Spline is completely defined by a set of control point (vertices) and a set of parameters. One parameter is associated with each control point.

There is 3 variations of x splines:

basic
extended
general

basic x spline

The first and last point of such spline are not reached.

spline {
  basic_x_spline [freedom_degree FLOAT]
  time_Val_1, <Vector_1> [freedom_degree FLOAT] [,]
  time_Val_2, <Vector_2> [freedom_degree FLOAT] [,]
  ...
  time_Val_n, <Vector_n> [freedom_degree FLOAT]
}

The freedom_degree before the first point is the default value (0.0 by default)

extended x spline

Extended spline are always C², but allows sharp points (where both the first and second derivatives drop to zero). All the points are visited.

spline {
  extended_x_spline [freedom_degree FLOAT]
  time_Val_1, <Vector_1> [freedom_degree FLOAT] [,]
  time_Val_2, <Vector_2> [freedom_degree FLOAT] [,]
  ...
  time_Val_n, <Vector_n> [freedom_degree FLOAT]
}

The freedom_degree before the first point is the default value (0.0 by default)

general x spline

All points are visited.

spline {
  general_x_spline [freedom_degree FLOAT]
  time_Val_1, <Vector_1> [freedom_degree FLOAT] [,]
  time_Val_2, <Vector_2> [freedom_degree FLOAT] [,]
  ...
  time_Val_n, <Vector_n> [freedom_degree FLOAT]
}

The freedom_degree before the first point is the default value (0.0 by default)

Colour space interpolation

The colour interpolation is available for:

mesh
blob
polygon

It can be used with texture_map, pigment_map or colour_map.

The interpolation is performed between the resulting colours from the evaluation, not along the map.

Which colourspace ?

colour_space pov
colour_space hsl
colour_space hsv
colour_space xyl
colour_space xyv

color_space is also a valid synonym for colour_space.

pov

Classical linear interpolation in the rgb space.

50% of pure Red (rgb <1, 0, 0>) and pure Green (rgb <0, 1, 0 >) is a dark yellow (rgb <1/2, 1/2, 0>).

hsl or hsv

The colour (from rgb space) is converted to the HSL ot HSV colour system where the linear interpolation is performed.

50% of pure Red and pure Green turns out as pure Yellow.

xyl or xyv

the hs part is considered as polar coordinates (h, hue, being the angle and s being the length) of a point. The interpolation is performed using the Cartesian coordinates (xy).

The interpolation for the l or v part remains unchanged, a simple linear interpolation.

Mesh

Only one colour space per mesh, used for all its triangles.

mesh {
	triangle {0,x,y texture_list { colo1, colo2, colo3 } }
        ...
	colour_space hsv
}

blob

Only one colour space per blob, used for all components.

blob {
  ...	
   	colour_space hsv
}

Interpolation for polygon

a texture_list can be provided in the polygon, with a texture identifier for each vertex (and ignoring repeated vertex which are used to close a line)

The colour of any point from the polygon is a weighted average of each vertex, with the weight based on the distance to the vertex: the closer to a vertex, the more weight that vertex has. strength (with a float) can be used to adjust the relative weight by raising them to the power of the strength: strong strength gives more pronounced partitions.

#declare colo3=texture { pigment {color rgb<0.,0.,0>}};
#declare colo4=texture { pigment {color rgb<0.,1.,1/3>}};
#declare colo5=texture { pigment {color rgb<0.,1.,1>}};
#declare colo6=texture { pigment {color rgb<1.,1.,1/3>}};
#declare colo7=texture { pigment {color rgb<1.,1./3,1>}};
#declare num=5;
#declare step=2;
                                polygon { (num+1)*step,
#local j=0.70;
#while(j>0.1)
#local i=0;
#while(i<num+1)
		                j*< cos(i*2*pi/num),sin(i*2*pi/num),0>
#local i=i+1;
#end
#local j=j-0.90/step;
#end
			texture_list { colo3, colo4, colo5, colo6, colo7, colo5, colo6, colo7, colo3, colo4 } 
                        strength 1.0
}

colour_space is of course available too.

Access to camera information

These pieces of information are in read-only mode. You cannot use them to modify the actual value (no #declare or #local). The various vectors might have been updated by transform and look_at.

camera_type is a string containing the type of the camera (but not its subtype, so cylinder camera might be ambiguous).
camera_up is the actual up vector of the camera.
camera_right is the actual right vector of the camera.
camera_direction is the actual direction vector of the camera.

In case of scene with multiple cameras, each keyword can be followed by an usual array notation to access the relevant camera. (e.g. camera_up[3] for the fourth camera)

Tesselation & mesh play

Yoda: Yes, run! Yes, a Jedi's strength flows from the Renderer. But beware of the dark side. 
      Mesh, Heightfield, Bicubic Patch; the dark side of the Force are they. Easily they flow, 
      quick to join you in a fight. If once you start down the dark path, 
      forever will it dominate your destiny, consume you it will, as it did Isosurface's apprentice.
Luke: Parametric precompute... Is the dark side stronger?
Yoda: No, no, no. Quicker, easier, more seductive.
Luke: But how am I to know the good side from the bad?
Yoda: You will know... when you are calm, at peace, passive. 
      A Jedi uses the Renderer for knowledge and defense, NEVER for attack.
Luke: But tell my why I can't...
Yoda: No, no! There is no "why".

Mesh from 3D finite object

it must be 3D, to have an inside test which is meaningfull
it must be finite, because the bounding box is use to specify the volume which will be sampled

Whatever the method used (it will always end as a mesh object, or inside a mesh object). there is some common parameters:

original is followed by the object to sample. It is really mandatory.
accuracy is followed by a 3D vector which specify the number of slices in each direction (it defaults to 10)

Without texture, using only Inside test (fast)

These approaches use a marching cube algorithm, hence their usage were forbidden on the USA thanks to a now expired patent (17 years after December 1987).

bourke ( inspired by Paul Bourke at http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/ , named with explicit authorisation)

heller ( alternate table from Bourke page made by Geoffrey Heller)

cubicle (simplistic approach using a cube)

cristal (same as cubicle, with inclined face)

bourke & heller allow additional options :

precision with a float, which supersample along the interecting line (by the amount of the float, so only positive integer are of any real interest) for a better fit.
offset is followed by a float which move outward the position of each face of the bounding box used for scanning (default to 0, so beware of very tight perfect bounding box)

Using Inside test & trace (slower)

No marching cube per itself here, the inside test is used to trigger the usage of trace to get the actual intersection.

tesselate

 mesh { ...
  tesselate { 
    original finite3D_obj
    [accuracy vector] [albinos] [offset float] [smooth] [texture { Tid }]
  }
 ...
 }

OR

 tesselate { 
   original finite3D_obj
   [accuracy vector] [albinos] [offset float] [smooth] 

 [Object_Mods...]
 }

tessel

 mesh { ...
  tessel { 
    original finite3D_obj
    [accuracy vector] [albinos] [offset float] [smooth] [texture { Tid }]
  }
 ...
 }

OR

 tessel { 
   original finite3D_obj
   [accuracy vector] [albinos] [offset float] [smooth] 

 [Object_Mods...]
 }

As trace is used, the texture from the intersection point is available and can be pushed on the vertex of each generated triangle. This can be prevented with the use of the albinos option.

a possible parameter is smooth which would also use the normal reported by the intersection to make smooth_triangle instead of triangle in the resulting mesh.
offset is followed by a float which move outward the position of each face of the bounding box used for scanning (default to 0, so beware of very tight perfect bounding box)

Mesh from and to file

Loading

A GTS file can be loaded with gts_load.

#include "colors.inc"
camera { location <3,5,-4>
	direction z
		up y
		right image_width/image_height*x
		look_at <-1/2,1/2,0>
		angle 35
}

light_source{ <-5, 20, -20>, 1}
light_source{ <0, 2, 0>, 1/2}

gts_load{ "bunny.gts"
	right
	rotate 180*y	
	scale 17
	translate -2*y
	texture { pigment { color Aquamarine}}
}

Aside from the filename of the file to load, the right keyword can be used to change the default left-handed coordinate system to a right-handed one.

gts_load can be used to create a mesh of its own or to incorporate the mesh of the file into a larger mesh, in which case a texture identifier can be applied over the loaded GTS mesh.

 mesh { ...
    gts_load { filename [right] [texture { Tid }] }
  ...
 }

OR

 gts_load { filename [right] 

 [Object_Mods...]
 }

Saving

A mesh can be saved with gts_save. Beware of I/O restrictions.

gts_save { filename, mesh_object }

GTS format saves the geometry, but neither the faked normal or the textures

Getting a new mesh from a mesh

The following method (or pseudo-object) can be used only on a mesh, whatever its origin.

Whatever the method used (it will always end as a mesh object, or inside a mesh object). there is some common parameters:

original is the mesh used as the base object (it is not updated, it is used as data source)
albinos is an option which remove all textures on the generated triangles

bend

Curve the mesh along a line, using a reference half-plane containing that line.

bend  { original Objiii 
        origin 0  
        amount 30 
        fixed z 
        direction y
        minimal -0.0
        maximal 2.0 }

bend  { original Objiii 
        origin 0  
        amount 30 
        fixed y 
        direction z
        minimal -50.0
        maximal 2.0 }

 mesh { ...
   bend {
    original mesh_object
    [albinos]  [amount float]  [direction vector]  [fixed vector]  [maximal float]  [minimal float]
    [modulation { texture_description }]  [origin vector]  [texture { Tid }]
   } 
 ...
 }

OR

 bend {
  original mesh_object
  [albinos]  [amount float]  [direction vector]  [fixed vector]  [maximal float]  [minimal float]
  [modulation { texture_description }]  [origin vector]

 [Object_Mods...]
 }

original mesh_object : the original mesh object whose data are used as source for the new mesh
albinos : do not copy the texture from the original mesh
amount float : angle of rotation (in degree) for a unit length. The rotation is proportional to the length.
direction vector : axis of the rotation, only the direction is taken into account.
fixed vector : axis of the zero-plane (origin, origin+direction & origin+fixed points are all contained inside the zero-plane: the plane with no transformation)
maximal float : when length is bigger, the transformation is limited to the float.
minimal float : when length is smaller, the transformation is limited to the float.
modulation { texture_description } : the luminosity of the colour from the texture evaluated at the vertex is used to ponder the deformation effect; full black means no transformation, white (<1,1,1>) means 100%.
origin vector : vertex used as the origin of the transformation's reference base.

displace

Move each vertex of a triangle along its normal.

Be careful: as a vertex might appears in more than one triangle, if the normal at a vertex is not the same for all the triangles sharing that vertex, the displacement would create cracks in the resulting mesh as each triangles move away.

 mesh{ ...
  displace {
    modulation { texture_description }
    original mesh_object
    [albinos]  [amount float]  [offset float]  [texture { Tid } ]
  }
  ...
 }

OR
 
 displace {
  modulation { texture_description }
  original mesh_object
  [albinos] [amount float] [offset float]

 [Object_Mods...]
 }

original mesh_object : the original mesh object whose data are used as source for the new mesh
modulation { texture_description } : the luminosity of the colour from the texture evaluated at the vertex is used to ponder the deformation effect; full black means no transformation, white (<1,1,1>) means 100%.
albinos : do not copy the texture from the original mesh
amount float : length of displacement for 100%.
offset : offset applied to the luminosity.

move

Transforms the coordinates of each points.

mesh { ...
  move {
   original mesh_object
   [albinos] [modulation { texture_description } ] [move < coeff_of_matrix(12) >] [ texture { Tid } ]

} 
  ...
}

OR

move {
    original mesh_object
    [ albinos ] [modulation { texture_description } ] [ move < coeff_of_matrix(12) > ]

[Object_Mods...]
}

The starting point is used with the movematrix to produce a end point. The resulting deplacement is then modulated by the luminosity of the modulation texture to produce the final point.

The matrix is the usual transformation matrix.

#include "colors.inc"
#default { finish { ambient 0.5 specular 0.5 } }
camera { location <6,6,12> direction  -z right x up y look_at 0 angle 25 }
light_source { <-30,100,50>, 1 }

#declare tt=texture { pigment { spiral2 6 scale 2 translate -y*0.95 pigment_map { 
[0 Black]
[1 Gray20]
} } }
 
#declare msize=3.0;
move { original cristal { accuracy 150 original sphere { 0,msize } }
modulation { tt }
move < 0.6,+0.4,0, 0,1,0, 0,-0.2,0.1, 0,0,0 >
pigment { Yellow } 
}

roll

original mesh_object : the original mesh object whose data are used as source for the new mesh
albinos : do not copy the texture from the original mesh
modulation { texture_description } : the luminosity of the colour from the texture evaluated at the vertex is used to ponder the deformation effect; full black means no transformation, white (<1,1,1>) means 100%.
direction vector : vector of the rotation (as usual) for a unit length along that vector.
maximal float : when rotation's angle is bigger, the transformation is limited to the float.
minimal float : when rotation's angle is smaller, the transformation is limited to the float.
origin vector : vertex used as the origin of the transformation's reference base.

mesh{ ...
  roll {
    original mesh_object
    [albinos] [direction vector] [maximal float] [minimal float] [modulation { texture_description }]
    [origin vector]
    [texture { Tid }]
  }
  ...
}

OR

roll {
    original mesh_object
    [albinos] [direction vector] [maximal float] [minimal float] [modulation { texture_description }]
    [origin vector]

[Object_Mods...]
}

screw

#default { pigment { rgb <1,.8,.6> } finish { specular .5 } }
#declare Objiii = cubicle { original box { <-0.5,-3.5,-0.5>,<0.5,3.5,0.5>  } accuracy <20,120,20> }
#local i=0;
#while (i<15)
screw  { original Objiii origin 0  direction i*20*y
  #if (mod(i,3)=1) minimal -30.0 maximal i*45.0 #end
  #if (mod(i,4)=0) right #end
rotate 30*x*mod(i+1,2)  translate i*2*x } 
#local i=i+1;
#end
camera { location <14.0,0,150> up 8*y right 8*x*image_width/image_height direction -z angle 12 }
light_source { <200,100,-150>, z }
light_source { <00,10,150>, 1 }
light_source { <200,100,100>, x }
light_source { 0, y }

original mesh_object : the original mesh object whose data are used as source for the new mesh
albinos : do not copy the texture from the original mesh
modulation { texture_description } : the luminosity of the colour from the texture evaluated at the vertex is used to ponder the deformation effect; full black means no transformation, white (<1,1,1>) means 100%.
direction vector : vector of the rotation (as usual) for a unit length along that vector.
maximal float : when rotation's angle is bigger, the transformation is limited to the float.
minimal float : when rotation's angle is smaller, the transformation is limited to the float.
origin vector : vertex used as the origin of the transformation's reference base.
right : inverse the handedness of the the screw (on a default left-handed scene, the default screw is the traditional clockwise; right allows to produce the chiral one)

mesh{ ...
  screw {
    original mesh_object
    [albinos] [direction vector] [maximal float] [minimal float] [modulation { texture_description }]
    [origin vector] [right]
    [texture { Tid }]
  }
  ...
}

OR

screw {
    original mesh_object
    [albinos] [direction vector] [maximal float] [minimal float] [modulation { texture_description }]
    [origin vector] [right]

[Object_Mods...]
}

keep

Keep only part(s) of a mesh, relative to a 3D object. Four parts are possible:

inner all 3 vertices of a triangle are inside the 3D object.
inbound only 2 vertices of a triangle are inside.
outbound only 1 vertex of a triangle is inside.
outside all 3 vertices of a triangle are not inside the 3D object.

A keep selection can select as many parts as wanted for the resulting mesh, but will only use a single 3D object.

keep { original Foobar_Mesh 
  with intersection { 
            box { <-1,-1,-1>,<4,haut+1,0.04> } 
            sphere { <1.5,haut/2,0>,haut*2/5 }
       }
   outside
}

mesh{ ...
  keep {
    original mesh_object
    with solid_object
    [albinos] [inbound] [inner] [outbound] [outside]
    [texture { Tid }]
  }
  ...
}

OR

keep {
    original mesh_object
    with solid_object
    [albinos] [inbound] [inner] [outbound] [outside]

[Object_Mods...]
}

smooth

#include "colors.inc"
background { rgb z *.5}
#declare T1= texture { pigment { rgb <1,.8,.6> } finish { specular .5 } };
#declare T2= texture { pigment { rgb <.8,.6,1> } finish { specular .5 } };
#declare T3= texture { pigment { rgb <.6,1,.8> } finish { specular .5 } };
#default { texture { T1 }}
#declare Obj = sphere { 0,1 texture { T3} }
#declare Spacing = 2.1;
#declare Tes= tessel { original Obj accuracy 3 offset 0.1 albinos texture { T2 } }
object { Obj translate x*4*Spacing }

object { Tes translate -x*Spacing }
#for(i,0,3,1)
smooth { original Tes method i translate Spacing*x*i }
#end

camera { orthographic location < 0, 4, -18 > *2.1 up y right image_width/image_height*x
look_at < 0, 0, 0 > angle 37 / 2 translate Spacing*x*1.5 }
light_source { <200, 100, -150 >, 1}
light_source { <-200, 100, -100 >, x * .5}

mesh{...
  smooth {
    original mesh_object
    [albinos] [amount float] [method float] [texture { Tid }]
  } 
...
}

OR

smooth {
    original mesh_object
    [albinos] [amount float] [method float ]

  [Object_Mods...]
}

Perturbate the normal of each triangle. By default the perturbation is toward a smoother surface.

amount float : the amount of displacement of the normals toward the unified normal at that vertex. 1 (=100%) by default.
method index : how to compute the unified normal (default to 0)
- 0 : basic average of all contributing normals
- 1 : weighted average, the weight is the angle at the vertex
- 2 : weighted average, the weight is the product of the lengths of segments at the vertex
- 3 : weighted average, the weight is the surface of the triangle

warp

#version 3.7;
global_settings { assumed_gamma 1.0 }
#include "colors.inc"

camera { location <9.3,1.5/2,-100> up y direction z
right image_width/image_height*x look_at <9.3,1.5/2,0> angle 11 }
#declare T0= texture { pigment { Gold } }

light_source { <-30,100,-100>,1 }
light_source { <0,00,-100>,1 }

#declare Obj1= union {
        box { <0,0,0>,<1,1.5,30> texture { pigment { Blue } } }
        box { <1,0,0>,<2,1.5,30> texture { pigment { White } } }
        box { <2,0,0>,<3,1.5,30> texture { pigment { Red } } }
        box { <1.45,0.3,-0.001>,<1.55,1.2,0> texture { T0 } }
        box { <1.2,0.70,-0.001>, <1.8,0.80,0> texture { T0 } }
        box { <1.325,0.925,-0.001>, <1.675,1.025,0> texture { T0 } }
      }

#declare Vector =  <0.1,0.2,0.3>;

#declare Boring_mesh= keep { original tesselate { original  Obj1 offset 0.1 accuracy <100,50,2> }
		with box { <-1,-1,-1>,<4,1.5+1,0.04> } inner };

object { Boring_mesh  }
#for(i,1,5,1)
warp { original Boring_mesh warp { turbulence Vector octaves i } 
			 translate 3.15*i*x }
#end

mesh{...
  warp {
    original mesh_object warp warp_description
    [albinos] [modulation { texture_description } ] [move <coeff_ot_matrix(12)>] [texture { Tid }]
  } 
...
}

OR
warp {
    original mesh_object warp warp_description
    [albinos] [modulation { texture_description } ] [move <coeff_ot_matrix(12)>]
    
  [Object_Mods...]
}

See move for the details about modulation. The matrix provided with move is applied to the points before evaluating the warp (useful in animation for moving an object in the wind: as the wind progress, the translation of the matrix does also).

proximity pattern

#declare test_object = 
  julia_fractal {
    <0.1,0.8,-0.1,0.002> quaternion sqr
    max_iteration 8
    precision 1000
    scale 60 translate y*60 rotate y*45
}

object {  test_object
  texture {
    proximity { test_object } radius 10
    texture_map {
      [ 0.0 pigment { rgb <0,169,224>/255 } ]
      [ 0.2 pigment { rgb <50,52,144>/255 } ]
      [ 0.4 pigment { rgb <234,22,136>/255 } ]
      [ 0.6 pigment { rgb <235,46,46>/255 } ]
      [ 0.8 pigment { rgb <253,233,45>/255 } ]
      [ 1.0 pigment { rgb <0,158,84>/255 } ]
    }
  }
}

proximity { Object_Description } [ PATTERN_MODIFIER | radius Radius_of_Sampling ]...

The default radius of sampling is 1.0. A weighted sampling is performed inside the sphere around the intersection, returning a value between 0.0 (all insideness tests failed) and 1.0 (all tests succeed). Usual value (for flat surface) would be around 0.5, edge of box dropping to 0.25 and corners of box to 0.125 (1/8 of the sphere).

Getting a copy of an object inside a CSG

A small SDL extension, to retrieve the object inside an existing CSG.

child { CSG_Object_ID }( Index )

The index start at 0 for the first child of the CSG. Only the first level of the CSG is explored (recursion in CSG structure must be handled the same way: with recursion).

patterns with list of objects

binary { OBJECT_LIST } [ PATTERN_MODIFIERS ]

proportion { OBJECT_LIST } [ PATTERN_MODIFIERS ]

OBJECT_LIST = Object_Description [ OBJECT_LIST ]

proportion pattern

For a list of N objects, perform an insideness test for each of them and compute a number k/N, where k is the number of success for insideness test.

binary pattern

Take into account the position of the object in the list to weight it.

As for proportion, it use insideness testing. but the contribution of the k-th object is 1/(2^k).

The value is 1 if all tests succeed, and has a lower limit of 1/(2^N) (which tends to 0 very rapidly).

Vault

User:Le_Forgeron/vault

Camera

You knew orthographic, ultra_wide_angle, spherical, omnimax, fisheye, perspective and others, here a few new kinds.

The recommendation about the ratio is for the the final picture's dimensions, assuming square pixels.

aitoff_hammer

Recommended ratio is 2:1

eckert_iv

Recommended ratio is 2:1

eckert_vi

Recommended ratio is 2:1

lambert_azimuthal

Recommended ratio is 1:1

mercator

Recommended ratio is up to you, as you need a very large height/wide to hope reaching the poles (nah, it's impossible with that projection).

miller_cylindrical

Recommended ratio is 1.3638862 or 1:0.733

mollweide

Recommended ratio is 2:1

plate_carree

Recommended ratio is 2:1

van_der_grinten

Recommended ratio is 1:1

Cylindrical Equal Area Projection

formula for ratio is π.cos²(φ) with φ the standard parallel.

balthasart

Recommended ratio is about 1.3.

The standard parallel of the projection is 50°.

behrmann

Recommended ratio is 3π:4 (about 2.36)

The standard parallel of the projection is 30°.

edwards

Recommended ratio is about 2.

The standard parallel of the projection is 37°24'.

gall

Recommended ratio is π:2 or golden ratio (φ) (both near 1.6).

The standard parallel of the projection is 45°.

hobo_dyer

Recommended ratio is about 2.

The standard parallel of the projection is 37°30'.

lambert_cylindrical

Recommended ratio is π

The standard parallel of the projection is 0°.

peters

Recommended ratio is about π:2 or golden ratio φ (not exactly the same thing, but around 1.6).

The standard parallel of the projection is 44.138°.

smyth_craster

Recommended ratio is about 2.

The standard parallel of the projection is 37°04'.

Unfolding platonic

icosa

Recommended ratio is about 2.1169 ( 11.sqrt(3):9 )

octa

Recommended ratio is about 2.3 ( 4:sqrt(3) )

tetra

Recommended ratio is about 2.886 ( 5:sqrt(3) )

User:Le Forgeron

Interesting documents & link

Splines

Accessing splines data

Additional types of splines

Sor spline

akima spline

tcb spline

x splines

basic x spline

extended x spline

general x spline

Colour space interpolation

Which colourspace ?

pov

hsl or hsv

xyl or xyv

Mesh

blob

Interpolation for polygon

Access to camera information

Tesselation & mesh play

Mesh from 3D finite object

Without texture, using only Inside test (fast)

Using Inside test & trace (slower)

Mesh from and to file

Loading

Saving

Getting a new mesh from a mesh

bend

displace

move

roll

screw

keep

smooth

warp

proximity pattern

Getting a copy of an object inside a CSG

patterns with list of objects

proportion pattern

binary pattern

Vault

Camera

aitoff_hammer

eckert_iv

eckert_vi

lambert_azimuthal

mercator

miller_cylindrical

mollweide

plate_carree

van_der_grinten

Cylindrical Equal Area Projection

balthasart

behrmann

edwards

gall

hobo_dyer

lambert_cylindrical

peters

smyth_craster

Unfolding platonic

icosa

octa

tetra

Navigation menu

Search