seexpr - en to ca translation catalogue (190 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
ca: float abs(float x)
    Valor absolut de «x»

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
ca: float deg(float angle)
    Radians a graus

[ctx: builtin|]
en: float deg(float angle)
    degrees to radians
ca: float deg(float angle)
    Graus a radians

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
ca: float cosd(float angle)
    Cosinus en graus

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
ca: float sind(float angle)
    Sinus en graus

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
ca: float tand(float angle)
    Tangent en graus

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
ca: float acosd(float value)
    Arccosinus en graus

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
ca: float asind(float value)
    Arcsinus en graus

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
ca: float atand(float value)
    Arctangent en graus

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
ca: float atan2d(float y,float x)
    Arctangent en graus de «y»/«x» entre -180 i 180

[ctx: builtin|]
en: float cos(float angle)
    cosine in radians
ca: float cos(float angle)
    Cosinus en radians

[ctx: builtin|]
en: float sin(float angle)
    sine in radians
ca: float sin(float angle)
    Sinus en radians

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
ca: float tan(float angle)
    Tangent en radians

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
ca: float acos(float value)
    Arccosinus en radians

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
ca: float asin(float value)
    Arcsinus en radians

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
ca: float atan(float value)
    Arctangent en radians

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
ca: float atan2(float y,float x)
    Arctangent en radians de «y»/«x» entre -PI i PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
ca: float cosh(float angle)
    Cosinus hiperbòlic en radians

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
ca: float sinh(float angle)
    Sinus hiperbòlic en radians

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
ca: float tanh(float angle)
    Tangent hiperbòlica en radians

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
ca: float acosh(float value)
    Arccosinus hiperbòlic en radians

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
ca: float asinh(float value)
    Arcsinus hiperbòlic en radians

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
ca: float atanh(float value)
    Arctangent hiperbòlica en radians

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
ca: float clamp(float x,float lo,float hi)
    Restringeix «x» a l'interval [lo,hi]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
ca: float round(float x)
    Arrodoneix a l'enter més proper a «x»

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
ca: float max(float a,float b)
    Enter més gran entre «a» i «b»

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
ca: float min(float a,float b)
    Enter més petit entre «a» i «b»

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
ca: float trunc(float a)
    Sencer més proper a zero

[ctx: builtin|]
en: float floor(float a)
    next lower integer
ca: float floor(float a)
    Següent sencer més petit

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
ca: float ceil(float a)
    Següent sencer més gran

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
ca: float invert(float a)
    Definit com a 1-x

[ctx: builtin|]
en: float cbrt(float x)
    cube root
ca: float cbrt(float x)
    Arrel cúbica

[ctx: builtin|]
en: float sqrt(float x)
    square root
ca: float sqrt(float x)
    Arrel quadrada

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
ca: float exp(float x)
    «e» elevat a la potència de «x»

[ctx: builtin|]
en: float pow(float x)
    x to the y power, also available as ^
ca: float pow(float x)
    «x» elevat a la potència de «y», també disponible com a «^»

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
ca: float log(float x)
    Logaritme natural

[ctx: builtin|]
en: float log10(float x)
    Base 10 logarithm
ca: float log10(float x)
    Logaritme en base 10

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
ca: float fmod(float x,float y)
    La resta de «x»/«y» (també disponible com a l'operador «%»)

[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
ca: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=0.5)
    Es pren el valor absolut de cada terme de soroll. Això li dóna una aparença més ondulada

[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
ca: color cturbulence(vector v,int octaves=6,float lacunarity=2,float gain=0.5)
    Es pren el valor absolut de cada terme de soroll. Això li dóna una aparença més ondulada

[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
ca: vector vturbulence(vector v,int octaves=6,float lacunarity=2,float gain=0.5)
    Es pren el valor absolut de cada terme de soroll. Això li dóna una aparença més ondulada

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
ca: float compress(float x,float lo,float hi)
    Reassigna «x» de [0,1] a [lo,hi]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
ca: float expand(float x,float lo,float hi)
    Reassigna «x» de [lo,hi] a [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]
ca: float fit(float x,float a1,float b1,float a2,float b2)
    Reassigna linealment «x» de [a1,b1] a [a2,b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
ca: float gamma(float x, float g)
    Correcció de la gamma de «x» amb el factor de la gamma de «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))
ca: float bias(float x, float g)
    Variació de gamma on els valors inferiors a 0.5 tiren de la corba
    cap avall i els valors superiors a 0.5 tiren de la corba cap amunt
    pow(x,log(b)/log(0.5))

[ctx: builtin|]
en: float contrast(float x,float x)
    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.
ca: float contrast(float x,float x)
    Ajusta el contrast:&nbsp; Per a «c» des de 0 fins a 0.5, es redueix el contrast.&nbsp; Per a «c» &gt; 0.5, el contrast augmenta.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
ca: float boxstep(float x,float a)
    Si «x» és < que a serà 0, en cas contrari 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 &lt; x &lt; b
ca: float linearstep(float x,float a,float b)
    Si «x» &lt; «a» serà 0, si «x» &gt; «b» serà 1, i «x»
    canviarà linealment quan &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
ca: float smoothstep(float x,float a,float b)
    Si «x» &lt; «a» serà 0, si «x» &gt; «b» serà 1, i «x»
    canviarà suaument (cúbica) quan &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
ca: float gasussstep(float x,float a,float b)
    Si «x» &lt; «a» serà 0, si «x» &gt; «b» serà 1, i «x»
    canviarà suaument (exponencialment) quan &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
ca: remap(float x, float source, float range, float falloff, float interp)
    Funció de reassignació general.
    Quan «x» es troba dins de l'interval (<i>range</i>) +/- de la font,
    el resultat és u.
    El resultat caurà a zero més enllà d'aquest interval sobre la
    distància de caiguda (<i>falloff</i>).
    La forma de la caiguda està controlada per <i>interp</i>.
    Es poden usar valors numèrics o constants amb nom:
    &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

[ctx: builtin|]
en: mix(float a,float b,float alpha)
    Blend of a and b according to alpha.
ca: mix(float a,float b,float alpha)
    Barreja d'«a» i «b» segons alfa.

[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.
ca: color  hsi(color x, float h, float s, float i, float map=1)
    La funció «hsi» desplaça el to per «h» (en graus) i escala la
    saturació i la intensitat per «s» i «i» respectivament.&nbsp; Es pot
    proporcionar un mapa que controlarà el desplaçament: tot el
    desplaçament succeirà quan el mapa sigui ú, i no succeirà cap
    canvi quan el mapa sigui zero.&nbsp; El desplaçament s'escalarà
    a menys per als valors entre zero i ú.

[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.
ca: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    La funció «midhsi» és com la funció «hsi», excepte que el mapa
    de control està centrat al voltant del punt mig (valor de 0.5)
    i pot escalar el desplaçament en ambdues direccions.

[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.
ca: color rgbtohsl(color rgb)
    Conversió des de l'espai de color RGB a HSL.
    El HSL és To, Saturació i Claredat (tots en l'interval [0..1]).
    Aquestes funcions també s'han ampliat per a admetre valors RGB
    i HSL fora de l'interval [0..1] de manera raonable.&nbsp; Per a qualsevol
    valor RGB o HSL (excepte per als valors «s» negatius), la conversió
    estarà ben definida i serà reversible.

[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.
ca: color hsltorgb(color hsl)
    Conversió des de l'espai de color HSL a RGB.
    El HSL és To, Saturació i Claredat (tots en l'interval [0..1]).
    Aquestes funcions també s'han ampliat per a admetre valors RGB
    i HSL fora de l'interval [0..1] de manera raonable.&nbsp; Per a qualsevol
    valor RGB o HSL (excepte per als valors «s» negatius), la conversió
    estarà ben definida i serà reversible.

[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.
ca: color saturate(color val, float amt)
    Escala de saturació del color per «amt».
    El color s'escala al voltant del valor de luminància Rec. 709 i
    els resultats negatius es mantenen a zero.

[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.
ca: float hash(float seed1,[float seed2, ...])
    Com «rand», però sense llavors internes. Es pot indicar qualsevol
    nombre de llavors i el resultat serà una funció aleatòria basada
    en totes les llavors.

[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)
ca: 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 )
    Soroll Perlin original a la ubicació (interpolant C2)

[ctx: builtin|]
en: float snoise ( vector v)
    signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
ca: float snoise ( vector v)
    Soroll signat «w/» amb l'interval -1 a 1 format amb el soroll Perlin original a la ubicació (interpolant C2)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
ca: vector vnoise ( vector v)
    Soroll vectorial format amb el soroll Perlin original a la ubicació (interpolant C2)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
ca: color cnoise ( vector v)
    Soroll del color format amb el soroll Perlin original a la ubicació (interpolant C2)

[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)
ca: float snoise4 ( vector v,float t)
    Soroll signat en 4D «w/» amb l'interval -1 a 1 format amb el soroll Perlin original a la ubicació (interpolant C2)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
ca: vector vnoise4 ( vector v,float t)
    Soroll vectorial en 4D format amb el soroll Perlin original a la ubicació (interpolant C2)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
ca: color cnoise4 ( vector v,float t)
    Soroll del color en 4D format amb el soroll Perlin original a la ubicació (interpolant C2)

[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.
ca: float fbm(vector v,int octaves=6,float lacunarity=2,float gain=0.5)
    «fbm» (moviment brownià fraccional) és una funció de soroll amb
    múltiples freqüències. La freqüència base és la mateixa que la
    funció «noise» (soroll). El nombre total de freqüències està
    controlat per «octaves» (octaus). La «lacunarity» (lacunaritat)
    és l'espai entre les freqüències: un valor de 2 vol dir que cada
    vuitena és el doble de la freqüència anterior. El «gain» (guany)
    controla quant s'escalarà cada freqüència en relació amb la
    freqüència anterior.

[ctx: builtin|]
en: vector vfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
ca: vector vfbm(vector vint octaves=6,float lacunarity=2,float gain=0.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.
ca: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=0.5)
    «fbm» (moviment brownià fraccional) és una funció de soroll amb
    múltiples freqüències. La freqüència base és la mateixa que la
    funció «noise» (soroll). El nombre total de freqüències està
    controlat per «octaves» (octaus). La «lacunarity» (lacunaritat)
    és l'espai entre les freqüències: un valor de 2 vol dir que cada
    vuitena és el doble de la freqüència anterior. El «gain» (guany)
    < controla quant s'escalarà cada freqüència en relació amb la
    freqüència anterior.

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

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

[ctx: builtin|]
en: color cfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
ca: color cfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=0.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.
ca: float cellnoise(vector v)
    «cellnoise» genera un camp de cubs amb colors constants en funció de la ubicació del nombre sencer.
    És el mateix que la funció «cellnoise» de PRMan.

[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.
ca: color cellnoise(vector v)
    «cellnoise» genera un camp de cubs amb colors constants en funció de la ubicació del nombre sencer.
    És el mateix que la funció «cellnoise» de PRMan.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
ca: float pnoise ( vector v, vector period )
    Soroll periòdic

[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.
ca: float voronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    «voronoi» és un patró de soroll cel·lular. És una variant nerviosa de «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.
ca: color cvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    Retorna el color en un patró cel·lular. És una variant nerviosa de «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.
ca: color pvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    Retorna el centre de la cel·la «voronoi».

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
ca: float dist(vector a, vector b)
    Distància entre dos punts

[ctx: builtin|]
en: float length(vector v)
    length of vector
ca: float length(vector v)
    Longitud del vector

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
ca: float hypot(vector v)
    Longitud del vector en 2D [x,y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
ca: float dot(vector a,vector b)
    Producte d'un punt vectorial

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
ca: vector norm(vector v)
    Vector escalat a una unitat de longitud

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
ca: vector cross(vector a,vector b)
    Producte d'un creuat vectorial

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
ca: float angle(vector a,vector b)
    Angle entre dos vectors (en radians)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
ca: vector angle(vector a,vector b)
    Vector normalitzat ortogonal, «a» i «b» escalats a una unitat de longitud

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
ca: vector rotate(vector v,vector axis,float angle)
    Gira «v» al voltant de l'eix en un angle indicat (en radians)

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
ca: vector up(vector P,vector upvec)
    Gira «v» de manera que l'eix «Y» apunti en la direcció indicada

[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 rotates v such that the
    Y axis points in the given up direction
ca: int cycle(int index, int loRange, int hiRange )
    Recorre els valors entre «loRange» i «hiRange» segons l'índex proporcionat.
    Aquesta és una funció «mod» de compensació. El resultat gira «v»
    de manera que l'eix «Y» apunta en la direcció cap amunt indicada

[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.
ca: int pick(float index, int loRange, int hiRange, [float weights, ...] )
    Tria aleatòriament els valors entre «loRange» i «hiRange» segons
    l'índex proporcionat (el qual automàticament té una suma):&nbsp; Els
    valors es distribuiran segons els pesos subministrats.&nbsp; S'assumirà
    que qualsevol pes no subministrat serà 1.0.

[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]).
ca: color swatch(float index, color choice0, color choice1, color choice2, [...])
    Tria una de les opcions proporcionades segons l'índex (se suposa que està en l'interval [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]).
ca: float choose(float index,float choice1, float choice2, [...])
    Tria una de les opcions proporcionades segons l'índex (se suposa que està en l'interval [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.
ca: float wchoose(float index,float choice1, float weight1, float choice2, float weight2, [...] )
    Tria una de les opcions proporcionades segons l'índex (se suposa que està en l'interval [0..1]).
    Els valors es distribuiran segons els pesos subministrats.

[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]
ca: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Interpola un conjunt de valors al paràmetre especificat, on «y1»,
    «...» i «yn» són distribuïts homogèniament des de [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)
ca: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpola una rampa en 1D definida pels punts de control en el
    «param». Els punts de control s'especifiquen mitjançant triples
    dels paràmetres «pos_i», «val_i» i «interp_i». Els codis d'interpolació
    són: 0 - cap, 1 - lineal, 2 - suau, 3 - spline i 4 - monòton
    (spline no oscil·lant)

[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)
ca: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpola una rampa definida pels punts de control en el «param».
    Els punts de control s'especifiquen mitjançant triples dels
    paràmetres «pos_i», «val_i» i «interp_i». Els codis d'interpolació
    són: 0 - cap, 1 - lineal, 2 - suau, 3 - spline i 4 - monòton
    (spline no oscil·lant)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
ca: getVar(string varName,vector defaultValue)
    Retorna el valor de «varName» si la variable existeix, en cas contrari retorna «defaultValue»

[ctx: builtin|]
en: printf(string format,[vec0, vec1,  ...])
    Prints out a string to STDOUT, Format parameter allowed is %v
ca: printf(string format,[vec0, vec1,  ...])
    Imprimeix una cadena a la sortida estàndard, el format permès del paràmetre de és %v

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
ca: sprintf(string format, [double|string, double|string, ...])
    Retorna una cadena formatada a partir dels valors indicats. Per a obtenir els detalls sobre el format, vegeu «man sprintf».

[ctx: ExprControlCollection|]
en: Add new variable
ca: Afegeix una variable nova

[ctx: ErrorMessages|]
en: Expected string or float[d]
ca: S'esperava «string» o «float[d]»

[ctx: ErrorMessages|]
en: Expected float[d]
ca: S'esperava «float[d]»

[ctx: ErrorMessages|]
en: Expected float[%1]
ca: S'esperava «float[%1]»

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
ca: No coincideixen els tipus, primer: «%1», segon: «%2»

[ctx: ErrorMessages|]
en: Expected float or float[3]
ca: S'esperava «float» o «float[3]»

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
ca: S'esperava «%1» per a l'argument i s'ha obtingut «%2»

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
ca: Nombre incorrecte d'arguments, hauria de ser d'1 fins a 7

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
ca: Nombre incorrecte d'arguments, hauria de ser múltiple de 3 més 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
ca: Nombre incorrecte d'arguments, hauria de ser 1 o més

[ctx: ErrorMessages|]
en: First argument must be a string
ca: El primer argument ha de ser una cadena

[ctx: ErrorMessages|]
en: Incomplete format specifier
ca: Especificador incomplet de format

[ctx: ErrorMessages|]
en: No variable named '%1'
ca: No hi ha cap variable anomenada «%1»

[ctx: ErrorMessages|]
en: Function '%1' has no definition
ca: La funció «%1» no té definició

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
ca: L'operació d'assignació té un tipus incorrecte «%1»

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
ca: Els tipus de condicional no són compatibles

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
ca: La variable «%1» està definida de manera inconsistent en condicional

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
ca: Hi ha pocs arguments indicats per a la funció «%1»

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
ca: Hi ha massa arguments indicats per a la funció «%1»

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
ca: Tipus d'expressió generada «%1», incompatible amb el tipus desitjat «%2»

[ctx: ErrorMessages|]
en: Syntax error near '%1'
ca: Error de sintaxi a prop de «%1»

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
ca: Final inesperat de l'expressió a prop de «%1»

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
ca: Error desconegut (missatge = %1)

[ctx: ExprAddDialog|]
en: Lookup
ca: Cerca

[ctx: ExprAddDialog|]
en: Curve
ca: Corba

[ctx: ExprAddDialog|]
en: Color Curve
ca: Corba de color

[ctx: ExprAddDialog|]
en: Default
ca: Predeterminat

[ctx: ExprAddDialog|]
en: Min
ca: Mín

[ctx: ExprAddDialog|]
en: Max
ca: Màx

[ctx: ExprAddDialog|]
en: Int
ca: Enter

[ctx: ExprAddDialog|]
en: Float
ca: Flotant

[ctx: ExprAddDialog|]
en: Rainbow
ca: Arc de Sant Martí

[ctx: ExprAddDialog|]
en: Shades of Gray
ca: Ombres de gris

[ctx: ExprAddDialog|]
en: Swatch
ca: Mostra

[ctx: ExprAddDialog|]
en: string
ca: cadena

[ctx: ExprAddDialog|]
en: file
ca: fitxer

[ctx: ExprAddDialog|]
en: directory
ca: directori

[ctx: ExprAddDialog|]
en: String Name
ca: Nom de la cadena

[ctx: ExprAddDialog|]
en: String Type
ca: Tipus de cadena

[ctx: ExprAddDialog|]
en: String Default
ca: Cadena predeterminada

[ctx: ExprAddDialog|]
en: String
ca: Cadena

[ctx: ExprAddDialog|]
en: Link
ca: Enllaç

[ctx: ExprAddDialog|]
en: Deep Water
ca: Aigües profundes

[ctx: ExprBrowser|]
en: Save Expression
ca: Desa l'expressió

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
ca: No s'ha pogut obrir el fitxer «%1» per a escriptura

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
ca: No s'ha pogut obrir el fitxer «%1» per a escriptura. És de només lectura?

[ctx: CCurveScene|]
en: Delete Point
ca: Suprimeix el punt

[ctx: ExprColorCurve|]
en: Selected Position:
ca: Posició seleccionada:

[ctx: ExprColorCurve|]
en: Selected Color:
ca: Color de seleccionat:

[ctx: ExprColorCurve|]
en: None
ca: Cap

[ctx: ExprColorCurve|]
en: Linear
ca: Lineal

[ctx: ExprColorCurve|]
en: Smooth
ca: Suavitzat

[ctx: ExprColorCurve|]
en: &Expand...
ca: &Expandeix...

[ctx: ExprColorFrame|]
en: Delete Swatch
ca: Suprimeix la mostra

[ctx: ExprColorFrame|]
en: Cancel
ca: Cancel·la

[ctx: ExprColorSwatchWidget|]
en: &Add...
ca: &Afegeix...

[ctx: StringControl|]
en: Please choose a file
ca: Si us plau, seleccioneu un fitxer

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

[ctx: CurveControl|]
en: Interp:
ca: Intèrp:

[ctx: CCurveControl|]
en: Interp:
ca: Intèrp:

[ctx: CurveScene|]
en: Delete Point
ca: Suprimeix el punt

[ctx: ExprCurve|]
en: Selected Position:
ca: Posició seleccionada:

[ctx: ExprCurve|]
en: Selected Value:
ca: Valor seleccionat:

[ctx: ExprCurve|]
en: None
ca: Cap

[ctx: ExprCurve|]
en: Linear
ca: Lineal

[ctx: ExprCurve|]
en: Smooth
ca: Suavitzat

[ctx: ExprCurve|]
en: &Expand...
ca: &Expandeix...

[ctx: ExprDialog|]
en: Preview / Library
ca: Vista prèvia / Biblioteca

[ctx: ExprDialog|]
en: Preview
ca: Vista prèvia

[ctx: ExprDialog|]
en: Save
ca: Desa

[ctx: ExprDialog|]
en: Save As
ca: Desa com a

[ctx: ExprDialog|]
en: Save Local
ca: Desa en local

[ctx: ExprDialog|]
en: Clear
ca: Neteja

[ctx: ExprDialog|]
en: Apply
ca: Aplica

[ctx: ExprDialog|]
en: Accept
ca: Accepta

[ctx: ExprDialog|]
en: Cancel
ca: Cancel·la

[ctx: ExprDialog|]
en: Your expression had possible errors.
ca: L'expressió conté possibles errors.

[ctx: ExprDialog|]
en: Do you want to accept your expression anyways?
ca: Voleu acceptar aquesta expressió de totes maneres?

[ctx: ExprDialog|]
en: Help
ca: Ajuda

[ctx: ExprDialog|]
en: Back
ca: Enrere

[ctx: ExprDialog|]
en: Forward
ca: Endavant

[ctx: ExprDialog|]
en: Find
ca: Cerca

[ctx: ExprDialog|]
en: Find Next
ca: Cerca la següent

[ctx: ExprDialog|]
en: Find Prev
ca: Cerca l'anterior

[ctx: ExprDialog|]
en: <b>Variables not supported in preview (assumed zero):</b><br>
ca: <b>Variables no admeses en la vista prèvia (se suposa que és zero):</b><br>

[ctx: ExprDialog|]
en: <b>Functions not supported in preview (assumed zero):</b><br>
ca: <b>Funcions no admeses en la vista prèvia (se suposa que és zero):</b><br>

[ctx: ExprEditor|]
en: Expression Editor
ca: Editor d'expressions

[ctx: ExprFileDialog|]
en: Open
ca: Obre

[ctx: ExprFileDialog|]
en: Favorites
ca: Preferides

[ctx: ExprGrapherWidget|]
en: Width
ca: Amplada

[ctx: ExprTextEdit|]
en: Pop-up Help
ca: Ajuda emergent
