Krita Manual 4.3 - en to pt translation catalogue (176 entries)

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

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
pt: float deg(float angulo)
    radianos para graus

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
pt: float rad(float angulo)
    graus para radianos

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
pt: float cosd(float angulo)
    Coseno em graus

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
pt: float sind(float angulo)
    seno em graus

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
pt: float tand(float angulo)
    tangente em graus

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
pt: float acosd(float valor)
    arco-coseno em graus

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
pt: float asind(float valor)
    arco-seno em graus

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
pt: float atand(float valor)
    arco-tangente em graus

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
pt: float atan2d(float y,float x)
    arco-tangente em graus de y/x entre -180 e 180

[ctx: builtin|]
en: float cos(float angle)
    cosine in radians
pt: float cos(float angulo)
    coseno em radianos

[ctx: builtin|]
en: float sin(float angle)
    sine in radians
pt: float sin(float angulo)
    seno em radianos

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
pt: float tan(float angulo)
    tangente em radianos

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
pt: float acos(float valor)
    arco-coseno em radianos

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
pt: float asin(float valor)
    arco-seno em radianos

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
pt: float atan(float valor)
    arco-tangente em radianos

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
pt: float atan2(float valor)
    arco-tangente em radianos do y/x entre -PI e PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
pt: float cosh(float angulo)
    coseno hiperbólico em radianos

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
pt: float sinh(float angulo)
    seno hiperbólico em radianos

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
pt: float tanh(float angulo)
    tangente hiperbólica em radianos

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
pt: float acosh(float valor)
    arco-coseno hiperbólico em radianos

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
pt: float asinh(float valor)
    arco-seno hiperbólico em radianos

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
pt: float atanh(float valor)
    arco-tangente hiperbólica em radianos

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
pt: float clamp(float x, float inf, float sup)
    restringe o 'x' ao intervalo [inf,sup]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
pt: float round(float x)
    inteiro mais próximo de 'x'

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
pt: float max(float a, float b)
    o maior dos valores 'a' ou 'b'

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
pt: float min(float a, float b)
    o menor dos valores 'a' ou 'b'

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
pt: float trunc(float a)
    inteiro mais próximo em direcção a zero

[ctx: builtin|]
en: float floor(float a)
    next lower integer
pt: float floor(float a)
    inteiro mais próximo por defeito

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
pt: float ceil(float a)
    inteiro mais próximo por excesso

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

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

[ctx: builtin|]
en: float sqrt(float x)
    square root
pt: float sqrt(float x)
    raiz quadrada

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
pt: float exp(float x)
    E elevado ao expoente 'x'

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
pt: float pow(float x, float y)
    x elevado à potência de 'y', também conhecido por ^

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

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

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
pt: float fmod(float x,float y)
    resto do x/y (também disponível como o 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
pt: float turbulence(vector v,int oitavas=6,float lacunas=2,float ganho=.5)
    É retirado o valor absoluto de cada termo do ruído. Isto gera uma aparência mais 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
pt: color cturbulence(vector v,int oitavas=6,float lacunas=2,float ganho=.5)
    É retirado o valor absoluto de cada termo do ruído. Isto gera uma aparência mais 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
pt: vector vturbulence(vector v,int oitavas=6,float lacunas=2,float ganho=.5)
    É retirado o valor absoluto de cada termo do ruído. Isto gera uma aparência mais ondulada

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
pt: float compress(float x, float inf, float sup)
    Associa o 'x' entre [0,1] a [inf,sup]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
pt: float expand(float x, float inf, float sup)
    Associa o 'x' entre [inf,sup] 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]
pt: float fit(float x, float a1, float b1, float a2, float b2)
    Associa linearmente o 'x' entre [a1,b1] a [a2,b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
pt: float gamma(float x, float g)
    Correcção do 'gama' do 'x' com o factor '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))
pt: float bias(float x, float g)
    Variação do 'gama', onde os valores inferiores a 0.5 puxam a curva para baixo
    enquanto os superiores a 0.5 puxam a curva para cima
    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.
pt: float contrast(float x, float c)
    Ajusta o contraste.&nbsp; Para um 'c' de 0 a 0.5, o contraste é diminuído.&nbsp; Para o 'c' &gt; 0.5, o contraste é aumentado.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
pt: float boxstep(float x, float a)
     se o x < a então 0, caso contrário 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
pt: float linearstep(float x, float a, float b)
     se x &lt; a então 0, se x &gt; b então 1,
    sendo que o 'x' transita linearmente quando 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
pt: float smoothstep(float x,float a,float b)
     se x &lt; a então 0, se x &gt; b então 1,
    sendo que o 'x' transita suavemente (de forma cúbica) quando 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
pt: float gaussstep(float x,float a,float b)
     se x &lt; a então 0, se x &gt; b então 1,
    sendo que o 'x' transita suavemente (de forma exponencial) quando 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
pt: remap(float x, float origem, float intervalo, float corte, float interp)
    Função de associação genérica.
    Quando o 'x' está dentro de +/- <i>intervalo</i> da origem, o resultado é um.
    O resultado passa a zero para além desse intervalo com uma distância de <i>corte</i>.
    A forma de corte é controlada pelo <i>interp</i>. Poderá usar
    valores numéricos ou constantes com nome:
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>linear</b> = 0
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>suave</b> = 1
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>gaussiano</b> = 2

[ctx: builtin|]
en: mix(float a,float b,float alpha)
    Blend of a and b according to alpha.
pt: mix(float a,float b,float alfa)
    Mistura do 'a' com o 'b' de acordo com o 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.
pt: color  hsi(color x, float h, float s, float i, float mapa=1)
    A função 'hsi'  desvia a matiz em 'h' (em graus) e ajusta a escala
    da saturação e intensidade em 's' e 'i' respectivamente.&nbsp;
    Poderá ser indicado um 'mapa' que irá controlar o desvio - o desvio
    completo irá acontecer quando o mapa for igual a 1 e não ocorrerá
    nenhum desvio quando o mapa for zero. O desvio será ajustado à escala
    para os valores entre zero e um.

[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.
pt: color midhsi(color x, float h, float s, float i, float mapa, float corte=1, int interp=0)
    A função 'midhsi0 é parecida com a função 'hsi', exceptuando o facto
    que o 'mapa' de controlo está centrado em torno do ponto médio (valor 0.5)
    e poderá ajustar a escala do desvio em ambas as direcções.

[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.
pt: color rgbtohsl(color rgb)
    Conversão do espaço de cores RGB para HSL.
    O HSL corresponde a Matiz, Saturação e Luminosidade (todos no intervalo [0..1])
    Estas funções também foram estendidas para suportar os valores de RGB e HSL
    fora do intervalo [0..1] de forma razoável.&nbsp;Para qualquer valor
    de RGB ou HSL (excepto os valores negativos), a conversão está
    bem-definida e é reversível.

[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.
pt: color hsltorgb(color hsl)
    Conversão do espaço de cores HSL para RGB.
    O HSL corresponde a Matiz, Saturação e Luminosidade (todos no intervalo [0..1])
    Estas funções também foram estendidas para suportar os valores de RGB e HSL
    fora do intervalo [0..1] de forma razoável.&nbsp;Para qualquer valor
    de RGB ou HSL (excepto os valores negativos), a conversão está
    bem-definida e é reversível.

[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.
pt: color saturate(color val, float quant)
    Ajusta a escala de saturação da cor em 'quant'.
    A escala da cor é ajustada em torno do valor de luminância do rec709,
    sendo que os valores negativos são convertidos em zero.

[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.
pt: float rand ( [float min, float max], [float base] )
    Número aleatório entre [min, max] (ou [0, 1] se não forem indicados).
    Se for indicado um valor de 'base', será usado para além dos valores de base internos e pode ser usado para criar vários geradores 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.
pt: float hash(float base1,[float base2, ...])
    Como o 'rand', mas sem valores de base internos. Poderá indicar
    qualquer número de valores de base e o resultado será uma função
    aleatória com base em todos os valores de base.

[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)
pt: 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 p )
    Ruído de Perlin original no local (interpolação C2)

[ctx: builtin|]
en: float snoise ( vector v)
    signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
pt: float snoise ( vector v)
    ruído com sinal no intervalo -1 a 1, formado com o ruído de Perlin original na localização (interpolação C2)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
pt: vector vnoise ( vector v)
    ruído vectorial, formado com o ruído de Perlin original na localização (interpolação C2)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
pt: color cnoise ( vector v)
    ruído de cor, formado com o ruído de Perlin original na localização (interpolação 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)
pt: float snoise4 ( vector v, float t)
    ruído 4D com sinal no intervalo -1 a 1, formado com o ruído de Perlin original na localização (interpolação C2)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
pt: vector vnoise4 ( vector v, float t)
    ruído vectorial 4D com sinal no intervalo -1 a 1, formado com o ruído de Perlin original na localização (interpolação C2)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
pt: color cnoise4 ( vector v, float t)
    ruído de cor 4D com sinal no intervalo -1 a 1, formado com o ruído de Perlin original na localização (interpolação 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.
pt: float fbm(vector v,int oitavas=6,float lacunas=2,float ganho=.5)
    O 'fbm (Fractal Brownian Motion - Movimento Fractal de Brown) é
    uma função de ruído multi-frequências. A frequência de base é igual
    à da função "noise". O número total de frequências é controlado
    pelas 'oitavas'. As 'lacunas' são o intervalo entre as frequências
    - um valor de 2 significa que cada oitava é duas vezes a frequência
    anterior. O 'ganho' controla qual o ajuste da escala de cada
    frequência face à frequência anterior.

[ctx: builtin|]
en: vector vfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
pt: vector vfbm(vector v,int oitavas=6,float lacunas=2,float ganho=.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.
pt: float fbm4(vector v,int oitavas=6,float lacunas=2,float ganho=.5)
    O 'fbm (Fractal Brownian Motion - Movimento Fractal de Brown) é
    uma função de ruído multi-frequências. A frequência de base é igual
    à da função "noise". O número total de frequências é controlado
    pelas 'oitavas'. As 'lacunas' são o intervalo entre as frequências
    - um valor de 2 significa que cada oitava é duas vezes a frequência
    anterior. O 'ganho' controla qual o ajuste da escala de cada
    frequência face à frequência anterior.

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

[ctx: builtin|]
en: color cfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
pt: color cfbm(vector v,int oitavas=6,float lacunas=2,float ganho=.5)

[ctx: builtin|]
en: color cfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
pt: color cfbm4(vector v,int oitavas=6,float lacunas=2,float ganho=.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.
pt: float cellnoise(vector v)
    O 'cellnoise' gera um campo de cubos coloridos constantes com base
    na localização inteira.
    Isto é igual à função 'cellnoise' do 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.
pt: color cellnoise(vector v)
    O 'cellnoise' gera um campo de cubos coloridos constantes com base
    na localização inteira.
    Isto é igual à função 'cellnoise' do PRMan.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
pt: float pnoise ( vector v, vector periodo )
    ruído 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.
pt: float voronoi( vector v, int tipo=1, float desvio=0.5, float fbmEscala=0, int fbmOitavas=4, float fbmLacunas=2, float fbmGanho=0.5)
    O 'voronoi' é um padrão de ruído celular. É uma variante com desvios do '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.
pt: color cvoronoi( vector v, int tipo=1, float desvio=0.5, float fbmEscala=0, int fbmOitavas=4, float fbmLacunas=2, float fbmGanho=0.5)
    Devolve uma cor num padrão celular. É uma variante com desvios do '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.
pt: color pvoronoi( vector v, int tipo=1, float desvio=0.5, float fbmEscala=0, int fbmOitavas=4, float fbmLacunas=2, float fbmGanho=0.5)
    Devolve o centro da célula de Voronoi.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
pt: float dist(vector a, vector b)
    distância entre dois pontos

[ctx: builtin|]
en: float length(vector v)
    length of vector
pt: float length(vector v)
    comprimento do vector

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
pt: float hypot(vector v)
    comprimento do vector 2d [x,y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
pt: float dot(vector a, vector b)
    produto interno vectorial

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
pt: vector norm(vector v)
    O vector escalado ao comprimento da unidade

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
pt: vector cross (vector a, vector b)
    produtor vectorial externo

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
pt: float angle(vector a,vector b)
    ângulo entre dois vectoers (em radianos)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
pt: vector angle(vector a,vector b)
    vector normalizado ortogonal ao 'a' e 'b' escalados ao tamanho da unidade

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
pt: vector rotate(vector v, vector eixo, float angulo)
    roda em 'angulo' radianos o 'v' em torno do eixo

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
pt: vector up(vector v, vector cima)
    Roda o 'v' de forma que o eixo dos Y aponte para a direcção 'cima 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)``.
pt: int cycle(int indice, int intervaloInf, int intervaloSup)
    Circula pelos valores entre 'intervaloInf' e 'intervaloSup' com base no índice fornecido.
    Esta é uma função 'mod' do deslocamento. O resultado é calculado como ``intervaloInf + valor % (intervaloSup-intervaloInf+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.
pt: int pick(float indice, int intervaloInf, int intervaloSup, [float pesos, ...] )
    Escolhe os valores aleatoriamente entre 'intervaloInf' e 'intervaloSup'
    com base no índice fornecido (que é disperso de forma automática).
    &nbsp;Os valores serão distribuídos de acordo com os pesos indicados.
    &nbsp;Todos os pesos não indicados assumem-se como sendo iguais a 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]).
pt: color swatch(float indice, color opcao0, color opcao1, color opcao2, [...])
    Escolha uma das opções de cores indicadas com base no índice (assume-se que está no intervalo de [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]).
pt: color choose(float indice, color opcao0, color opcao1, color opcao2, [...])
    Escolha uma das opções indicadas com base no índice (assume-se que está no intervalo de [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.
pt: color wchoose(float indice, float opcao0, float peso0, float opcao1, float peso2, [...])
    Escolhe uma das opções fornecidas com base no índice (que se assume no intervalo [0..1]).
    Os valores serão distribuídos de acordo com os pesos indicados.

[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]
pt: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Faz a interpolação de um conjunto de valores para o parâmetro indicado em que os valores 'y1', ..., 'yn' estão distribuídos de forma uniforme 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)
pt: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpola uma rampa em 1D definida pelos pontos de controlo em 'param'. Os pontos de controlo são indicados pelos grupos de três parâmetros
    pos_i, val_i e interp_i. Os códigos de interpolação são
    0 - nenhum, 1 - linear, 2 - suave, 3 - curva, 
    4- monótono (curva não 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)
pt: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    Interpola uma rampa de cores definida pelos pontos de controlo em 'param'. Os pontos de controlo são indicados pelos grupos de três parâmetros
    pos_i, val_i e interp_i. Os códigos de interpolação são
    0 - nenhum, 1 - linear, 2 - suave, 3 - curva, 
    4- monótono (curva não oscilante)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
pt: getVar(string nome,vector valorPredefinido)
    devolve o valor da variável 'nome', se existir, caso contrário devolve o 'valorPredefinido'

[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.
pt: printf(string formato,[vec0, vec1,  ...])
    Imprime um texto no STDOUT, O parâmetro de formato permitido é "%v" e "%f".
    O parâmetro devolvido é vazio, mas é necessário estar atribuído a uma variável.

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
pt: sprintf(string formato, [número|texto, número|texto, ...])
    Devolve um texto formatado a partir dos valores indicados. Veja os detalhes do formato em 'man sprintf'.

[ctx: ExprControlCollection|]
en: Add new variable
pt: Adicionar uma nova variável

[ctx: ErrorMessages|]
en: Expected string or float[d]
pt: É esperado uma 'string' ou um 'float[d]'

[ctx: ErrorMessages|]
en: Expected float[d]
pt: É esperado um 'float[d]'

[ctx: ErrorMessages|]
en: Expected float[%1]
pt: É esperado um 'float[%1]'

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
pt: Inconsistência de tipos, primeiro: '%1'; segundo: '%2'

[ctx: ErrorMessages|]
en: Expected float or float[3]
pt: É esperado um 'float' ou 'float[3]'

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
pt: É esperado um '%1' como argumento, mas obteve-se um '%2'

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
pt: Número de argumentos inválido, deverá ser de 1 a 7

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
pt: Número de argumentos inválido, deverá um múltiplo de 3 mais 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
pt: Número de argumentos inválido, deverá ser 1 ou mais

[ctx: ErrorMessages|]
en: First argument must be a string
pt: O primeiro argumento deverá ser de texto

[ctx: ErrorMessages|]
en: Incomplete format specifier
pt: O texto de formato está incompleto

[ctx: ErrorMessages|]
en: No variable named '%1'
pt: Não existe a variável com o nome '%1'

[ctx: ErrorMessages|]
en: Function '%1' has no definition
pt: A função '%1' não tem nenhuma definição

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
pt: A operação de atribuição tem o tipo incorrecto '%1'

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
pt: Os tipos de condicionais não são compatíveis

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
pt: A variável '%1' está definida de forma inconsistente nas condicionais

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
pt: Tem argumentos a menos na função '%1'

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
pt: Tem argumentos a mais na função '%1'

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
pt: A expressão gerou o tipo '%1', que é incompatível com o tipo desejado '%2'

[ctx: ErrorMessages|]
en: Syntax error near '%1'
pt: Erro de sintaxe perto de '%1'

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
pt: Chegou-se inesperadamente ao fim da expressão perto de '%1'

[ctx: ErrorMessages|]
en: Unexpected end of format string
pt: Chegou-se inesperadamente ao fim do texto de formato

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
pt: O texto do formato é inválido, só é permitido o %v ou o %f

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
pt: Número de argumentos inválido para o texto do formato

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
pt: Erro desconhecido (mensagem = %1)

[ctx: ExprAddDialog|]
en: Variable
pt: Variável

[ctx: ExprAddDialog|]
en: Lookup
pt: Consulta

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

[ctx: ExprAddDialog|]
en: Color Curve
pt: Curva de Cor

[ctx: ExprAddDialog|]
en: Default
pt: Predefinição

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

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

[ctx: ExprAddDialog|]
en: Float
pt: Fraccionário

[ctx: ExprAddDialog|]
en: Color
pt: Cor

[ctx: ExprAddDialog|]
en: Rainbow
pt: Arco-Íris

[ctx: ExprAddDialog|]
en: Shades of Gray
pt: Tons de Cinzento

[ctx: ExprAddDialog|]
en: Colors
pt: Cores

[ctx: ExprAddDialog|]
en: Swatch
pt: Amostra

[ctx: ExprAddDialog|]
en: string
pt: texto

[ctx: ExprAddDialog|]
en: file
pt: ficheiro

[ctx: ExprAddDialog|]
en: directory
pt: pasta

[ctx: ExprAddDialog|]
en: String Name
pt: Nome do Texto

[ctx: ExprAddDialog|]
en: String Type
pt: Tipo do Texto

[ctx: ExprAddDialog|]
en: String Default
pt: Texto por Omissão

[ctx: ExprAddDialog|]
en: String
pt: Texto

[ctx: ExprBrowser|]
en: Save Expression
pt: Gravar a Expressão

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
pt: Não foi possível aceder ao ficheiro '%1' para escrita

[ctx: ExprBrowser|]
en: Error
pt: Erro

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
pt: Não foi possível aceder ao ficheiro '%1' para escrita. É apenas para leitura?

[ctx: CCurveScene|]
en: Delete Point
pt: Apagar o Ponto

[ctx: ExprColorCurve|]
en: Selected Position:
pt: Posição Seleccionada:

[ctx: ExprColorCurve|]
en: Selected Color:
pt: Cor Seleccionada:

[ctx: ExprColorCurve|]
en: None
pt: Nenhuma

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

[ctx: ExprColorCurve|]
en: Spline
pt: Curva

[ctx: ExprColorCurve|]
en: MSpline
pt: Curva-M

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

[ctx: ExprColorFrame|]
en: Delete Swatch
pt: Apagar a Amostra

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

[ctx: ExprColorSwatchWidget|]
en: &Add...
pt: &Adicionar...

[ctx: StringControl|]
en: Please choose a file
pt: Escolha por favor um ficheiro

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

[ctx: CurveScene|]
en: Delete Point
pt: Apagar o Ponto

[ctx: ExprCurve|]
en: Selected Position:
pt: Posição Seleccionada:

[ctx: ExprCurve|]
en: Selected Value:
pt: Valor Seleccionado:

[ctx: ExprCurve|]
en: None
pt: Nenhum

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

[ctx: ExprCurve|]
en: Spline
pt: Curva

[ctx: ExprCurve|]
en: MSpline
pt: Curva-M

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

[ctx: ExprEditor|]
en: Expression Editor
pt: Editor da Expressão

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

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

[ctx: ExprTextEdit|]
en: Pop-up Help
pt: Ajuda de Contexto

[ctx: ExprTextEdit|]
en: <br>%1
pt: <br/>%1
