en to it translation catalogue (167 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
it: float abs(float x)
    valore assoluto di x

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
it: float deg(float angolo)
    radianti a gradi

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
it: float rad(float angolo)
    gradi a radianti

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
it: float cosd(float angolo)
    coseno in gradi

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
it: float sind(float angolo)
    seno in gradi

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
it: float tand(float angolo)
    tangente in gradi

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
it: float acosd(float valore)
    arcocoseno in gradi

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
it: float asind(float valore)
    arcoseno in gradi

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
it: float atan2d(float y,float x)
    arcotangente in gradi di y/x tra -180 e 180

[ctx: builtin|]
en: float cos(float angle)
    cosine in radians
it: float cos(float angolo)
    coseno in radianti

[ctx: builtin|]
en: float sin(float angle)
    sine in radians
it: float sin(float angolo)
    seno in radianti

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
it: float tan(float angolo)
    tangente in radianti

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
it: float acos(float valore)
    arcocoseno in radianti

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
it: float asin(float valore)
    arcoseno in radianti

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
it: float atan(float valore)
    arcotangente in radianti

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
it: float atan2(float y,float x)
    arcotangente in radianti di y/x tra -PI e PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
it: float cosh(float angolo)
    coseno iperbolico in radianti

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
it: float sinh(float angolo)
    seno iperbolico in radianti

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
it: float tanh(float angolo)
    tangente iperbolica in radianti

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
it: float acosh(float valore)
    arcocoseno iperbolico in radianti

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
it: float asinh(float valore)
    seno iperbolico in radianti

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
it: float atanh(float valore)
    arcotangente iperbolica in radianti

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
it: float clamp(float x,float lo,float hi)
    vincola x all'intervallo [lo, hi]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
it: float round(float x)
    intero più vicino a x

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
it: float max(float a,float b)
    maggiore di a e b

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
it: float min(float a,float b)
    minore di a e b

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
it: float trunc(float a)
    intero più vicino verso lo zero

[ctx: builtin|]
en: float floor(float a)
    next lower integer
it: float floor(float a)
    intero successivo inferiore

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
it: float ceil(float a)
    intero successivo più alto

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
it: float invert(float a)
    Definito come 1-x

[ctx: builtin|]
en: float cbrt(float x)
    cube root
it: float cbrt(float x)
    radice cubica

[ctx: builtin|]
en: float sqrt(float x)
    square root
it: float sqrt(float x)
    radice quadrata

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
it: float exp(float x)
    E elevato alla potenza di x

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
it: float pow(float x)
    x alla potenza di y, disponibile anche come ^

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
it: float log(float x)
    Logaritmo naturale

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

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
it: float fmod(float x,float y)
    resto di x/y (disponibile anche come operatore %)

[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
it: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Viene preso il valore assoluto di ciascun termine di rumore. Questo dà un aspetto fluttuante

[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
it: color cturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Viene preso il valore assoluto di ciascun termine di rumore. Questo dà un aspetto fluttuante

[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
it: vector vturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Viene preso il valore assoluto di ciascun termine di rumore. Questo dà un aspetto fluttuante

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
it: float compress(float x,float lo,float hi)
    Rimappa x in [0,1] a [lo,hi]

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

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
it: float gamma (float x, float g)
    Correzione gamma di x con fattore 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))
it: float bias(float x, float g)
    Variazione della gamma dove valori inferiori a 0,5 abbassano la curva
    e valori maggiori di 0,5 alzano la curva
    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.
it: float contrast(float x,float c)
    Regola il contrasto. &nbsp; Per c tra 0 e 0,5, il contrasto è ridotto.&nbsp; Per c &gt; 0,5, il contrasto è aumentato.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
it: float boxstep(float x,float a)
     se x < a allora 0 altrimenti 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
it: float linearstep(float x,float a,float b)
     se x &lt; a allora 0, se x &gt; b allora 1, e
    x passa 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
it: float smoothstep(float x,float a,float b)
     se x &lt; a allora 0, se x &gt; b allora 1, e
    x passa gradualmente (cubica) 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
it: float gasussstep(float x,float a,float b)
     se x &lt; a allora 0, se x &gt; b allora 1, e
    x passa in modo graduale (esponenzialmente) 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
it: remap(float x, float source, float range, float falloff, float interp)
    Funzione di ri-mappatura generale.
    Quando x è all'interno di +/- il<i>range</i> della sorgente, il risultato è uno.
    Il risultato scende a zero oltre tale intervallo sulla distanza di <i>falloff</i>.
    La forma del decadimento è controllata da <i>interp</i>. Valori numerici
    o costanti con nome possono essere utilizzati:
    &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.
it: mix(float a,float b,float alpha)
    Miscela di a e b in base ad 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.
it: color  hsi(color x, float h, float s, float i, float map=1)
    La funzione hsi sposta la tonalità di h
    (in gradi) e scala la saturazione e l'intensità di s e i
    rispettivamente.&nbsp;Potrebbe essere fornita una mappa che controllerà lo spostamento
    - lo spostamento completo avverrà quando la mappa è una e nessuno spostamento
    si verifica quando la mappa è zero.&nbsp;Lo spostamento sarà ridotto per
    valori compresi tra zero e 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.
it: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    La funzione midhsi è proprio come la funzione hsi tranne che
    la mappa di controllo è centrata attorno al punto medio (valore 0,5)
    e può scalare lo spostamento in entrambe le direzioni.

[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.
it: color rgbtohsl(color rgb)
    Conversione dello spazio dei colori da RGB a HSL.
    HSL sta per Tonalità (Hue), Saturazione, Luminosità (tutto nell'intervallo [0..1])
    Queste funzioni sono state estese anche per supportare i valori rgb e hsl
    al di fuori dell'intervallo [0..1] in modo ragionevole.&nbsp;Per qualsiasi valore rgb o
    hsl (ad eccezione dei valori s negativi), la conversione è
    ben definita e reversibile.

[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.
it: color hsltorgb(color hsl)
    Conversione dello spazio dei colori da HSL a RGB.
    HSL sta per Tonalità (Hue), Saturazione, Luminosità (tutto nell'intervallo [0..1])
    Queste funzioni sono state estese anche per supportare i valori rgb e hsl
    al di fuori dell'intervallo [0..1] in modo ragionevole.&nbsp;Per qualsiasi valore rgb o
    hsl (ad eccezione dei valori s negativi), la conversione è
    ben definita e reversibile.

[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.
it: color saturate(color val, float amt)
    Scala la saturazione del colore di amt.
    Il colore viene ridimensionato attorno al valore di luminanza di rec709,
    e i risultati negativi sono fissati a 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.
it: float rand ( [float min, float max], [float seme] )
    Numero casuale compreso tra [min, max] (o [0, 1] se non specificato).
    Se viene fornito un seme, sarà utilizzato in aggiunta ai semi interni epuò essere utilizzato per creare più generatori distinti.

[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.
it: float hash(float seed1,[float seed2, ...])
    Come rand, ma senza semi interni. Può essere fornito un numero qualsiasi di semi
    e il risultato sarà una funzione casuale basata su tutti i semi.

[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)
it: 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 )
    Rumore di Perlin originale nella posizione (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)
it: float snoise ( vector v)
    rumore con segno nell'intervallo da -1 a 1 formato con rumore di Perlin originale nella posizione (interpolante C2)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
it: vector vnoise ( vector v)
    rumore vettoriale formato con rumore di Perlin originale nella posizione (interpolante C2)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
it: color cnoise ( vector v)
    rumore di colore formato con rumore di Perlin originale nella posizione (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)
it: float snoise4 ( vector v,float t)
    rumore 4D con segno nell'intervallo da -1 a 1 formato con rumore di Perlin originale nella posizione (interpolante C2)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
it: vector vnoise4 ( vector v,float t)
    rumore vettoriale 4D formato con rumore di Perlin originale nella posizione (interpolante C2)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
it: color cnoise4 ( vector v,float t)
    rumore di colore 4D formato con rumore di Perlin originale nella posizione (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.
it: float fbm(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (moto browniano frazionario) è una funzione di rumore multi-frequenza.
    La frequenza di base è la stessa della funzione «noise». Il numero
    totale di frequenze è controllato da ottave. La lacunarità è la
    spaziatura tra le frequenze - un valore di 2 significa che ogni ottava è
    due volte la frequenza precedente. Il guadagno controlla quanto ciascuna
    frequenza viene scalata rispetto alla frequenza precedente.

[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.
it: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (moto browniano frazionario) è una funzione di rumore multi-frequenza.
    La frequenza di base è la stessa della funzione «noise». Il numero
    totale di frequenze è controllato da ottave. La lacunarità è la
    spaziatura tra le frequenze - un valore di 2 significa che ogni ottava è
    due volte la frequenza precedente. Il guadagno controlla quanto ciascuna
    frequenza viene scalata rispetto alla frequenza precedente.

[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.
it: float cellnoise(vector v)
    cellnoise genera un campo di cubi colorati costanti in base alla posizione dell'intero.
    È uguale alla funzione prman cellnoise.

[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.
it: color cellnoise(vector v)
    cellnoise genera un campo di cubi colorati costanti in base alla posizione dell'intero.
    È uguale alla funzione prman cellnoise.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
it: float pnoise ( vector v, vector period )
    rumore periodico

[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.
it: float voronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    voronoi è un modello di rumore cellulare. È una variante con jitter di 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.
it: color cvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    restituisce il colore nel modello cellulare. È una variante con jitter di 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.
it: color pvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    restituisce il centro della cellula voronoi.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
it: float dist(vector a, vector b)
    distanza tra due punti

[ctx: builtin|]
en: float length(vector v)
    length of vector
it: float length(vector v)
    lunghezza del vettore

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

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
it: float dot(vector a,vector b)
    prodotto scalare

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
it: vector norm(vector v)
    vettore scalato alla lunghezza unitaria

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
it: vector cross(vector a,vector b)
    prodotto vettoriale

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
it: float angle(vector a,vector b)
    angolo tra due vettori (in radianti)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
it: vector angle(vector a,vector b)
    vettore normalizzato ortogonale ad a e b scalato alla lunghezza unitaria

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
it: vector rotate(vector v,vector axis,float angle)
    ruota v attorno all'asse di un dato angolo (in radianti)

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
it: vector up(vector P,vector upvec)
    ruota v in modo tale che l'asse Y punti nella direzione indicata

[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)``.
it: int cycle(int index, int loRange, int hiRange )
    Passa attraverso i valori tra loRange e hiRange in base all'indice fornito.
    Questa è una funzione «mod» di offset. Il risultato è calcolato come ``loRange + value % (hiRange-loRange+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.
it: int pick (float index, int loRange, int hiRange, [float weights, ...])
    Seleziona i valori in modo casuale tra loRange e hiRange in base all'indice fornito (per cui viene generato
    automaticamente un hash).&nbsp;I valori verranno distribuiti secondo
    ai pesi forniti.&nbsp;Si assume che i pesi non forniti
    siano 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]).
it: color swatch (float index, colore choice0, color choice1, color choice2, [...])
    Sceglie una delle scelte di colore fornite in base all'indice (presumibilmente nell'intervallo [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]).
it: float choose(float index,float choice1, float choice2, [...])
    Seleziona una delle scelte fornite in base all'indice (assunto nell'intervallo [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.
it: float wchoose(float indice,float scelta1, float peso1, float scelta2, float peso2, [...] )
    Seleziona una delle scelte fornite in base all'indice (assunto nell'intervallo [0..1]).
    I valori saranno distribuiti in base ai pesi forniti.

[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]
it: float spline (float param,float y1,float y2,float y3,float y4,[...])
    
    Interpola un insieme di valori nel parametro specificato dove y1, ..., yn sono
    distribuiti uniformemente da [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)
it: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpola una rampa 1D definita dai punti di controllo in «param». I punti di controllo sono specificati
    per triple dei parametri pos_i, val_i e interp_i. I codici di interpolazione sono 
    0 - nessuna, 1 - lineare, 2 - liscia, 3 - spline,
    4 - monotona (spline non oscillante)

[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)
it: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpola la scala di colori fornita dai punti di controllo in «param». I punti di controllo sono specificati
    da triple dei parametri pos_i, val_i e interp_i. I codici di interpolazione sono
    0 - nessuna, 1 - lineare, 2 - liscia, 3 - spline,
    4 - monotona (spline non oscillante)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
it: getVar (string varName,vector defaultValue)
    restituisce il valore di varName se la variabile esiste, altrimenti restituisce defaultValue

[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.
it: printf (formato stringa,[vec0, vec1, ...])
    Stampa una stringa su STDOUT, i parametri di formato consentiti sono è «%v» and «%f».
    Il parametro di ritorno è vuoto, ma deve essere assegnato a una variabile.

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
it: sprintf (formato stringa, [double|stringa, double|stringa, ...])
    Restituisce una stringa formattata dai valori forniti. Vedi «man sprintf» per i dettagli del formato.

[ctx: ExprControlCollection|]
en: Add new variable
it: Aggiungi una nuova variabile

[ctx: ErrorMessages|]
en: Expected string or float[d]
it: Stringa o float[d] atteso

[ctx: ErrorMessages|]
en: Expected float[d]
it: float[d] atteso

[ctx: ErrorMessages|]
en: Expected float[%1]
it: float[%1] atteso

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
it: Tipo non corrispondente, primo: «%1»; secondo «%2»

[ctx: ErrorMessages|]
en: Expected float or float[3]
it: Float atteso o float[3]

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
it: Atteso «%1» come argomento, ricevuto «%2»

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
it: Numero di argomenti non corretto, dovrebbe essere da 1 a 7

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
it: Numero di argomenti non corretto, dovrebbe essere multiplo di 3 più 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
it: Numero di argomenti non corretto, dovrebbe essere 1 o più

[ctx: ErrorMessages|]
en: First argument must be a string
it: Il primo argomento deve essere una stringa

[ctx: ErrorMessages|]
en: Incomplete format specifier
it: Specificatore di formato incompleto

[ctx: ErrorMessages|]
en: No variable named '%1'
it: Nessuna variabile con nome «%1»

[ctx: ErrorMessages|]
en: Function '%1' has no definition
it: La funzione «%1» non ha definizione

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
it: L'operazione di assegnazione ha il tipo non corretto «%1»

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
it: I tipi di condizione non sono compatibili

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
it: Variabile «%1» definita nelle condizioni in modo incoerente

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
it: Troppi argomenti per la funzione «%1»

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
it: Troppi argomenti per la funzione «%1»

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
it: Tipo di espressione generato «%1», incompatibile con il tipo desiderato «%2»

[ctx: ErrorMessages|]
en: Syntax error near '%1'
it: Errore di sintassi vicino a «%1»

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
it: Fine di espressione inattesa vicino a «%1»

[ctx: ErrorMessages|]
en: Unexpected end of format string
it: Fine inattesa della stringa di formato

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
it: Formato non valido, è consentito solo %v o %f

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
it: Numero di argomenti non corretto per la stringa di formato

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
it: Errore sconosciuto (messaggio = %1)

[ctx: ExprAddDialog|]
en: Variable
it: Variabile

[ctx: ExprAddDialog|]
en: Lookup
it: Ricerca

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

[ctx: ExprAddDialog|]
en: Color Curve
it: Curva di colore

[ctx: ExprAddDialog|]
en: Default
it: Predefinita

[ctx: ExprAddDialog|]
en: Vector
it: Vettore

[ctx: ExprAddDialog|]
en: Color
it: Colore

[ctx: ExprAddDialog|]
en: Rainbow
it: Arcobaleno

[ctx: ExprAddDialog|]
en: Shades of Gray
it: Sfumature di grigio

[ctx: ExprAddDialog|]
en: Colors
it: Colori

[ctx: ExprAddDialog|]
en: Swatch
it: Campione

[ctx: ExprAddDialog|]
en: string
it: stringa

[ctx: ExprAddDialog|]
en: file
it: File

[ctx: ExprAddDialog|]
en: directory
it: cartella

[ctx: ExprAddDialog|]
en: String Name
it: Nome stringa

[ctx: ExprAddDialog|]
en: String Type
it: Tipo stringa

[ctx: ExprAddDialog|]
en: String Default
it: Valore predefinito stringa

[ctx: ExprAddDialog|]
en: String
it: Stringa

[ctx: ExprBrowser|]
en: Save Expression
it: Salva espressione

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
it: Impossibile aprire il file %1 in scrittura

[ctx: ExprBrowser|]
en: Error
it: Errore

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
it: Impossibile aprire il file %1 in scrittura. È in sola lettura?

[ctx: CCurveScene|]
en: Delete Point
it: Elimina punto

[ctx: ExprColorCurve|]
en: Selected Position:
it: Posizione selezionata:

[ctx: ExprColorCurve|]
en: Selected Color:
it: Colore selezionato:

[ctx: ExprColorCurve|]
en: None
it: Nessuno

[ctx: ExprColorCurve|]
en: Linear
it: Lineare

[ctx: ExprColorCurve|]
en: Smooth
it: Smussatura

[ctx: ExprColorCurve|]
en: &Expand...
it: &Espandi...

[ctx: ExprColorFrame|]
en: Delete Swatch
it: Elimina campione

[ctx: ExprColorFrame|]
en: Cancel
it: Annulla

[ctx: ExprColorSwatchWidget|]
en: &Add...
it: &Aggiungi...

[ctx: ExprCompletionModel|]
en: Local
it: Locale

[ctx: StringControl|]
en: Please choose a file
it: Scegli un file

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

[ctx: CurveScene|]
en: Delete Point
it: Elimina punto

[ctx: ExprCurve|]
en: Selected Position:
it: Posizione selezionata:

[ctx: ExprCurve|]
en: Selected Value:
it: Valore selezionato:

[ctx: ExprCurve|]
en: None
it: Nessuno

[ctx: ExprCurve|]
en: Linear
it: Lineare

[ctx: ExprCurve|]
en: Smooth
it: Smussatura

[ctx: ExprCurve|]
en: &Expand...
it: &Espandi...

[ctx: ExprEditor|]
en: Expression Editor
it: Editor delle espressioni

[ctx: ExprFileDialog|]
en: Open
it: Apri

[ctx: ExprFileDialog|]
en: Favorites
it: Preferiti

[ctx: ExprTextEdit|]
en: Pop-up Help
it: Aiuto a comparsa
