en to nl translation catalogue (173 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
nl: float abs(float x)
    absolute waarde van x

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
nl: float deg(float hoek)
    radialen naar graden

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
nl: float rad(float hoek)
    graden naar radialen

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
nl: float cosd(float hoek)
    cosinus in graden

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
nl: float sind(float hoek)
    sinus in graden

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
nl: float tand(float hoek)
    tangens in graden

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
nl: float acosd(float getal)
    arccosinus in graden

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
nl: float asind(float getal)
    arcsinus in graden

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
nl: float atand(float getal)
    arctangens in graden

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
nl: float atan2d(float y,float x)
    arctangens in graden van y/x tussen -180 en 180

[ctx: builtin|]
en: float cos(float angle)
    cosine in radians
nl: float cos(float hoek)
    cosinus in radialen

[ctx: builtin|]
en: float sin(float angle)
    sine in radians
nl: float sin(float hoek)
    sinus in radialen

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
nl: float tan(float hoek)
    tangens in radialen

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
nl: float acos(float getal)
    arccosinus in radialen

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
nl: float asin(float getal)
    arcsinus in radialen

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
nl: float atan(float getal)
    arctangens in radialen

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
nl: float atan2(float y,float x)
    arctangens in radialen van y/x tussen -PI en PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
nl: float cosh(float hoek)
    hyperbolische cosinus in radialen

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
nl: float sinh(float hoek)
    hyperbolische sinus in radialen

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
nl: float tanh(float hoek)
    hyperbolische tangens in radialen

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
nl: float acosh(float getal)
    hyperbolische arccosinus in radialen

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
nl: float asinh(float getal)
    hyperbolische arcsinus in radialen

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
nl: float atanh(float getal)
    hyperbolische arctangens in radialen

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
nl: float clamp(float x,float laag,float hoog)
    beperk x tot domein [laag, hoog]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
nl: float round(float x)
    geheel getal dichtst bij x

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
nl: float max(float a,float b)
    grootste van a en b

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
nl: float min(float a,float b)
    kleinste van a en b

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
nl: float trunc(float a)
    dichtstbijzijnd geheel getal in de richting van 0

[ctx: builtin|]
en: float floor(float a)
    next lower integer
nl: float floor(float a)
    eerstvolgend kleiner geheel getal

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
nl: float ceil(float a)
    eerstvolgend groter geheel getal

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
nl: float invert(float a)
    Gedefinieerd als 1-x

[ctx: builtin|]
en: float cbrt(float x)
    cube root
nl: float cbrt(float x)
    derdemachts wortel

[ctx: builtin|]
en: float sqrt(float x)
    square root
nl: float sqrt(float x)
    (vierkants) wortel

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
nl: float exp(float x)
    e tot de macht x

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
nl: float pow(float x, float y)
    x tot de macht y, ook mogelijk met ^

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
nl: float log(float x)
    natuurlijke logaritme

[ctx: builtin|]
en: float log10(float x)
    Base 10 logarithm
nl: float log10(float x)
    logaritme met grondtal 10

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
nl: float fmod(float x,float y)
    rest van x/y (ook mogelijk met x%y)

[ctx: builtin|]
en: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolute value of each noise term is taken. This gives billowy appearance
nl: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Met absolute waarde van elke ruisterm. Ziet er golvend uit

[ctx: builtin|]
en: color cturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolute value of each noise term is taken. This gives billowy appearance
nl: color cturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Met absolute waarde van elke ruisterm. Ziet er golvend uit

[ctx: builtin|]
en: vector vturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolute value of each noise term is taken. This gives billowy appearance
nl: vector vturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Met absolute waarde van elke ruisterm. Ziet er golvend uit

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
nl: float compress(float x,float laag,float hoog)
    Beeldt x af van [0,1] naar [laag,hoog]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
nl: float expand(float x,float laag,float hoog)
    Beeldt x af van [laag,hoog] naar [0, 1]

[ctx: builtin|]
en: float fit(float x,float a1,float b1,float a2,float b2)
    Linearly remaps x in [a1,b1] to [a2,b2]
nl: float fit(float x,float a1,float b1,float a2,float b2)
    Lineair afbeelden van x van [a1,b1] naar [a2,b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
nl: float gamma(float x, float g)
    gammacorrectie van x met gammafactor g

[ctx: builtin|]
en: float bias(float x, float g)
    Variation of gamma where values less than 0.5 pull the curve down
    and values greater than 0.5 pull the curve up
    pow(x,log(b)/log(0.5))
nl: float bias(float x, float g)
    Variatie van gamma, waarbij waarden kleiner dan 0.5 de kromme neertrekken
    en waarden groter dan 0.5 de kromme omhoog trekken
    pow(x,log(b)/log(0.5))

[ctx: builtin|]
en: float contrast(float x, float c)
    Adjust the contrast.&nbsp; For c from 0 to 0.5, the contrast is decreased.&nbsp; For c &gt; 0.5, the contrast is increased.
nl: float contrast(float x, float c)
    Contrast aanpassen.&nbsp; Bij c van 0 tot 0.5 neemt het contrast af .&nbsp; Bij c &gt; 0.5 neemt het contrast toe.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
nl: float boxstep(float x,float a)
    als x < a dan 0 en anders 1

[ctx: builtin|]
en: float linearstep(float x, float a, float b)
     if x &lt; a then 0, if x &gt; b then 1, and
    x transitions linearly when a &lt; x &lt; b
nl: float linearstep(float x, float a, float b)
     als x &lt; a dan 0, als x &gt; b dan 1, en
    x verloopt lineair als a &lt; x &lt; b

[ctx: builtin|]
en: float smoothstep(float x,float a,float b)
     if x &lt; a then 0, if x &gt; b then 1, and
    x transitions smoothly (cubic) when a &lt; x &lt; b
nl: float smoothstep(float x,float a,float b)
    als x &lt; a dan 0, als x &gt; b dan 1, en
    x verloopt vloeiend (kubisch) als a &lt; x &lt; b

[ctx: builtin|]
en: float gasussstep(float x,float a,float b)
     if x &lt; a then 0, if x &gt; b then 1, and
    x transitions smoothly (exponentially) when a &lt; x &lt; b
nl: float gaussstep(float x,float a,float b)
     als x &lt; a dan 0, als x &gt; b dan 1, en
    x verloopt vloeiend (exponentieel) als a &lt; x &lt; b

[ctx: builtin|]
en: remap(float x, float source, float range, float falloff, float interp)
    General remapping function.
    When x is within +/- <i>range</i> of source, the result is one.
    The result falls to zero beyond that range over <i>falloff</i> distance.
    The falloff shape is controlled by <i>interp</i>. Numeric values
    or named constants may be used:
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>linear</b> = 0
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>smooth</b> = 1
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>gaussian</b> = 2
nl: remap(float x, float bron, float bereik, float afval, float interp)
    Algemene functie voor afbeelden.
    Wanneer x +/- binnen het <i>bereik</i> is van bron, is het antwoord een.
    Het resultaat wordt nul op meer dan <i>afval</i>  buiten bereik.
    De vorm van afval wordt geregeld met <i>interp</i>. U kunt getallen
    gebruiken of constanten met een waarde:
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>lineair</b> = 0
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>glad</b> = 1
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>gaussisch</b> = 2

[ctx: builtin|]
en: mix(float a,float b,float alpha)
    Blend of a and b according to alpha.
nl: mix(float a,float b,float alpha)
    mengen van a en b volgens alpha.

[ctx: builtin|]
en: color  hsi(color x, float h, float s, float i, float map=1)
    The hsi function shifts the hue by h
    (in degrees) and scales the saturation and intensity by s and i
    respectively.&nbsp; A map may be supplied which will control the shift
    - the full shift will happen when the map is one and no shift will
    happen when the map is zero.&nbsp; The shift will be scaled back for
    values between zero and one.
nl: color  hsi(color x, float h, float s, float i, float map=1)
    de hsi function verschuift kleur met h
    (in graden) en schaalt de verzadiging en intensiteit met s en i.
    &nbsp; Met optioneel map kan de verschuiving worden geregeld
    - volledig wanneer map 1 is, en geen verandering wanneer map
    0 is.&nbsp; De verschuiving wordt voor waarden tussen 0 en 1 terug geschaald.

[ctx: builtin|]
en: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    The midhsi function is just like the hsi function except that
    the control map is centered around the mid point (value of 0.5)
    and can scale the shift in both directions.
nl: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    midhsi is gelijk aan de functie hsi behalve dat
    de besturing map werkt rond het midden (waarde 0.5)
    en de verschuiving in beide richtingen kan schalen.

[ctx: builtin|]
en: color rgbtohsl(color rgb)
    RGB to HSL color space conversion.
    HSL is Hue, Saturation, Lightness (all in range [0..1] )
    These functions have also been extended to support rgb and hsl values
    outside of the range [0..1] in a reasonable way.&nbsp; For any rgb or
    hsl value (except for negative s values), the conversion is
    well-defined and reversible.
nl: color rgbtohsl(color rgb)
    Omzetting kleurruimten van RGB naar HSL.
    HSL is Hue (kleur), Saturation (verzadiging), Lightness (lichtheid)
    (alles in bereik [0..1] )
    Deze functies zijn ook op redelijke manier uitgebreid voor rgb- en hsl-waarden
    buiten het bereik [0..1].&nbsp; Voor elke rgb- of hsl-waarde
     (behalve negatieve getallen), is de omzetting goed gedefinieerd en omkeerbaar.

[ctx: builtin|]
en: color hsltorgb(color hsl)
    HSL to RGB color space conversion.
    HSL is Hue, Saturation, Lightness (all in range [0..1] )
    These functions have also been extended to support rgb and hsl values
    outside of the range [0..1] in a reasonable way.&nbsp; For any rgb or
    hsl value (except for negative s values), the conversion is
    well-defined and reversible.
nl: color hsltorgb(color hsl)
    omzetting kleurruimten van HSL naar RGB.
    HSL is Hue (kleur), Saturation (verzadiging), Lightness (lichtheid)
    (alles in bereik [0..1] )
    Deze functies zijn ook op redelijke manier uitgebreid voor rgb- en hsl-waarden
    buiten het bereik [0..1].&nbsp; Voor elke rgb- of
    hsl-waarde (behalve negatieve getallen), is de omzetting goed gedefinieerd en omkeerbaar.

[ctx: builtin|]
en: color saturate(color val, float amt)
    Scale saturation of color by amt.
    The color is scaled around the rec709 luminance value,
    and negative results are clamped at zero.
nl: color saturate(color getal, float amt)
    Kleurverzadiging schalen met amt.
    De kleur wordt geschaald rond de luminantiewaarde rec709,
    en negatieve resultaten worden beperkt tot nul.

[ctx: builtin|]
en: float rand ( [float min, float max], [float seed] )
    Random number between [min, max] (or [0, 1] if unspecified).
    If a seed is supplied, it will be used in addition to the internal seeds and may be used to create multiple distinct generators.
nl: float rand ( [float min, float max], [float zaadje] )
    Willekeurig getal tussen [min, max] (of [0, 1] indien niet genoemd).
    Als een zaadje wordt gegeven wordt dat gebruikt naast de interne zaadjes, en kan het worden gebruikt voor het aanmaken van meerdere afzonderlijke generatoren.

[ctx: builtin|]
en: float hash(float seed1,[float seed2, ...])
    Like rand, but with no internal seeds. Any number of seeds may be given
    and the result will be a random function based on all the seeds.
nl: float hash(float zaadje1,[float zaadje2, ...])
    Als rand, maar zonder interne zaadjes. Elk aantal zaadjes is mogelijk
    en het gegeven antwoord  is afhankelijk van alle gegeven zaadjes.

[ctx: builtin|]
en: float noise ( vector v )
    float noise ( float x, float y )
    float noise ( float x, float y, float z )
    float noise ( float x, float y, float z, float w )
    Original perlin noise at location (C2 interpolant)
nl: float noise ( vector v )
    float noise ( float x, float y )
    float noise ( float x, float y, float z )
    float noise ( float x, float y, float z, float w )
    Originele perlin ruis op locatie (C2 interpolant)

[ctx: builtin|]
en: float snoise ( vector v)
    signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
nl: float snoise ( vector v)
    ruis met teken binnen bereik -1 tot 1 gevormd met originele perlin ruis op locatie (C2 interpolant)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
nl: vector vnoise ( vector v)
    vector ruis gevormd met originele perlin ruis op locatie (C2 interpolant)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
nl: color cnoise ( vector v)
    kleur ruis gevormd met originele perlin ruis op locatie (C2 interpolant)

[ctx: builtin|]
en: float snoise4 ( vector v,float t)
    4D signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
nl: float snoise4 ( vector v,float t)
    4D ruis met teken, binnen bereik -1 tot 1 gevormd met originele perlin ruis op locatie (C2 interpolant)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
nl: vector vnoise4 ( vector v,float t)
    4D vector ruis met teken, binnen bereik -1 tot 1 gevormd met originele perlin ruis op locatie (C2 interpolant)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
nl: color cnoise4 ( vector v,float t)
    4D kleur ruis met teken gevormd met originele perlin ruis op locatie (C2 interpolant)

[ctx: builtin|]
en: float fbm(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractal Brownian Motion) is a multi-frequency noise function. 
    The base frequency is the same as the "noise" function. The total number of frequencies is controlled by octaves. The lacunarity is the spacing between the frequencies - a value of 2 means each octave is twice the previous frequency. The gain controls how much each frequency is scaled relative to the previous frequency.
nl: float fbm(vector v,int octaves=6,float lacunariteit=2,float versterking=.5)
    fbm (Fractale Brownse beweging) is een multi-frequentie ruis functie. 
    The basis frequentie is gelijk aan de "noise" (ruis) functie. Het totale aantal van de frequenties wordt geregeld met octaves. The lacunariteit regelt deafstand tussen de frequenties - een waarde 2 betekent dat elke octaaf twee keer de voorgaande frequentie is. De versterking regelt de schaal van elke frequentie vergeleken met die van de vorige frequentie.

[ctx: builtin|]
en: vector vfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
nl: vector vfbm(vector vint octaves=6,float lacunariteit=2,float versterking=.5)

[ctx: builtin|]
en: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractal Brownian Motion) is a multi-frequency noise function. 
    The base frequency is the same as the "noise" function. The total 
    number of frequencies is controlled by octaves. The lacunarity is the 
    spacing between the frequencies - a value of 2 means each octave is 
    twice the previous frequency. The gain controls how much each 
    frequency is scaled relative to the previous frequency.
nl: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractale Brownse beweging) is een multi-frequentie ruis functie. 
    The basis frequentie is gelijk aan de "noise" (ruis) functie. Het totale 
    aantal van de frequenties wordt geregeld met octaves. The lacunariteit regelt de
    afstand tussen de frequenties - een waarde 2 betekent dat elke octaaf 
    twee keer de voorgaande frequentie is. De versterking regelt de schaal van 
    elke frequentie vergeleken met die van de vorige frequentie.

[ctx: builtin|]
en: vector vfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
nl: vector vfbm4(vector v,float time,int octaves=6,float lacunariteit=2,float versterking=.5)

[ctx: builtin|]
en: color cfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
nl: color cfbm(vector vint octaves=6,float lacunariteit=2,float versterking=.5)

[ctx: builtin|]
en: color cfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
nl: color cfbm4(vector v,float time,int octaves=6,float lacunariteit=2,float versterking=.5)

[ctx: builtin|]
en: float cellnoise(vector v)
    cellnoise generates a field of constant colored cubes based on the integer location.
    This is the same as the prman cellnoise function.
nl: float cellnoise(vector v)
    cellnoise genereert een veld van constant gekleurde kubussen op basis van de gehele locatie.
    Dit is gelijk aan de prman cellnoise functie.

[ctx: builtin|]
en: color cellnoise(vector v)
    cellnoise generates a field of constant colored cubes based on the integer location.
    This is the same as the prman cellnoise function.
nl: color cellnoise(vector v)
    cellnoise genereert een veld van constant gekleurde kubussen op basis van de gehele locatie.
    Dit is gelijk aan de prman cellnoise functie.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
nl: float pnoise ( vector v, vector periode )
    periodieke ruis

[ctx: builtin|]
en: float voronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    voronoi is a cellular noise pattern. It is a jittered variant of cellnoise.
nl: float voronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunariteit=2, float fbmGain=.5)
    voronoi is een cellulair ruispatroon. Het is een springerige variant van cellnoise.

[ctx: builtin|]
en: color cvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    returns color in cellular pattern. It is a jittered variant of cellnoise.
nl: color cvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunariteit=2, float fbmGain=.5)
    geeft kleur terug in cellulair patroon. Het is een springerige variant van cellnoise.

[ctx: builtin|]
en: color pvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    returns center of voronoi cell.
nl: color pvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunariteit=2, float fbmGain=.5)
    geeft centrum terug van voronoi cel.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
nl: float dist(vector a, vector b)
    afstand tussen twee punten

[ctx: builtin|]
en: float length(vector v)
    length of vector
nl: float length(vector v)
    lengte van vector

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
nl: float hypot(vector v)
    lengte van 2d vector [x,y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
nl: float dot(vector a,vector b)
    vector inproduct

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
nl: vector norm(vector v)
    tot lengte 1 geschaalde vector

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
nl: vector cross(vector a,vector b)
    vector uitproduct

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
nl: float angle(vector a,vector b)
    hoek tussen twee vectoren (in radialen)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
nl: vector angle(vector a,vector b)
    genormaliseerde vector loodrecht op  a en b geschaald naar lengte 1

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
nl: vector rotate(vector v,vector as, float hoek)
    roteert v rond as over een gegeven hoek (in radialen)

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
nl: vector up(vector P,vector upvec)
    roteert v zodanig dat de Y-as wijst in de gegeven richting van upvec

[ctx: builtin|]
en: int cycle(int index, int loRange, int hiRange )
    Cycles through values between loRange and hiRange based on supplied index.
    This is an offset "mod" function. The result is computed as ``loRange + value % (hiRange-loRange+1)``.
nl: int cycle(int index, int laag, int hoog )
    cyclisch gaan door de waarden tussen laag en hoog, op basis van de gegeven index.
    Dit is een offset "mod"-functie. Het antwoord wordt berekend als "laag + waarde % (hoog - laag) +1 ".

[ctx: builtin|]
en: int pick(float index, int loRange, int hiRange, [float weights, ...] )
    Picks values randomly between loRange and hiRange based on supplied index (which is
    automatically hashed).&nbsp; The values will be distributed according
    to the supplied weights.&nbsp; Any weights not supplied are assumed to
    be 1.0.
nl: int pick(float index, int laag, int hoog, [float gewichten, ...] )
    Kiest willekeurig  waarden tussen laag en hoog op basis van de opgegeven index(met automatische hash
    . &nbsp; De waarden worden verdeeld volgens de opgegeven
    gewichten.&nbsp;Een niet opgegeven gewicht wordt verondersteld 1.0 te zijn.

[ctx: builtin|]
en: color swatch(float index, color choice0, color choice1, color choice2, [...])
    Chooses one of the supplied color choices based on the index (assumed to be in range [0..1]).
nl: color swatch(float index, color keuze0, color keuze1, color keuze2, [...])
    Kiest een van de opgegeven kleurkeuzes op basis van de index ( volgens aanname in bereik [0..1]).

[ctx: builtin|]
en: float choose(float index,float choice1, float choice2, [...])
    Chooses one of the supplied choices based on the index (assumed to be in range [0, 1]).
nl: float choose(float index,float keuze1, float keuze2, [0, ])
    Kiest een van de opgegeven keuzes op basis van de index ( volgens aanname in bereik [0..1]).

[ctx: builtin|]
en: float wchoose(float index,float choice1, float weight1, float choice2, float weight2, [...] )
    Chooses one of the supplied choices based on the index (assumed to be in range [0..1]).
    The values will be distributed according to the supplied weights.
nl: float wchoose(float index,float keuze1, float gewicht1, float keuze2, float gewicht2, [...] )
    Kiest een van de opgegeven keuzes op basis van de index ( volgens aanname in bereik [0..1]).
    De waarden worden verdeeld naar de opgegeven gewichten.

[ctx: builtin|]
en: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Interpolates a set of values to the parameter specified where y1, ..., yn are
    distributed evenly from [0..1]
nl: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Interpoleert een aantal waarden naar de opgegeven parameter, hierin
     zijn y1,...,y2 gelijkmatig verdeeld over [0..1]

[ctx: builtin|]
en: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpolates a 1D ramp defined by control points at 'param'. Control points are specified 
    by triples of parameters pos_i, val_i, and interp_i. Interpolation codes are 
    0 - none, 1 - linear, 2 - smooth, 3 - spline, 
    4 - monotone (non oscillating spline)
nl: float curve(float param,float pos0,float waarde0,int interp0,float pos1,float waarde1,int interp1,[...])
    
    Interpoleert 1D helling gedefinieerd  door de controlepunten in 'param'. Controlepuntenworden opgegeven met 
    drietallen parameters posi, waardei, and interpi. Interpolatiecodes zijn 
    0 - geen, 1 - lineair, 2 - glad, 3 - spline, 
    4 - monotoon (niet-oscillerende spline)

[ctx: builtin|]
en: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpolates color ramp given by control points at 'param'. Control points are specified 
    by triples of parameters pos_i, val_i, and interp_i. Interpolation codes are 
    0 - none, 1 - linear, 2 - smooth, 3 - spline, 
    4 - monotone (non oscillating spline)
nl: color curve(float param,float pos0,float waarde0,int interp0,float pos1,float waarde1,int interp1,[...])
    
    Interpoleert kleurenhelling gedefinieerd  door de controlepunten in 'param'. Controlepuntenworden opgegeven met 
    drietallen parameters posi, waardei, and interpi. Interpolatiecodes zijn 
    0 - geen, 1 - lineair, 2 - glad, 3 - spline, 
    4-monotoon (niet-oscillerende spline)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
nl: getVar(string varNaam,vector standaardWaarde)
    geeft waarde terug van varNaam indien variable bestaat, en anders de standaardWaarde

[ctx: builtin|]
en: float printf(string format,[vec0, vec1,  ...])
    Prints out a string to STDOUT, Format parameters allowed are "%v" and "%f".
    Return parameter is empty, but must be assigned to a variable.
nl: float printf(string format,[vec0, vec1,  ...])
    Stuurt een tekenreeks naar STDOUT, Format parameters zijn "%v" en "%f".
    Teruggegeven parameter is leeg, maar moet aan een variabele worden toegekend.

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
nl: sprintf(string format, [double|string, double|string, ...])
    Geeft tekenreeks terug geformatteerd naar de gegeven waarden. Zie 'man sprintf'  voor meer details over format.

[ctx: ExprControlCollection|]
en: Add new variable
nl: Nieuwe variabele toevoegen

[ctx: ErrorMessages|]
en: Expected string or float[d]
nl: String (tekenreeks) verwacht of float[d]

[ctx: ErrorMessages|]
en: Expected float[d]
nl: float[d] verwacht

[ctx: ErrorMessages|]
en: Expected float[%1]
nl: float[%1] verwacht

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
nl: Types kloppen niet, eerst: '%1'; daarna: '%2'

[ctx: ErrorMessages|]
en: Expected float or float[3]
nl: float of float[3] verwacht

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
nl: '%1' verwacht voor argument, maar kreeg '%2'

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
nl: Aantal argumenten klopt niet, moet 1 tot 7 zijn

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
nl: Aantal argumenten klopt niet, moet veelvoud zijn van 3, plus 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
nl: Aantal argumenten klopt niet, moet 1 zijn of meer

[ctx: ErrorMessages|]
en: First argument must be a string
nl: Eerste argument moet een tekenreeks zijn

[ctx: ErrorMessages|]
en: Incomplete format specifier
nl: Onvolledige format specificatie

[ctx: ErrorMessages|]
en: No variable named '%1'
nl: Geen variabele met naam '%1'

[ctx: ErrorMessages|]
en: Function '%1' has no definition
nl: Functie '%1' is niet gedefinieerd

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
nl: Toekenning heeft onjuist type '%1'

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
nl: Types van conditie komen niet met elkaar overeen

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
nl: Variabele '%1' in condities is inconsistent gedefinieerd

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
nl: Te weinig argumenten voor functie '%1'

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
nl: Teveel argumenten voor functie '%1'

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
nl: Expressie genereerde type '%1', incompatibel met gewenst type '%2'

[ctx: ErrorMessages|]
en: Syntax error near '%1'
nl: Syntaxisfout nabij '%1'

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
nl: Onverwacht einde van expressie nabij '%1'

[ctx: ErrorMessages|]
en: Unexpected end of format string
nl: Onverwacht einde van format string

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
nl: Ongeldige format string, alleen %v en %f zijn toegestaan

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
nl: Aantal argumenten voor format string klopt niet

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
nl: Onbekende fout (melding=%1)

[ctx: ExprAddDialog|]
en: Variable
nl: Variabele

[ctx: ExprAddDialog|]
en: Lookup
nl: Opzoeken

[ctx: ExprAddDialog|]
en: Curve
nl: Kromme

[ctx: ExprAddDialog|]
en: Color Curve
nl: Kleurkromme

[ctx: ExprAddDialog|]
en: Default
nl: Standaard

[ctx: ExprAddDialog|]
en: Color
nl: Kleur

[ctx: ExprAddDialog|]
en: Rainbow
nl: Regenboog

[ctx: ExprAddDialog|]
en: Shades of Gray
nl: Grijswaarden

[ctx: ExprAddDialog|]
en: Colors
nl: Kleuren

[ctx: ExprAddDialog|]
en: Swatch
nl: Kleurenstaal

[ctx: ExprAddDialog|]
en: string
nl: string (tekenreeks)

[ctx: ExprAddDialog|]
en: file
nl: bestand

[ctx: ExprAddDialog|]
en: directory
nl: map

[ctx: ExprAddDialog|]
en: String Name
nl: Naam van string

[ctx: ExprAddDialog|]
en: String Type
nl: Stringtype

[ctx: ExprAddDialog|]
en: String Default
nl: Stringstandaard

[ctx: ExprAddDialog|]
en: String
nl: String (tekenreeks)

[ctx: ExprBrowser|]
en: Save Expression
nl: Expressie opslaan

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
nl: Kon bestand %1 niet openen voor schrijven

[ctx: ExprBrowser|]
en: Error
nl: Fout

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
nl: Kon bestand %1 niet openen voor schrijven. Is het alleen-lezen?

[ctx: CCurveScene|]
en: Delete Point
nl: Punt verwijderen

[ctx: ExprColorCurve|]
en: Selected Position:
nl: Geselecteerde positie:

[ctx: ExprColorCurve|]
en: Selected Color:
nl: Geselecteerde kleur:

[ctx: ExprColorCurve|]
en: None
nl: Geen

[ctx: ExprColorCurve|]
en: Linear
nl: Lineair

[ctx: ExprColorCurve|]
en: Smooth
nl: Glad

[ctx: ExprColorCurve|]
en: &Expand...
nl: Uitvouw&en...

[ctx: ExprColorFrame|]
en: Delete Swatch
nl: Kleurenstaal wissen

[ctx: ExprColorFrame|]
en: Cancel
nl: Annuleren

[ctx: ExprColorSwatchWidget|]
en: &Add...
nl: &Toevoegen...

[ctx: ExprCompletionModel|]
en: Local
nl: Lokaal

[ctx: StringControl|]
en: Please choose a file
nl: Kies een bestand a.u.b

[ctx: StringControl|]
en: Images (*.tif *.tx *.jpg *.ptx *.png)
nl: Afbeeldingen (*.tif *.tx *.jpg *.ptx *.png)

[ctx: CurveControl|]
en: Val:
nl: Waarde:

[ctx: CCurveControl|]
en: Val:
nl: Waarde:

[ctx: CurveScene|]
en: Delete Point
nl: Punt verwijderen

[ctx: ExprCurve|]
en: Selected Position:
nl: Geselecteerde positie:

[ctx: ExprCurve|]
en: Selected Value:
nl: Geselecteerde waarde:

[ctx: ExprCurve|]
en: None
nl: Geen

[ctx: ExprCurve|]
en: Linear
nl: Lineair

[ctx: ExprCurve|]
en: Smooth
nl: Glad

[ctx: ExprCurve|]
en: &Expand...
nl: Uitvouw&en...

[ctx: ExprEditor|]
en: Expression Editor
nl: Editor voor expressies

[ctx: ExprFileDialog|]
en: Open
nl: Openen

[ctx: ExprFileDialog|]
en: Favorites
nl: Favorieten

[ctx: ExprTextEdit|]
en: Pop-up Help
nl: Help pop-up
