seexpr2_qt - en to es translation catalogue (173 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
es: float abs(float x)
    valor absoluto de x

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
es: float deg(float ángulo)
    radianes a grados

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
es: float rad(float ángulo)
    grados a radianes

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
es: float cosd(float ángulo)
    coseno en grados

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
es: float sind(float ángulo)
    seno en grados

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
es: float tand(float ángulo)
    tangente en grados

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
es: float acosd(float valor)
    arcocoseno en grados

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
es: float asind(float valor)
    arcoseno en grados

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
es: float atand(float valor)
    arcotangente en grados

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
es: float atan2d(float y,float x)
    arcotangente en grados de y/x entre -180 y 180

[ctx: builtin|]
en: float cos(float angle)
    cosine in radians
es: float cos(float ángulo)
    coseno en radianes

[ctx: builtin|]
en: float sin(float angle)
    sine in radians
es: float sin(float ángulo)
    seno en radianes

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
es: float tan(float ángulo)
    tangente en radianes

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
es: float acos(float valor)
    arcocoseno en radianes

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
es: float asin(float valor)
    arcoseno en radianes

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
es: float atan(float valor)
    arcotangente en radianes

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
es: float atan2(float y,float x)
    arcotangente en radianes de y/x entre -PI y PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
es: float cosh(float ángulo)
    coseno hiperbólico en radianes

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
es: float sinh(float ángulo)
    seno hiperbólico en radianes

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
es: float tanh(float ángulo)
    tangente hiperbólica en radianes

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
es: float acosh(float valor)
    arcocoseno hiperbólico en radianes

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
es: float asinh(float valor)
    arcoseno hiperbólico en radianes

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
es: float atanh(float valor)
    arcotangente hiperbólica en radianes

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
es: float clamp(float x,float bajo,float alto)
    limitar x al intervalo [bajo,alto]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
es: float round(float x)
    entero más cercano a x

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
es: float max(float a,float b)
    mayor de a y b

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
es: float min(float a,float b)
    menor de a y b

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
es: float trunc(float a)
    entero más cercano hacia cero

[ctx: builtin|]
en: float floor(float a)
    next lower integer
es: float floor(float a)
    siguiente entero más bajo

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
es: float ceil(float a)
    siguiente entero más alto

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
es: float invert(float a)
    Definido como 1-x

[ctx: builtin|]
en: float cbrt(float x)
    cube root
es: float cbrt(float x)
    raíz cúbica

[ctx: builtin|]
en: float sqrt(float x)
    square root
es: float sqrt(float x)
    raíz cuadrada

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
es: float exp(float x)
    E elevado a la potencia de x

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
es: float pow(float x, float y)
    x a la potencia de y, también está disponible como ^

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
es: float log(float x)
    Logaritmo natural

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

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
es: float fmod(float x,float y)
    resto de x/y (también disponible como el 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
es: float turbulence(vector v,int octavas=6,float lagunaridad=2,float ganancia=.5)
    Se toma el valor absoluto de cada término de ruido. Esto proporciona una apariencia 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
es: color cturbulence(vector v,int octavas=6,float lagunaridad=2,float ganancia=.5)
    Se toma el valor absoluto de cada término de ruido. Esto proporciona una apariencia 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
es: vector vturbulence(vector v,int octavas=6,float lagunaridad=2,float ganancia=.5)
    Se toma el valor absoluto de cada término de ruido. Esto proporciona una apariencia ondulada.

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
es: float compress(float x,float bajo,float alto)
    Remapea x en [0,1] a [bajo,alto]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
es: float expand(float x,float bajo,float alto)
    Remapea x en [bajo,alto] 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]
es: float fit(float x,float a1,float b1,float a2,float b2)
    Remapea linealmente x en [a1,b1] a [a2,b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
es: float gamma(float x, float g)
    Corrección gamma de x con el factor gamma 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))
es: float bias(float x, float g)
    Variación de gamma en la que los valores menores que 0.5 tiran de la curva hacia abajo
    y los valores mayores que 0.5 tiran de la curva hacia arriba
    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.
es: float contrast(float x, float c)
    Ajustar el contraste.&nbsp; Para c de 0 a 0.5, se disminuye el contraste.&nbsp; Para c &gt; 0.5, se aumenta el contraste.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
es: float boxstep(float x,float a)
    si x < a entonces 0 en caso contrario 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
es: float linearstep(float x, float a, float b)
     si x &lt; a entonces 0, si x &gt; b entonces 1, y
    x se convierte linealmente cuando 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
es: float smoothstep(float x,float a,float b)
     si x &lt; a entonces 0, si x &gt; b entonces 1, y
    x se convierte suavemente (de forma cúbica) cuando 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
es: float gasussstep(float x,float a,float b)
     si x &lt; a entonces 0, si x &gt; b entonces 1, y
    x se convierte suavemente (de forma exponencial) cuando 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
es: remap(float x, float origen, float intervado, float caída, float interp)
    Función de remapeo general.
    Cuando x está dentro de +/- <i>intervalo</i> de <i>origen</i>, el resultado es uno.
    El resultado cae a cero más allá de este intervalo, sobre la distancia de <i>caída</i>.
    La forma de la caída se controla con <i>interp</i>. Se pueden usar valores
    numéricos o constantes con nombre:
    &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.
es: mix(float a,float b,float alfa)
    Mezcla de a y b según 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.
es: color  hsi(color x, float h, float s, float i, float mapa=1)
    La función «hsi» desplaza el matiz «h» grados
    y escala la saturación y la intensidad «s» e «i», respectivamente.
    &nbsp; Se puede proporcionar un mapa para controlar el desplazamiento
     (tendrá lugar un desplazamiento completo cuando el mapa es uno, mientras
    que no habrá desplazamiento cuando el mapa es cero.&nbsp; El desplazamiento
    se escalará hacia atrás para los valores entre cero y uno.

[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.
es: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    La función «midhsi» es similar a la función «hsi», excepto que el mapa
    de control está centrado alrededor del punto medio (valor de 0.5)
    y puede escalar el desplazamiento en ambas direcciones.

[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.
es: color rgbtohsl(color rgb)
    Conversión de espacio de color RGB a HSL.
    HSL significa «matiz», «saturación» y «luminosidad» (todos en el intervalo [0..1]).
    Estas funciones también se han extendido para permitir valores RGB y HSL
    fuera del intervalo [0..1] de un modo razonable.&nbsp; La conversión está bien
    definida y es reversible para cualquier valor RGB o HSL (excepto para valores
    negativos de «s»).

[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.
es: color hsltorgb(color hsl)
    Conversión de espacio de color HSL a RGB.
    HSL significa «matiz», «saturación» y «luminosidad» (todos en el intervalo [0..1]).
    Estas funciones también se han extendido para permitir valores RGB y HSL
    fuera del intervalo [0..1] de un modo razonable.&nbsp; La conversión está bien
    definida y es reversible para cualquier valor RGB o HSL (excepto para valores
    negativos de «s»).

[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.
es: color saturate(color val, float cantidad)
    Escalar la saturación de color en «cantidad».
    El color se escala en torno al valor de luminancia rec709,
    mientras que los valores negativos se recortan a cero.

[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.
es: float rand ( [float mín, float máx], [float semilla] )
    Número aleatorio entre [mín, máx] (o [0, 1] si no se especifican).
    Si se proporciona una «semilla», se usará adicionalmente a las semillas internas; se puede usar para crear múltiples generadores distintos.

[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.
es: float hash(float semilla1,[float semilla2, ...])
    Como rand, pero sin semillas internas. Se puede indicar cualquier número de
    semillas y el resultado será una función aleatoria basada en todas las semillas.

[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)
es: 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 )
    Ruido Perlin original de la posición (interpolante C2)

[ctx: builtin|]
en: float snoise ( vector v)
    signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
es: float snoise ( vector v)
    Ruido con signo en el intervalo -1 a 1 formado con el ruido Perlin original de la posición (interpolante C2)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
es: vector vnoise ( vector v)
    Ruido vectorial formado con el ruido Perlin original de la posición (interpolante C2)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
es: color cnoise ( vector v)
    Ruido de color formado con el ruido Perlin original de la posición (interpolante 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)
es: float snoise4 ( vector v,float t)
    Ruido con signo en 4D en el intervalo -1 a 1 formado con el ruido Perlin original de la posición (interpolante C2)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
es: vector vnoise4 ( vector v,float t)
    Ruido vectorial en 4D formado con el ruido Perlin original de la posición (interpolante C2)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
es: color cnoise4 ( vector v,float t)
    Ruido de color en 4D formado con el ruido Perlin original de la posición (interpolante 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.
es: float fbm(vector v,int octavas=6,float lagunaridad=2,float ganancia=.5)
    El «fbm» (movimiento browniano fraccionario) es una función de ruido multifrecuencia. 
    La frecuencia base es la misma que la de la función «noise». El número total de frecuencias se controla mediante «octavas». La «lagunaridad» es el espacio entre las frecuencias (un valor de 2 significa que cada octava es el doble de la frecuencia anterior). La «ganancia» controla cuánto se escala cada frecuencia con relación a la frecuencia anterior.

[ctx: builtin|]
en: vector vfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
es: vector vfbm(vector vint octavas=6,float lagunaridad=2,float ganancia=.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.
es: float fbm4(vector v,float tiempo,int octavas=6,float lagunaridad=2,float ganancia=.5)
    El «fbm» (movimiento browniano fraccionario) es una función de ruido multifrecuencia. 
    La frecuencia base es la misma que la de la función «noise». El número total 
    de frecuencias se controla mediante «octavas». La «lagunaridad» es el 
    espacio entre las frecuencias (un valor de 2 significa que cada octava es 
    el doble de la frecuencia anterior). La «ganancia» controla cuánto se escala 
    cada frecuencia con relación a la frecuencia anterior.

[ctx: builtin|]
en: vector vfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
es: vector vfbm4(vector v,float tiempo,int octavas=6,float lagunaridad=2,float ganancia=.5)

[ctx: builtin|]
en: color cfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
es: color cfbm(vector vint octavas=6,float lagunaridad=2,float ganancia=.5)

[ctx: builtin|]
en: color cfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
es: color cfbm4(vector v,float tiempo,int octavas=6,float lagunaridad=2,float ganancia=.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.
es: float cellnoise(vector v)
    «cellnoise» genera un campo constante de cubos de color basado en la posición entera.
    Es idéntica a la función «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.
es: color cellnoise(vector v)
    «cellnoise» genera un campo constante de cubos de color basado en la posición entera.
    Es idéntica a la función «cellnoise» de PRMan.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
es: float pnoise ( vector v, vector periodo )
    ruido periódico

[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.
es: float voronoi(vector v, int tipo=1,float agitación=0.5, float fbmEscala=0, int fbmOctavas=4,float fbmLagunaridad=2, float fbmGanancia=.5)
    «voronoi» es un patrón de ruido celular. Es una variante de «cellnoise» con agitación.

[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.
es: color cvoronoi(vector v, int tipo=1,float agitación=0.5, float fbmEscala=0, int fbmOctavas=4,float fbmLagunaridad=2, float fbmGanancia=.5)
    Devuelve el color de un patrón celular. Es una variante de «cellnoise» con agitación.

[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.
es: color pvoronoi(vector v, int tipo=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    devuelve el centro de la celda de Voronói.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
es: float dist(vector a, vector b)
    distancia entre dos puntos

[ctx: builtin|]
en: float length(vector v)
    length of vector
es: float length(vector v)
    longitud del vector

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
es: float hypot(vector v)
    longitud del segundo vector [x,y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
es: float dot(vector a,vector b)
    Producto de un punto vectorial

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
es: vector norm(vector v)
    vector escalado a la longitud unitaria

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
es: vector cross(vector a,vector b)
    Producto de un cruce vectorial

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
es: float angle(vector a,vector b)
    ángulo entre dos vectores (en radianes)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
es: vector angle(vector a,vector b)
    Vector ortogonal normalizado de «a» y «b» escalado a la longitud unitaria

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
es: vector rotate(vector v,vector eje,float ángulo)
    rota v alrededor del eje el ángulo indicado (en radianes)

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
es: vector up(vector P,vector vectorarriba)
    Rota «v» de tal modo que el eje Y apunte en la dirección arriba 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 is computed as ``loRange + value % (hiRange-loRange+1)``.
es: int cycle(int índice, int limInferior, int limSuperior )
    Recorre los valores entre «limInferior» y «limSuperior» según el índice proporcionado.
    Es una función «mod» de desplazamiento. El resultado se calcula como ``limInferior + valor % (limSuperior - limInferior + 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.
es: int pick(float índice, int limInferior, int limSuperior, [float pesos, ...] )
    Escoge valores aleatoriamente entre «limInferior» y «limSuperior» según el índice proporcionado (cuyo
    «hash» se obtiene automáticamente).&nbsp; Los valores se distribuirán según
    los pesos proporcionados.&nbsp; Se asume que los pesos no indicados valen
    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]).
es: color swatch(float índice, color elección0, color elección1, color elección2, [...])
    Escoge una de las elecciones de color proporcionadas basándose en el «índice» (que se supone en el intervalo [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]).
es: float choose(float índice,float elección1, float elección2, [...])
    Escoge una de las elecciones proporcionadas basándose en el «índice» (que se supone en el intervalo [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.
es: float wchoose(float índice,float elección1, float peso1, float elección2, float peso2, [...] )
    Escoge una de las elecciones proporcionadas basándose en el «índice» (que se supone en el intervalo [0..1]).
    Los valores se distribuyen según los pesos proporcionados.

[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]
es: float spline(float parámetro,float y1,float y2,float y3,float y4,[...])
    
    Interpola un conjunto de valores al parámetro especificado, donde y1, ..., yn se
    distribuyen uniformemente desde [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)
es: float curve(float parámetro,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpola una rampa de 1D definida por los puntos de control en «parámetro». Los puntos de control se especifican 
    mediante tripletes de los parámetros pos_i, val_i e interp_i. Los códigos de interpolación son 
    0 - ninguno, 1 - lineal, 2 - suave, 3 - spline, 
    4 - monótono (spline no oscilante)

[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)
es: color curve(float parámetro,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpola la rampa de color indicada por los puntos de control de «parámetro». Los puntos de control se especifican 
    mediante tripletes de los parámetros pos_i, val_i e interp_i. Los códigos de interpolación son 
    0 - ninguno, 1 - lineal, 2 - suave, 3 - spline, 
    4 - monótono (spline no oscilante)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
es: getVar(string nombreVariable,vector valorPredeterminado)
    Devuelve el valor de «nombreVariable» si existe dicha variable. En caso contrario devuelve «valorPredeterminado».

[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.
es: float printf(string formato,[vec0, vec1,  ...])
    Imprime una cadena de texto en STDOUT. Los parámetros de formato permitidos son «%v» y «%f».
    El parámetro devuelto está vacío, aunque se puede asignar a una variable.

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
es: sprintf(string formato, [double|string, double|string, ...])
    Devuelve una cadena de texto formateada con los valores indicados. Consulte «man sprintf» para los detalles del formato.

[ctx: ExprControlCollection|]
en: Add new variable
es: Añadir nueva variable

[ctx: ErrorMessages|]
en: Expected string or float[d]
es: Se esperaba string o float[d]

[ctx: ErrorMessages|]
en: Expected float[d]
es: Se esperaba float[d]

[ctx: ErrorMessages|]
en: Expected float[%1]
es: Se esperaba float[%1]

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
es: El tipo no coincide; primero: «%1»; segundo: «%2»

[ctx: ErrorMessages|]
en: Expected float or float[3]
es: Se esperaba float o float[3]

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
es: Se esperaba «%1» para el argumento, pero se ha obtenido «%2»

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
es: Número incorrecto de argumentos; deben ser de 1 a 7

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
es: Número incorrecto de argumentos, debe ser múltiplo de 3 más 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
es: Número incorrecto de argumentos; debe ser 1 o más

[ctx: ErrorMessages|]
en: First argument must be a string
es: El primer argumento debe ser una cadena de texto

[ctx: ErrorMessages|]
en: Incomplete format specifier
es: Especificador de formato incompleto

[ctx: ErrorMessages|]
en: No variable named '%1'
es: No hay ninguna variable con el nombre «%1»

[ctx: ErrorMessages|]
en: Function '%1' has no definition
es: La función «%1» no tiene definición

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
es: La operación de asignación tiene el tipo incorrecto «%1»

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
es: Los tipos del condicional no son compatibles

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
es: Variable «%1» definida en los condicionales de forma inconsistente

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
es: Faltan argumentos para la función «%1»

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
es: Demasiados argumentos para la función «%1»

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
es: El tipo de expresión generado «%1» es incompatible con el tipo deseado «%2»

[ctx: ErrorMessages|]
en: Syntax error near '%1'
es: Error de sintaxis próximo a «%1»

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
es: Fin de expresión no esperado próximo a «%1»

[ctx: ErrorMessages|]
en: Unexpected end of format string
es: Fin no esperado de la cadena de formato

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
es: Cadena de formato no válida. Solo se permite %v o %f.

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
es: Número incorrecto de argumentos para la cadena de formato

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
es: Error desconocido (mensaje = %1)

[ctx: ExprAddDialog|]
en: Lookup
es: Búsqueda

[ctx: ExprAddDialog|]
en: Curve
es: Curva

[ctx: ExprAddDialog|]
en: Color Curve
es: Curva de color

[ctx: ExprAddDialog|]
en: Default
es: Por omisión

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

[ctx: ExprAddDialog|]
en: Max
es: Máx

[ctx: ExprAddDialog|]
en: Rainbow
es: Arcoíris

[ctx: ExprAddDialog|]
en: Shades of Gray
es: Tonos de gris

[ctx: ExprAddDialog|]
en: Colors
es: Colores

[ctx: ExprAddDialog|]
en: Swatch
es: Muestra

[ctx: ExprAddDialog|]
en: string
es: cadena de texto

[ctx: ExprAddDialog|]
en: file
es: archivo

[ctx: ExprAddDialog|]
en: directory
es: directorio

[ctx: ExprAddDialog|]
en: String Name
es: Nombre de la cadena de texto

[ctx: ExprAddDialog|]
en: String Type
es: Tipo de cadena de texto

[ctx: ExprAddDialog|]
en: String Default
es: Cadena de texto por omisión

[ctx: ExprAddDialog|]
en: String
es: Cadena de texto

[ctx: ExprBrowser|]
en: Save Expression
es: Guardar expresión

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
es: No se ha podido abrir el archivo %1 para escritura

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
es: No se ha podido abrir el archivo %1 para escritura. ¿Es de solo lectura?

[ctx: CCurveScene|]
en: Delete Point
es: Borrar punto

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

[ctx: ExprColorCurve|]
en: Selected Color:
es: Color seleccionado:

[ctx: ExprColorCurve|]
en: Interp:
es: Intérp:

[ctx: ExprColorCurve|]
en: None
es: Ninguna

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

[ctx: ExprColorCurve|]
en: Smooth
es: Suave

[ctx: ExprColorCurve|]
en: &Expand...
es: &Expandir...

[ctx: ExprColorFrame|]
en: Delete Swatch
es: Borrar muestra

[ctx: ExprColorFrame|]
en: Cancel
es: Cancelar

[ctx: ExprColorSwatchWidget|]
en: &Add...
es: &Añadir...

[ctx: StringControl|]
en: Please choose a file
es: Seleccione un archivo

[ctx: StringControl|]
en: Images (*.tif *.tx *.jpg *.ptx *.png)
es: Imágenes (*.tif *.tx *.jpg *.ptx *.png)

[ctx: CurveControl|]
en: Interp:
es: Intérp:

[ctx: CCurveControl|]
en: Interp:
es: Intérp:

[ctx: CurveScene|]
en: Delete Point
es: Borrar punto

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

[ctx: ExprCurve|]
en: Selected Value:
es: Valor seleccionado:

[ctx: ExprCurve|]
en: Interp:
es: Intérp:

[ctx: ExprCurve|]
en: None
es: Ninguna

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

[ctx: ExprCurve|]
en: Smooth
es: Suave

[ctx: ExprCurve|]
en: &Expand...
es: &Expandir...

[ctx: ExprEditor|]
en: Expression Editor
es: Editor de expresiones

[ctx: ExprFileDialog|]
en: Open
es: Abrir

[ctx: ExprFileDialog|]
en: Favorites
es: Favoritos

[ctx: ExprTextEdit|]
en: Pop-up Help
es: Ayuda emergente
