seexpr2_qt - en to fr translation catalogue (182 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
fr: float abs (float x)
    Valeur absolue de x

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
fr: float deg (float angle)
    Conversion de degrés en radians

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
fr: float rad (float angle)
    Conversion de degrés en radians

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
fr: float cosd (float angle)
    cosinus en degrés

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
fr: float sind (float angle)
    sinus en degrés

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
fr: float tand (float angle)
    tangente en degrés

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
fr: float acosd (float value)
    arc cosinus en degrés

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
fr: float asind (float value)
    arc sinus en degrés

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
fr: float atand (float value)
    arc tangente en degrés

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
fr: float atan2d (float y, float x)
    arc tangente en degrés de y divisé par x entre -180 et 180 degrés

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

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

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

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

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

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

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
fr: float atan2 (float y, float x)
    arc tangente en radians de y divisé par x entre -Pi et +Pi

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
fr: float cosh (float angle)
    cosinus hyperbolique en radians

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
fr: float sinh (float angle)
    sinus hyperbolique en radians

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
fr: float tanh (float angle)
    tangente hyperbolique en radians

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
fr: float acosh (float value)
    arc cosinus hyperbolique en radians

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
fr: float asinh (float value)
    arc sinus hyperbolique en radians

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
fr: float atanh (float value)
    arc tangente hyperbolique en radians

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
fr: float clamp (float x, float lo, float hi)
    Limiter x à l'intervalle [lo,hi]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
fr: float round (float x)
    entier le plus proche de x

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
fr: float max (float a, float b)
    le plus grand entre a et b

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
fr: float min(float a,float b)
    Le plus petit entre a et b

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
fr: float trunc (float a)
    Entier le plus proche de zéro

[ctx: builtin|]
en: float floor(float a)
    next lower integer
fr: float floor (float a)
    Entier inférieur suivant

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
fr: float ceil (float a)
    Entier supérieur suivant

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
fr: float invert (float a)
    Défini comme « 1 - x »

[ctx: builtin|]
en: float cbrt(float x)
    cube root
fr: float cbrt (float x)
    racine cubique

[ctx: builtin|]
en: float sqrt(float x)
    square root
fr: float sqrt (float x)
    Racine carrée

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
fr: float exp (float x)
    E élevé à la puissance x

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
fr: float pow (float x, float y)
    Élévation de x à la puissance y, aussi noté x^y

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
fr: float log (float x)
    Logarithme classique

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

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
fr: float fmod (float x, float y)
    Reste de la division entière de x par y (aussi nommé sous la forme x % y)

[ctx: builtin|]
en: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolute value of each noise term is taken. This gives billowy appearance
fr: float turbulence (vector v, int octaves=6, float lacunarity=2, float gain=0.5)
    La valeur absolue de chaque terme de bruit est prise. Ceci donne une apparence agitée.

[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
fr: color cturbulence(vector v, int octaves=6, float lacunarity=2, float gain=0.5)
    La valeur absolue de chaque terme de bruit est prise. Ceci donne une apparence agitée.

[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
fr: vector vturbulence (vector v, int octaves=6, float lacunarity=2, float gain=0.5)
    La valeur absolue de chaque terme est prise. Ceci donne une apparence agitée.

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
fr: float compress (float x, float lo, float hi)
    Recales x dans [0,1] vers [lo, hi]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
fr: float expand (float x, float lo, float hi)
    Recales x dans [lo,hi] vers [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]
fr: float fit (float x, float a1, float b1, float a2, float b2)
    Recales linéairement x dans [a1, b1] vers [a2, b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
fr: float gamma (float x, float g)
    Correction de « Gamma » de x selon le facteur « Gamma »

[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))
fr: float bias (float x, float g)
    La variation de « Gamma » où les valeurs inférieures à 0.5 déplacent la courbe vers le bas et 
    les valeurs supérieures à 0.5 vers le haut
    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.
fr: float contrast (float x, float c)
    Ajuste le contrast. Pour c allant de 0 à 0.5, le contraste et diminué. Pour c supérieur à 0.5, le contraste est augmenté.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
fr: float boxstep (float x,float a)
    si x est strictement plus petit que y alors 0 sinon 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
fr: float linearstep (float x, float a, float b)
    Si x &lt; a alors 0, si x &gt; b alors 1 et
    x est extrapolé linéairement quand &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
fr: float smoothstep (float x, float a, float b)
    Si x &lt; a alors 0, si x &gt; b alors 1, et
    x extrapolé doucement (cubique) quand &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
fr: float gasussstep (float x, float a, float b)
    si x &lt; a alors 0, si x &gt; b alors 1, et
    x est extrapolé doucement (exponentiellement) quand 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
fr: remap (float x, float source, float range, float falloff, float interp)
    Fonction générale de ré-association.
    Quand x est dans +/- <i>range</i> de source, le résultat est 1.
    Le résultat passe à zéro sous cette intervalle au dessus de la distance <i>falloff</i>.
    La condition falloff est contrôlé par <i>interp</i>. Les valeurs numériques
    ou les constantes nommées peuvent être utilisées :
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>linéaire</b> = 0
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>doux</b> = 1
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>gaussien</b> = 2

[ctx: builtin|]
en: mix(float a,float b,float alpha)
    Blend of a and b according to alpha.
fr: mix (float a, float b, float alpha)
    Mélange de a et b selon alpha.

[ctx: builtin|]
en: color  hsi(color x, float h, float s, float i, float map=1)
    The hsi function shifts the hue by h
    (in degrees) and scales the saturation and intensity by s and i
    respectively.&nbsp; A map may be supplied which will control the shift
    - the full shift will happen when the map is one and no shift will
    happen when the map is zero.&nbsp; The shift will be scaled back for
    values between zero and one.
fr: color hsi (color x, float h, float s, float i, float map=1)
    La fonction « hsi » décale la tonalité chromatique par h
    (en degrés) et dimensionne la saturation et l'intensité lumineuse respectivement par s et i.
    Une carte peut être fournie contrôlant le décalage
    - le décalage complet se produira quand la carte est unique et qu'aucun décalage ne se produira quand la carte est à zéro. Le décalage sera dimensionné en retour pour 
    des valeurs entre 0 et 1.

[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.
fr: color midhsi (color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    La fonction « midhsi » est similaire à la fonction « hsi » excepté que
    la carte de contrôle est centré autour du point médian (valeur de 0.5)
    et peut dimensionner le positionnement dans les deux directions.

[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.
fr: color rgbtohsl (color rgb)
    Conversion de l'espace colorimétrique de RGB vers HSL.
    HSL est la tonalité chromatique « Hue », la saturation « Saturation »
    , l'intensité lumineuse « Lightness » (tout entre [0..1] )
    Ces fonctions ont aussi été étendues pour la prise en charge des valeurs
     « rgb » et « hsl » en dehors de l'intervalle [0..1] de façon raisonnable. Pour toute valeur
     « rgb » et « hsl » (excepté les valeurs négatives),
     la conversion est bien définie et réversible.

[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.
fr: color hsltorgb (color hsl)
    Conversion de l'espace colorimétrique de HSL vers RGB.
    HSL est la tonalité chromatique « Hue », la saturation « Saturation »,
     l'intensité lumineuse « Lightness » (tout entre [0..1] )
    Ces fonctions ont aussi été étendues pour la prise en charge des valeurs « rgb » et « hsl »
    en dehors de l'intervalle [0..1] de façon raisonnable. Pour toute valeur
     « rgb » et « hsl » (excepté les valeurs négatives), la conversion est bien définie et
     réversible.

[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.
fr: color saturate (color val, float amt)
    Réduire la saturation de couleurs par amt.
    La couleur est réduite d'environ de la valeur de luminance « rec709 »,
    et les résultats négatifs sont calés à zéro.

[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.
fr: float rand ([float min, float max], [float seed] )
    Nombre aléatoire entre [min, max](ou [0, 1] si non spécifié).
    Si une initialisation « seed » est fournie, elle sera utilisée en addition des initialisations internes et pourra être utilisée pour créer de multiples générateurs distincts.

[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.
fr: float hash (float seed1, [float seed2,...])
    Comme la fonction « rand » mais sans aucune initialisation interne
    et le résultat sera une fonction aléatoire reposant sur toutes les initialisations.

[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)
fr: 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 )
    Bruit original de Perlin à cet emplacement (C2 interpolant)

[ctx: builtin|]
en: float snoise ( vector v)
    signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
fr: float snoise ( vector v)
    Bruit signé «  w/ range -1 » vers 1, constitué par le bruit original de Perlin à l'emplacement (C2 interpolant)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
fr: vector vnoise ( vector v)
    Vecteur de bruit constitué par le bruit original de Perlin à cet emplacement (C2 interpolant)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
fr: color cnoise (vector v)
    Bruit de couleurs constitué par le bruit original de Perlin à cet emplacement (C2 interpolant)

[ctx: builtin|]
en: float snoise4 ( vector v,float t)
    4D signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
fr: float snoise4 ( vector v, float t)
    Bruit « 4D » signé «  w/ range -1 » vers 1, constitué par le bruit original de Perlin à l'emplacement (C2 interpolant)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
fr: vector vnoise4 ( vector v, float t)
    Vecteur de bruit « 4D » constitué par le bruit original de Perlin à cet emplacement (C2 interpolant)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
fr: color cnoise4 (vector v, float t)
    Bruit de couleurs « 4D » constitué par le bruit original de Perlin à cet emplacement (C2 interpolant)

[ctx: builtin|]
en: float fbm(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractal Brownian Motion) is a multi-frequency noise function. 
    The base frequency is the same as the "noise" function. The total number of frequencies is controlled by octaves. The lacunarity is the spacing between the frequencies - a value of 2 means each octave is twice the previous frequency. The gain controls how much each frequency is scaled relative to the previous frequency.
fr: float fbm (vector v, int octaves=6, float lacunarity=2, float gain=0.5)
    fbm « Fractal Brownian Motion » est une fonction de bruit multi-fréquence. 
    La fréquence de base est la même que la fonction « noise ». Le nombre total de fréquences est contrôlé par octaves. La lacunarité est l'espacement entre les fréquences - une valeur de 2 signifie que chaque octave est deux fois la fréquence précédente. Le gain contrôle de combien chaque fréquence est étendue relativement à la fréquence précédente.

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

[ctx: builtin|]
en: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractal Brownian Motion) is a multi-frequency noise function. 
    The base frequency is the same as the "noise" function. The total 
    number of frequencies is controlled by octaves. The lacunarity is the 
    spacing between the frequencies - a value of 2 means each octave is 
    twice the previous frequency. The gain controls how much each 
    frequency is scaled relative to the previous frequency.
fr: float fbm4 (vector v, float time, int octaves=6, float lacunarity=2, float gain=0.5)
    fbm, « Fractal Brownian Motion », est une fonction de bruit multi-fréquence. 
    La fréquence de base est la même que la fonction « noise ». Le nombre total
     de fréquences est contrôlé par octaves. La lacunarité est l'espacement entre
     les fréquences - une valeur de 2 signifie que chaque octave est deux fois la
     fréquence précédente. Le gain contrôle de combien chaque fréquence est
     étendue relativement à la fréquence précédente.

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

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

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

[ctx: builtin|]
en: float cellnoise(vector v)
    cellnoise generates a field of constant colored cubes based on the integer location.
    This is the same as the prman cellnoise function.
fr: float cellnoise (vector v)
    La fonction « cellnoise » génère un ensemble de cubes constants et colorés selon un emplacement entier.
    Elle est identique à la fonction « prman » pour le bruit dans les cellules.

[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.
fr: float cellnoise (vector v)
    La fonction « cellnoise » génère un ensemble de cubes constants et colorés selon un emplacement entier.
    Elle est identique à la fonction « prman » pour le bruit dans les cellules.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
fr: float pnoise (vector v, vector period)
    bruit périodique

[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.
fr: float voronoi (vector v, int type=1, float jitter=0.5, float fbmScale=0, int fbmOctaves=4, float fbmLacunarity=2, float fbmGain=0.5)
    « Voronoi » est un profil de bruit cellulaire. C'est une variante instable de la fonction « 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.
fr: color cvoronoi (vector v, int type=1, float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=0.5)
    retourne une couleur dans un profil de cellules. C'est une variante instable de la fonction « 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.
fr: color pvoronoi(vector v, int type=1, float jitter=0.5, float fbmScale=0, int fbmOctaves=4, float fbmLacunarity=2, float fbmGain=0.5)
    retourne la cellule de Voronoi.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
fr: float dist (vector a, vector b)
    distance entre deux points

[ctx: builtin|]
en: float length(vector v)
    length of vector
fr: float length (vector v)
    longueur du vecteur

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
fr: float hypot (vector v)
    longueur d'un vecteur à deux dimensions [x,y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
fr: float dot (vector a, vector b)
    vecteur.produit

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
fr: vector norm (vector v)
    vecteur redimensionné à la longueur de l'unité

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
fr: vector cross (vector a, vector b)
    vecteur x produit

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
fr: float angle (vector a, vector b)
    angle formé par deux vecteurs (en radians)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
fr: vector angle (vector a, vector b)
    vecteur normé orthogonal à a et b, redimensionné à la longueur de l'unité

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
fr: vector rotate (vector v, vector axis, float angle)
    tournes v autour l'axe donné par un angle donné (en radians).

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
fr: vector up (vector P, vector upvec)
    tournes v tel que l'axe Y pointe dans une direction donnée.

[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)``.
fr: int cycle (int index, int loRange, int hiRange )
    Parcourt les valeurs entre « loRange » et « hiRange » reposant sur l'index fourni.
    Ceci est une fonction dérivée de « mod ». Le résultat est calculé comme « 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.
fr: int pick (float index, int loRange, int hiRange, [float weights,...] )
    Sélectionne des valeurs aléatoires dans l'intervalle « loRange » et
     « hiRange » selon l'index fourni (lequel est automatiquement haché). Les
     valeurs seront distribués selon 
    les poids fournis. Si non fourni, le poids est supposé valoir 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]).
fr: color swatch (float index, color choice0, color choice1, color choice2, [...])
    Sélectionne un des choix fournis de couleurs selon l'index (supposé être dans [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]).
fr: float choose (float index, float choice1, float choice2, [...])
    Sélectionne un des choix proposés selon l'index (est supposé être entre [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.
fr: float wchoose (float index, float choice1, float weight1, float choice2, float weight2, [...] )
    Choisit un des choix fournis selon l'index (en supposant qu'il soit dans l'intervalle [0..1]).
    Les valeurs seront distribuées selon les poids fournis.

[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]
fr: float spline (float param, float y1, float y2, float y3, float y4, [...])
    
    Interpole un ensemble de valeurs selon le paramètre spécifié, où y1,..., yn sont
    distribués de façon uniforme entre [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)
fr: float curve (float param, float pos0, float val0, int interp0, float pos1, float val1, int interp1, [...])
    
    Interpole une rampe « 1D » définie par des points de contrôle de « param ». Les points de contrôle sont spécifiés 
    par des triplets de paramètres « pos_i », « val_i » et « interp_i ». Les codes d'interpolation sont 
    0 - aucun, 1 - linéaire, 2 - doux, 3 - courbe, 
    4-monotone (courbe 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)
fr: color curve (float param, float pos0, color val0, int interp0, float pos1, color val1,int interp1,[...])
    
    Interpole une rampe définie par des points de contrôle de « param ». Les points de contrôle sont spécifiés par des triplets de paramètres pos_i, val_i, et interp_i. Les codes d'interpolation sont 
    0 - aucun, 1 - linéaire, 2 - doux, 3 - courbe, 
    4 - monotone (courbe non oscillante)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
fr: getVar (string varName, vector defaultValue)
    retourne la valeur de « varName » si la variable existe, sinon retourne « 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.
fr: float printf (string format, [vec0, vec1,...])
    Imprime une chaîne sur « stdout ». Les paramètres de formatage sont « %v » et « %f ».
    Le paramètre retourné est vide mais doit être stocké dans une 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.
fr: sprintf (string format, [double|string, double|string,...])
    Retourne une chaîne formatée à partir des valeurs fournies. Veuillez  consulter « man sprintf » pour des informations détaillées sur le format.

[ctx: ExprControlCollection|]
en: Add new variable
fr: Ajouter une nouvelle variable

[ctx: ErrorMessages|]
en: Expected string or float[d]
fr: Flottant ou chaîne attendus [d]

[ctx: ErrorMessages|]
en: Expected float[d]
fr: Flottant attendu [d]

[ctx: ErrorMessages|]
en: Expected float[%1]
fr: Flottant attendu [%1]

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
fr: Incohérence de type, premier arg : « %1 » ; second arg : « %2 »

[ctx: ErrorMessages|]
en: Expected float or float[3]
fr: Flottant attendu ou flottant [3]

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
fr: Argument attendu « %1 » mais fourni « %2 »

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
fr: Nombre incorrect d'arguments. Devrait être entre 1 et 7.

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
fr: Nombre incorrect d'arguments. Devrait être multiple de 3 plus 1.

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
fr: Nombre incorrect d'arguments. Devrait être 1 ou plus.

[ctx: ErrorMessages|]
en: First argument must be a string
fr: Le premier argument doit être une chaîne

[ctx: ErrorMessages|]
en: Incomplete format specifier
fr: Spécificateur de format incomplet

[ctx: ErrorMessages|]
en: No variable named '%1'
fr: Aucune variable nommée « %1 »

[ctx: ErrorMessages|]
en: Function '%1' has no definition
fr: La fonction « %1 » n'a aucune définition

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
fr: L'opération d'affectation a un type incorrect « %1 »

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
fr: Les types de conditions sont incompatibles.

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
fr: La variable « %1 » est définie de façon incohérente dans les conditions

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
fr: Nombre d'arguments insuffisant pour la fonction « %1 »

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
fr: Nombre d'arguments trop important pour la fonction « %1 »

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
fr: Type généré de l'expression « %1 », incompatible avec le type attendu « %2 »

[ctx: ErrorMessages|]
en: Syntax error near '%1'
fr: Erreur de syntaxe à proximité de « %1 »

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
fr: Fin inattendue d'expression à proximité de « %1 »

[ctx: ErrorMessages|]
en: Unexpected end of format string
fr: Fin inattendue de la chaîne de formatage

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
fr: Chaîne de formatage non valable. Seuls « %v » ou « %f » sont autorisés.

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
fr: Nombre incorrect d'arguments pour la chaîne de formatage.

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
fr: Erreur inconnue (message = %1)

[ctx: ExprAddDialog|]
en: Lookup
fr: Rechercher

[ctx: ExprAddDialog|]
en: Curve
fr: Courbe

[ctx: ExprAddDialog|]
en: Color Curve
fr: Colorer la courbe

[ctx: ExprAddDialog|]
en: Default
fr: Par défaut

[ctx: ExprAddDialog|]
en: Int
fr: Ent

[ctx: ExprAddDialog|]
en: Float
fr: Flottant

[ctx: ExprAddDialog|]
en: Vector
fr: Vecteur

[ctx: ExprAddDialog|]
en: Color
fr: Couleur

[ctx: ExprAddDialog|]
en: Rainbow
fr: Arc-en-ciel

[ctx: ExprAddDialog|]
en: Shades of Gray
fr: Nuances de gris

[ctx: ExprAddDialog|]
en: Colors
fr: Couleurs

[ctx: ExprAddDialog|]
en: Swatch
fr: Nuancier

[ctx: ExprAddDialog|]
en: string
fr: chaîne

[ctx: ExprAddDialog|]
en: file
fr: Fichier

[ctx: ExprAddDialog|]
en: directory
fr: dossier

[ctx: ExprAddDialog|]
en: String Name
fr: Nom de la chaîne

[ctx: ExprAddDialog|]
en: String Type
fr: Type de chaîne

[ctx: ExprAddDialog|]
en: String Default
fr: Chaîne par défaut

[ctx: ExprAddDialog|]
en: String
fr: Chaîne

[ctx: ExprBrowser|]
en: Save Expression
fr: Enregistrer une expression

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
fr: Impossible d'ouvrir le fichier %1 pour y écrire

[ctx: ExprBrowser|]
en: Error
fr: Erreur

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
fr: Impossible d'ouvrir le fichier %1 pour y écrire ? Serait-il en lecture seule ?

[ctx: CCurveScene|]
en: Delete Point
fr: Supprimer un point

[ctx: ExprColorCurve|]
en: Selected Position:
fr: Position sélectionnée :

[ctx: ExprColorCurve|]
en: Selected Color:
fr: Couleur sélectionnée :

[ctx: ExprColorCurve|]
en: Interp:
fr: Interp :

[ctx: ExprColorCurve|]
en: None
fr: Aucun

[ctx: ExprColorCurve|]
en: Linear
fr: Linéaire

[ctx: ExprColorCurve|]
en: Smooth
fr: Doux

[ctx: ExprColorCurve|]
en: Spline
fr: Courbe

[ctx: ExprColorCurve|]
en: &Expand...
fr: Développ&er...

[ctx: ExprColorFrame|]
en: Delete Swatch
fr: Supprimer le nuancier

[ctx: ExprColorFrame|]
en: Cancel
fr: Annuler

[ctx: ExprColorSwatchWidget|]
en: &Add...
fr: &Ajouter...

[ctx: StringControl|]
en: Please choose a file
fr: Veuillez choisir un fichier

[ctx: CurveControl|]
en: Pos:
fr: Pos :

[ctx: CurveControl|]
en: Val:
fr: Val :

[ctx: CurveControl|]
en: Interp:
fr: Interp :

[ctx: CCurveControl|]
en: Pos:
fr: Pos :

[ctx: CCurveControl|]
en: Val:
fr: Val :

[ctx: CCurveControl|]
en: Interp:
fr: Interp :

[ctx: CurveScene|]
en: Delete Point
fr: Supprimer un point

[ctx: ExprCurve|]
en: Selected Position:
fr: Position sélectionnée :

[ctx: ExprCurve|]
en: Selected Value:
fr: Valeur sélectionnée :

[ctx: ExprCurve|]
en: Interp:
fr: Interp :

[ctx: ExprCurve|]
en: None
fr: Aucun

[ctx: ExprCurve|]
en: Linear
fr: Linéaire

[ctx: ExprCurve|]
en: Smooth
fr: Doux

[ctx: ExprCurve|]
en: Spline
fr: Courbe

[ctx: ExprCurve|]
en: &Expand...
fr: Développ&er...

[ctx: ExprEditor|]
en: Expression Editor
fr: Éditeur d'expressions

[ctx: ExprEditor|]
en: (%1, %2): %3
fr: (%1, %2) : %3

[ctx: ExprFileDialog|]
en: Open
fr: Ouvrir

[ctx: ExprFileDialog|]
en: Favorites
fr: Favoris

[ctx: ExprTextEdit|]
en: Pop-up Help
fr: Aide contextuelle
