en to sv translation catalogue (173 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
sv: float abs(float x)
    absolutvärde av x

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
sv: float deg(float angle)
    radianer till grader

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
sv: float rad(float angle)
    grader till radianer

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
sv: float cosd(float angle)
    cosinus i grader

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
sv: float sind(float angle)
    sinus i grader

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
sv: float tand(float angle)
    tangens i grader

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
sv: float acosd(float value)
    arcus cosinus i grader

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
sv: float asind(float value)
    arcus sinus i grader

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
sv: float atand(float value)
    arcus tangens i grader

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
sv: float atan2d(float y,float x)
    arcus tangens i grader av y/x mellan -180 och 180

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

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

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
sv: float tan(float angle)
    tangens i radianer

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
sv: float acos(float value)
    arcus cosinus i radianer

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
sv: float asin(float value)
    arcus sinus i radianer

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
sv: float atan(float value)
    arcus tangens i radianer

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
sv: float atan2(float y,float x)
    arcus tangens i radianer av y/x mellan -PI och PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
sv: float cosh(float angle)
    hyperbolisk cosinus i radianer

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
sv: float sinh(float angle)
    hyperbolisk sinus i radianer

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
sv: float tanh(float angle)
    hyperbolisk tangens i radianer

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
sv: float acosh(float value)
    hyperbolisk arcus cosinus i radianer

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
sv: float asinh(float value)
    hyperbolisk arcus sinus i radianer

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
sv: float atanh(float value)
    hyperbolisk arcus tangens i radianer

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
sv: float clamp(float x,float lo,float hi)
    begränsar x till intervallet [lo,hi]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
sv: float round(float x)
    närmaste heltal till x

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
sv: float max(float a,float b)
    det största av a och b

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
sv: float min(float a,float b)
    det minsta av a och b

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
sv: float trunc(float a)
    närmaste heltal mot noll

[ctx: builtin|]
en: float floor(float a)
    next lower integer
sv: float floor(float a)
    nästa mindre heltal

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
sv: float ceil(float a)
    nästa större heltal

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
sv: float invert(float a)
    Definierat som 1-x

[ctx: builtin|]
en: float cbrt(float x)
    cube root
sv: float cbrt(float x)
    kubrot

[ctx: builtin|]
en: float sqrt(float x)
    square root
sv: float sqrt(float x)
    kvadratrot

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
sv: float exp(float x)
    e upphöjt till x

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
sv: float pow(float x, float y)
    x upphöjt till y, också tillgängligt som ^

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
sv: float log(float x)
    Naturlig logaritm

[ctx: builtin|]
en: float log10(float x)
    Base 10 logarithm
sv: float log10(float x)
    Bas 10 logaritm

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
sv: float fmod(float x,float y)
    rest av x/y (också tillgänglig som operatorn %)

[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
sv: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolutvärdet av varje brusterm beräknas. Det ger ett böljande utseende.

[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
sv: color cturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolutvärdet av varje brusterm beräknas. Det ger ett böljande utseende.

[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
sv: vector vturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolutvärdet av varje brusterm beräknas. Det ger ett böljande utseende.

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
sv: float compress(float x,float lo,float hi)
    Avbildar x inom [0,1] till [lo,hi]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
sv: float expand(float x,float lo,float hi)
    Avbildar x inom [lo,hi] till [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]
sv: float fit(float x,float a1,float b1,float a2,float b2)
    Avbildar x inom [a1,b1] linjärt till [a2,b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
sv: float gamma(float x, float g)
    Gammakorrigering av x med gammafaktor 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))
sv: float bias(float x, float g)
    Variation av gamma där värden mindre än 0,5 drar ner kurvan
    och värden större än 0,5 drar upp kurvan
    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.
sv: float contrast(float x,float c)
    Justerar kontrasten.&nbsp; För c från 0 till 0,5, minskas kontrasten.&nbsp; För c &gt; 0,5, ökas kontrasten.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
sv: float boxstep(float x,float a)
    om x < a är resultatet 0 annars 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
sv: float linearstep(float x,float a,float b)
     om x &lt; a är resultatet 0, om x &gt; b är det 1, och
    x ändras linjärt när &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
sv: float smoothstep(float x,float a,float b)
     om x &lt; a är resultatet 0, om x &gt; b är det 1, och
    x ändras jämnt (kubiskt) när 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
sv: float gasussstep(float x,float a,float b)
     om x &lt; a är resultatet 0, om x &gt; b är det 1, och
    x ändras jämnt (exponentiellt) när 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
sv: remap(float x, float source, float range, float falloff, float interp)
    Allmän avbildningsfunktion.
    När x är inom +/- <i>range</i> av source, är resultatet ett.
    Resultat minskar till noll bortom intervallet över avståndet <i>falloff</i>.
    Minskningens form bestäms av <i>interp</i>. Numeriska värden
    eller namngivna konstanter kan användas:
    &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.
sv: mix(float a,float b,float alpha)
    Blanda a och b enligt 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.
sv: color  hsi(color x, float h, float s, float i, float map=1)
    Funktionen hsi ändrar färgtonen med h
    (i grader) och skalar färgmättnaden och intensiteten med s och i.&nbsp;
    En avbildning kan anges som bestämmer skiftningen
    - fullständig skiftning sker när avbildningen är ett och igen skiftning
    sker när avbildningen är noll.&nbsp; Skiftningen skalas ner för
    värden mellan noll och ett.

[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.
sv: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    Funktionen midhsi är precis som funktionen hsi utom att
    kontrollavbildningen är centrerad omkring mittpunkten (värdet 0,5)
    och kan skala skiftningen i båda riktningar.

[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.
sv: color rgbtohsl(color rgb)
    RGB till HSL färgrymdskonvertering.
    HSL är färgton, färgmättnad, ljushet (alla i intervallet [0..1] )
    Funktionerna har också utökats för att stödja rgb- och hsi-värden
    utanför intervallet [0..1] på ett rimligt sätt.&nbsp; För alla rgb- eller
    hsl-värden (utom för negativa s-värden), är konverteringen
    väldefinierad och reversibel.

[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.
sv: color hsltorgb(color hsl)
    HSL till RGB färgrymdskonvertering.
    HSL är färgton, färgmättnad, ljushet (alla i intervallet [0..1] )
    Funktionerna har också utökats för att stödja rgb- och hsi-värden
    utanför intervallet [0..1] på ett rimligt sätt.&nbsp; För alla rgb- eller
    hsl-värden (utom för negativa s-värden), är konverteringen
    väldefinierad och reversibel.

[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.
sv: color saturate(color val, float amt)
    Skala färgmättnaden med amt.
    Färgen skalas omkring rec709 luminansvärde,
    och negativa resultat tvingas till noll.

[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.
sv: float rand ( [float min, float max], [float seed] )
    Slumptal mellan [min, max] (eller [0, 1] om de inte anges).
    Om ett frö anges, används det förutom de interna fröerna och kan användas för att skapa flera distinkta generatorer.

[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.
sv: float hash(float seed1,[float seed2, ...])
    Såsom rand, men utan några interna frön. Godtyckligt antal frön kan anges
    och resultatet är en slumpfunktion baserad på fröna.

[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)
sv: 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 )
    Ursprungligt perlin brus på plats (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)
sv: float snoise ( vector v)
    brus med tecken i intervallet -1 till 1 format med ursprungligt perlin brus på plats (C2 interpolant)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
sv: vector vnoise ( vector v)
    vektorbrus format med ursprungligt perlin brus på plats (C2 interpolant)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
sv: color cnoise ( vector v)
    färgbrus format med ursprungligt perlin brus på plats (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)
sv: float snoise4 ( vector v,float t)
    fyrdimensionellt brus med tecken i intervallet -1 till 1 format med ursprungligt perlin brus på plats (C2 interpolant)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
sv: vector vnoise4 ( vector v,float t)
    fyrdimensionellt vektorbrus format med ursprungligt perlin brus på plats (C2 interpolant)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
sv: color cnoise4 ( vector v,float t)
    fyrdimensionellt färgbrus format med ursprungligt perlin brus på plats (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.
sv: float fbm(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Funktionen fbm (fraktal Brownsk rörelse) är en brusfunktion med flera frekvenser. 
    Basfrekvensen är samma som funktionen "noise". Det totala antalet frekvenser bestäms av octaves. Värdet lacunarity är avståndet mellan frekvenserna: värdet 2 betyder att varje oktav är den dubbla av den föregående frekvensen. Värdet gain styr hur mycket varje frekvens skalas relativt till den föregående frekvensen.

[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.
sv: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
    Funktionen fbm (fraktal Brownsk rörelse) är en brusfunktion med flera frekvenser. 
    Basfrekvensen är samma som funktionen "noise". Det totala antalet 
    frekvenser bestäms av octaves. Värdet lacunarity är avståndet 
    mellan frekvenserna: värdet 2 betyder att varje oktav är den dubbla 
    av den föregående frekvensen. Värdet gain styr hur mycket varje 
    frekvens skalas relativt till den föregående frekvensen.

[ctx: builtin|]
en: color cfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
sv: icolor cfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.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.
sv: float cellnoise(vector v)
    cellnoise genererar ett fält av konstantfärgade kuber baserade på heltaletsplats.
    Det är samma sak som prman funktionen 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.
sv: color cellnoise(vector v)
    cellnoise genererar ett fält av konstantfärgade kuber baserade på heltaletsplats.
    Det är samma sak som prman funktionen cellnoise.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
sv: float pnoise ( vector v, vector period )
    periodiskt brus

[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.
sv: float voronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    voronoi är ett cellulärt brusmönster. Det är en gittervariant av 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.
sv: color cvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    returnerar färg i ett cellulärt mönster. Det är en gittervariant av 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.
sv: color pvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    returnerar centrum av en voronoi-cell.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
sv: float dist(vector a, vector b)
    avstånd mellan två punkter

[ctx: builtin|]
en: float length(vector v)
    length of vector
sv: float length(vector v)
    en vektors längd

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
sv: float hypot(vector v)
    längden av en 2d-vektor [x,y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
sv: float dot(vector a,vector b)
    vektorskalärprodukt

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
sv: vector norm(vector v)
    vektor skalad till enhetslängd

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
sv: vector cross(vector a,vector b)
    vektorkorsprodukt

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
sv: float angle(vector a,vector b)
    vinkel mellan två vektorer (i radianer)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
sv: vector angle(vector a,vector b)
    normalisera vektor ortogonalt mot a och b skalat till enhetslängd

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
sv: vector rotate(vector v,vector axis,float angle)
    roterar v omkring axeln axis med angiven vinkel angle (i radianer)

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
sv: vector up(vector P,vector upvec)
    roterar v så att Y-axeln pekar i angiven uppåtriktning

[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)``.
sv: int cycle(int index, int loRange, int hiRange )
    Går igenom värden mellan loRange och hiRange cykliskt baserat på angivna index.
    Det är en "mod" funktion. Resultatet beräknas som ``loRange + värde % (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.
sv: int pick(float index, int loRange, int hiRange, [float weights, ...] )
    Väljer värden slumpmässigt mellan loRange och hiRange baserat på angivet index (som
    automatiskt kondenseras).&nbsp; Värdena fördelas enligt
    angivna vikter.&nbsp; Alla vikter som inte anges antas
    vara 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]).
sv: color swatch(float index, color choice0, color choice1, color choice2, [...])
    Väljer ett av de tillhandahållna färgvalen baserat på index (antas vara i intervallet [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]).
sv: float choose(float index,float choice1, float choice2, [...])
    Väljer ett av de tillhandahållna valen baserat på index (antas vara i intervallet [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.
sv: float wchoose(float index,float choice1, float weight1, float choice2, float weight2, [...] )
    Väljer ett av de angivna värdena baserat på index (som antas vara i intervallet [0..1]).
    Värdena distribueras enligt de angivna vikterna.

[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]
sv: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Interpolerar en uppsättning värden till den angivna parametern där y1, ..., yn
    distribueras jämt från [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)
sv: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpolerar en endimensionell ramp definierad av styrpunkter i 'param'. Styrpunkter specificeras 
    av tripplar av parametrarna pos_i, val_i och interp_i. Interpolationskoder är 
    0 - ingen, 1 - linjär, 2 - jämn, 3 - spline, 
    4-monoton (icke-oscillerande spline)

[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)
sv: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpolerar en färgramp angiven av styrpunkter i 'param'. Styrpunkter specificeras 
    av tripplar av parametrarna pos_i, val_i och interp_i. Interpolationskoder är 
    0 - ingen, 1 - linjär, 2 - jämn, 3 - spline, 
    4-monoton (icke-oscillerande spline)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
sv: getVar(string varName,vector defaultValue)
    returnera värdet på varName om variabeln finns, returnera annars 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.
sv: float printf(string format,[vec0, vec1,  ...])
    Skriv ut en sträng till standardutmatningen, formatparametrar som tillåts är "%v" och "%f".
    Returparametern är tom, men måste tilldelas till en variabel.

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
sv: sprintf(string format, [double|string, double|string, ...])
    Returnerar en sträng formaterad från det givna värdet.  Se 'man sprintf' för formatinformation.

[ctx: ExprControlCollection|]
en: Add new variable
sv: Lägg till ny variabel

[ctx: ErrorMessages|]
en: Expected string or float[d]
sv: Förväntade sträng eller flyttal[d]

[ctx: ErrorMessages|]
en: Expected float[d]
sv: Förväntade flyttal[d]

[ctx: ErrorMessages|]
en: Expected float[%1]
sv: Förväntade flyttal[%1]

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
sv: Typmissanpassning, första: '%1', andra: '%2'

[ctx: ErrorMessages|]
en: Expected float or float[3]
sv: Förväntade flyttal eller flyttal[3]

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
sv: Förväntade '%1' som argument, erhöll '%2'

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
sv: Fel antal argument, ska vara 1 eller 7

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
sv: Fel antal argument, ska vara en multipel av 3 plus 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
sv: Fel antal argument, ska vara 1 eller fler

[ctx: ErrorMessages|]
en: First argument must be a string
sv: Första argumentet måste vara en sträng

[ctx: ErrorMessages|]
en: Incomplete format specifier
sv: Ofullständig formatspecificering

[ctx: ErrorMessages|]
en: No variable named '%1'
sv: Ingen variabel benämnd '%1'

[ctx: ErrorMessages|]
en: Function '%1' has no definition
sv: Funktionen '%1' saknar definition

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
sv: Tilldelningsoperation har felaktig typ '%1'

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
sv: Villkorsuttryckens typer är inte kompatibla

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
sv: Variabeln '%1' är inkonsekvent definierad i villkorsuttryck

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
sv: För få argument för funktionen '%1'

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
sv: För många argument för funktionen '%1'

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
sv: Uttryck genererade typen '%1', inkompatibel med önskad typ '%2'

[ctx: ErrorMessages|]
en: Syntax error near '%1'
sv: Syntaxfel nära '%1'

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
sv: Oväntat slut på uttryck nära '%1'

[ctx: ErrorMessages|]
en: Unexpected end of format string
sv: Oväntat slut på formatsträng

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
sv: Ogiltig formatsträng, bara %v eller %f är tillåtna

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
sv: Fel antal argument för formatsträng

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
sv: Okänt fel (meddelande = %1)

[ctx: ExprAddDialog|]
en: Variable
sv: Variabel

[ctx: ExprAddDialog|]
en: Lookup
sv: Slå upp

[ctx: ExprAddDialog|]
en: Curve
sv: Kurva

[ctx: ExprAddDialog|]
en: Color Curve
sv: Färgkurva

[ctx: ExprAddDialog|]
en: Default
sv: Förval

[ctx: ExprAddDialog|]
en: Int
sv: Heltal

[ctx: ExprAddDialog|]
en: Float
sv: Flyttal

[ctx: ExprAddDialog|]
en: Vector
sv: Vektor

[ctx: ExprAddDialog|]
en: Color
sv: Färg

[ctx: ExprAddDialog|]
en: Rainbow
sv: Regnbåge

[ctx: ExprAddDialog|]
en: Shades of Gray
sv: Gråskala

[ctx: ExprAddDialog|]
en: Colors
sv: Färger

[ctx: ExprAddDialog|]
en: Swatch
sv: Färgruta

[ctx: ExprAddDialog|]
en: string
sv: sträng

[ctx: ExprAddDialog|]
en: file
sv: fil

[ctx: ExprAddDialog|]
en: directory
sv: katalog

[ctx: ExprAddDialog|]
en: String Name
sv: Strängnamn

[ctx: ExprAddDialog|]
en: String Type
sv: Strängtyp

[ctx: ExprAddDialog|]
en: String Default
sv: Strängförval

[ctx: ExprAddDialog|]
en: String
sv: Sträng

[ctx: ExprBrowser|]
en: Save Expression
sv: Spara uttryck

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
sv: Kunde inte öppna filen %1 för skrivning

[ctx: ExprBrowser|]
en: Error
sv: Fel

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
sv: Kunde inte öppna filen %1 för skrivning. Är den skrivskyddad?

[ctx: CCurveScene|]
en: Delete Point
sv: Ta bort punkt

[ctx: ExprColorCurve|]
en: Selected Position:
sv: Vald position:

[ctx: ExprColorCurve|]
en: Selected Color:
sv: Vald färg:

[ctx: ExprColorCurve|]
en: None
sv: Ingen

[ctx: ExprColorCurve|]
en: Linear
sv: Linjär

[ctx: ExprColorCurve|]
en: Smooth
sv: Jämn

[ctx: ExprColorCurve|]
en: &Expand...
sv: &Expandera...

[ctx: ExprColorFrame|]
en: Delete Swatch
sv: Ta bort färgruta

[ctx: ExprColorFrame|]
en: Cancel
sv: Avbryt

[ctx: ExprColorSwatchWidget|]
en: &Add...
sv: &Lägg till...

[ctx: ExprCompletionModel|]
en: Local
sv: Lokal

[ctx: StringControl|]
en: Please choose a file
sv: Välj en fil

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

[ctx: CurveControl|]
en: Val:
sv: Värde:

[ctx: CCurveControl|]
en: Val:
sv: Värde:

[ctx: CurveScene|]
en: Delete Point
sv: Ta bort punkt

[ctx: ExprCurve|]
en: Selected Position:
sv: Vald position:

[ctx: ExprCurve|]
en: Selected Value:
sv: Valt värde:

[ctx: ExprCurve|]
en: None
sv: Inget

[ctx: ExprCurve|]
en: Linear
sv: Linjärt

[ctx: ExprCurve|]
en: Smooth
sv: Jämnt

[ctx: ExprCurve|]
en: &Expand...
sv: &Expandera...

[ctx: ExprEditor|]
en: Expression Editor
sv: Uttryckseditor

[ctx: ExprFileDialog|]
en: Open
sv: Öppna

[ctx: ExprFileDialog|]
en: Favorites
sv: Favoriter

[ctx: ExprTextEdit|]
en: Pop-up Help
sv: Hjälpruta
