Using Parser Expressions

 
 
 

| Using Component Expressions | Using Mathematical Expressions

The Component Parser operator and the Pixel Parser operator parse expressions, and use the results to affect individual RGBA components or individual pixels respectively. This section lists valid expression types, arguments and variables, and gives examples of their use.

The Component Parser allows separate expressions to be applied to red, green, blue and alpha components.

The Pixel Parser process, in the Image Adjust effect category, has a single expression channel that allows an expression to be input in the form of pixel. This applies the given expression to each RGBA component equally; additionally, the Pixel Parser can take any valid expression in a single Component Parser channel.

Using Component Expressions

Syntax: value

where value can be:

Any floating point number (0 to1).

Any expression evaluating to a number.

An input component value (r, g, b, a, pixel).

Example: Solid green frame:

Component Parser

Red

0

 

Green

1

 

Blue

0

 

Alpha

0

Example: Solid red frame:

Component Parser

Red

1

 

Green

0

 

Blue

0

 

Alpha

0

Example: Solid blue frame:

Component Parser

Red

0

 

Green

0

 

Blue

1

 

Alpha

0

Example: Do nothing (output same as input):

Component Parser

Red

r

 

Green

g

 

Blue

b

 

Alpha

a

Pixel Parser

Pixel

pixel

Example: Swap Components:

Component Parser

Red

g

 

Green

r

 

Blue

b

 

Alpha

a

Example: Invert picture:

Component Parser

Red

1-r

 

Green

1-g

 

Blue

1-b

 

Alpha

1-a

Pixel Parser

Pixel

1-pixel

Example: Luma Extract:

Component Parser

Red

r+g+b

 

Green

r+g+b

 

Blue

r+g+b

 

Alpha

0

Pixel Parser

Pixel

r+g+b

Component Expressions at a Particular Location

Syntax: component(x,y)

where x = integer (0 -- picture width in pixels)

where y = integer (0 -- picture height in pixels)

If you are using the Pixel Probe to see pixels values at a particular location, view the image at Full Size.

Example: Do nothing (output same as input)

Component Parser

Red

r(x,y)

 

Green

g(x,y)

 

Blue

b(x,y)

 

Alpha

0

Pixel Parser

Pixel

pixel(x,y)

Example: Shift whole image 10 pixels to the right:

Component Parser

Red

r(x+10,y)

 

Green

g(x+10,y)

 

Blue

b(x+10,y)

 

Alpha

0

Pixel Parser

Pixel

pixel(x+10,y)

Example: Shift just the red component upwards:

Component Parser

Red

r(x,y-10)

 

Green

g(x,y)

 

Blue

b(x,y)

 

Alpha

0

Component Expressions using Another Input

Syntax: component[input](x,y)

input is an integer either 1, 2 or 3, corresponding to the three available inputs to the operator.

Example: Do nothing (output same as input):

Component Parser

Red

r[1](x,y)

 

Green

g[1](x,y)

 

Blue

b[1](x,y)

 

Alpha

0

Pixel Parser

Pixel

pixel[1](x,y)

Example: Use the red component of Input 2 in the output:

Component Parser

Red

r[2](x,y)

 

Green

g[1](x,y)

 

Blue

b[1](x,y)

 

Alpha

0

Using Variables with Component Expressions

Variables can be used in expressions. Select the Variables property page.

There are:

  • Three floating point numbers (0 to 30) a1, a2, and a3.

  • Three floating point numbers (0 to 1) b1, b2, and b3.

  • Three integer number (0,1,2,3,...,30) c1, c2, and c3.

  • The variables can be set at key frames in the animation.

Example: Fade black to white over 10 frames (Set b1=0.0 at frame 1, b1=1.0 at frame 10):

Component Parser

Red

b1

 

Green

b1

 

Blue

b1

 

Alpha

0

Pixel Parser

Pixel

b1

Example: Dissolve input2 to input1 over 10 frames (Set b1=0.0 at frame 1, b1=1.0 at frame 10):

Component Parser

Red

r[1](x,y)*b1 + r[2](x,y)*(1-b1)

 

Green

g[1](x,y)*b1 + g[2](x,y)*(1-b1)

 

Blue

b[1](x,y)*b1 + b[2](x,y)*(1-b1)

 

Alpha

0

Pixel Parser

Pixel

pixel[1](x,y)*b1 + pixel[2](x,y)* (1-b1)

Using Variables with Conditional Expressions

Syntax: if (expression) then (expression) else (expression)

You must include an "else'"

Example: Horizontal Wipe over 10 frames (Set c1=0 at frame 1, c1= 720 at frame 10):

Component Parser

Red

if (x>c1) then r[1](x,y) else r[2](x,y)

 

Green

if (x>c1) then g[1](x,y) else g[2](x,y)

 

Blue

if (x>c1) then b[1](x,y) else b[2](x,y)

 

Alpha

0

Pixel Parser

Pixel

if (x>c1) then pixel[1](x,y) else pixel[2](x,y)

Using Mathematical Expressions

You can use a number of mathematical expressions in the component and pixel parsers. These include:

  • Plus: (+)

  • Minus: (-)

  • Multiplication: (*)

  • Division: (/)

  • Modulus: (%)

  • Natural Logarithm: (log) - log (float)

  • Square Root: (sqrt) - sqrt(float)

  • Exponential: (exp) - exp(float)

  • Absolute function: (abs) - abs(-1) = 1

  • Random number: (rand) - rand(N) N is any float, returns a float between 0 and N

Example: Color Correction:

Component Parser

Red

r + 0.5*b - 0.25*g

 

Green

g/2

 

Blue

b

 

Alpha

0

Example: Modulus - red and green stripey picture:

Component Parser

Red

if (y%2 = 0) then 1 else 0

 

Green

if (y%2 = 0) then 1 else 0

 

Blue

0

 

Alpha

0

Example: Add a lot of Noise to an image:

Component Parser

Red

r + rand(1)

 

Green

g + rand(1)

 

Blue

b + rand(1)

 

Alpha

0

Pixel Parser

Pixel

pixel + rand(1)

Example: Add a small amount of noise to an image:

Component Parser

Red

r + rand(0.1)

 

Green

g + rand(0.1)

 

Blue

b + rand(0.1)

 

Alpha

0

Pixel Parser

Pixel

pixel + rand(0.1)

Example: Scatter pixels around:

Component Parser

Red

r(x+rand(5),y+rand(5))

 

Green

g(x+rand(5),y+rand(5))

 

Blue

b(x+rand(5),y+rand(5))

 

Alpha

0

Pixel Parser

Pixel

pixel(x+rand(5),y+rand(5))

Trigonometric Expressions

Available trigonometric functions include:

  • Sine function (sin) - sin(float)

  • Cosine function (cos) - cos(float)

  • Tangent function (tan) - tan(float)

Example: Wave distortion:

Component Parser

Red

r(x+20*sin(x/ 20),y+20*sin(y/20))

 

Green

g(x+20*sin(x/ 20),y+20*sin(y/20))

 

Blue

b(x+20*sin(x/ 20),y+20*sin(y/20))

 

Alpha

a(x+20*sin(x/ 20),y+20*sin(y/20))

Pixel Parser

Pixel

pixel(x+20*sin(x/ 20),y+20*sin(y/20))

Logical Expressions

Available logical functions include:

  • Equality: (=)

  • Not equal: (<>)

  • Greater than: (>)

  • Less than: (<)

  • Greater than or equal: (>=)

  • Less than or equal: (<=)

  • Logical and: (and)

  • Logical or: (or)

  • Logical xor: (xor)

  • Logical not: (not)

  • Minimum of two numbers: (min)

  • Maximum of two numbers: (max)

Example: Logical composite:

Component Parser

Red

r[1](x,y) and r[2](x,y)

 

Green

g[1](x,y) and g[2](x,y)

 

Blue

b[1](x,y) and b[2](x,y)

 

Alpha

a[1](x,y) and a[2](x,y)

Pixel Parser

Pixel

pixel[1](x,y) and pixel[2](x,y)

Filter Attributes

Syntax: component.attribute(x,y)

where x and y are the pixel values at which the filter is applied.

All filters are based on a 3*3 convolution.

  • Gradient filter: (grad)

  • Blur filter: (blur)

  • Min filter: (minimum)

  • Max filter: (maximum)

  • Median filter: (median)

Example: Simple Blur:

Component Parser

Red

r.blur(x,y)

 

Green

g.blur(x,y)

 

Blue

b.blur(x,y)

 

Alpha

0

Pixel Parser

Pixel

pixel.blur(x,y)

Example: Edge Sharpen:

Component Parser

Red

r+r.grad(x,y)

 

Green

g+g.grad(x,y)

 

Blue

b+b.grad(x,y)

 

Alpha

0

Pixel Parser

Pixel

pixel+pixel.grad(x,y)

Shape Attributes

Syntax: shape(x,y,size)

where x, y and size are values in pixels and shape can be circle or square.

Circle: (circle)

Square: (square)

Example: Picture in picture:

Component Parser

Red

if square(100,200,50) then r[1](x,y) else r[2](x,y)

 

Green

if square(100,200,50) then g[1](x,y) else g[2](x,y)

 

Blue

if square(100,200,50) then b[1](x,y) else b[2](x,y)

 

Alpha

0

Pixel Parser

Pixel

if square(100,200,50) then pixel[1](x,y) else pixel[2](x,y)

Example: Picture in circle:

Component Parser

Red

if circle(100,200,50) then r[1](x,y) else r[2](x,y)

 

Green

if circle(100,200,50) then g[1](x,y) else g[2](x,y)

 

Blue

if circle(100,200,50) then b[1](x,y) else b[2](x,y)

 

Alpha

0

Pixel Parser

Pixel

if circle(100,200,50) then pixel[1](x,y) else pixel[2](x,y)

Image Attributes

Syntax: component.attribute(argument(s))

The image attribute category modifies the current pixel's component value. Attributes include:

  • Quantization (quantize) - component.quantize(x)

  • Contrast enhancement (contrast) - component.contrast(x1,x2)

  • Gamma correction (gamma) - component.gamma(x)

  • Sawtooth function (sawtooth) - component.sawtooth(x)

  • Smooth Step function (smoothstep) - component.smoothstep(x1,x2)

  • Step function (step) - component.step(x1,x2,x3)

Example: Component Quantization to 4 levels:

Component Parser

Red

r.quantize(4)

 

Green

g.quantize(4)

 

Blue

b.quantize(4)

 

Alpha

0

Pixel Parser

Pixel

 

pixel.quantize(4)

As quantization takes place on each component separately, this gives 43 = 64 levels.

Example: Contrast:

Component Parser

Red

r.contrast(0.25,0.75)

 

Green

g.contrast(0.25,0.75)

 

Blue

b.contrast(0.25,0.75)

 

Alpha

0

Pixel Parser

Pixel

pixel.contrast(0.25,0.75)

Example: Gamma:

Component Parser

Red

r.gamma(0.7)

 

Green

g.gamma(0.7)

 

Blue

b.gamma(0.7)

 

Alpha

0

Pixel Parser

Pixel

pixel.gamma(0.7)

Example: Sawtooth:

Component Parser

Red

r.sawtooth(4)

 

Green

g.sawtooth(4)

 

Blue

b.sawtooth(4)

 

Alpha

0

Pixel Parser

Pixel

pixel.sawtooth(4)

Example: Smoothstep:

Component Parser

Red

r.smoothstep(0.25,0.75)

 

Green

g.smoothstep(0.25,0.75)

 

Blue

b.smoothstep(0.25,0.75)

 

Alpha

0

Pixel Parser

Pixel

pixel.smoothstep(0.25,0.75)

Example: Step:

Component Parser

Red

r.step(0.25,0.75,0.75)

 

Green

g.step(0.25,0.75,0.75)

 

Blue

b.step(0.25,0.75,0.75)

 

Alpha

0

Pixel Parser

Pixel

pixel.step(0.25,0.75,0.75)

Time

Variables can be accessed at any point in time.

Syntax: variable(frame number)

The variable time represents the current frame number.

Example:

Component Parser

Red

r*c1(6)

 

Green

g*c1(time-1)

 

Blue

b

 

Alpha

0