Jitter expr

This document describes the Jitter expression language syntax. This is the language used for the jit.expr object, as well as the exprfill message to a jit.matrix objects. This expression will be evaluated once for each cell in the input, in order to generate an output matrix with the same matrix dimensions as the input.

You could make a jit.expr that passes through input unchanged.

jit.expr @expr in[0]

Or you could use an expression to add the first and second inputs together:

jit.expr @expr in[0] + in[1]

Or do something more sophisticated, like apply a vignette mask:

jit.expr @expr (1-hypot(snorm[0],snorm[1]))*in[0]*2.

Inputs

Reference the inputs to the expr object with in. Get the first input with in[0], the second with in[1], and so on. Use p to get a specific plane of the input, where in[0].p[0] accesses the first plane of the first input, in[0].p[1] gets the second plane of the first input, and so on.

To get the cell coordinates, use either cell, norm, or snorm. The index is used to select the dimension, so cell[0] is the cell coordinate in the x direction (first dimension), cell[1] is the cell coordinate in the y direction, and so on. You can also use dim to get the dimensions of the matrix in any direction.

Finally, it's also possible to access any named matrix by simply using the name of that matrix instead of in. With a matrix named my_matrix, use my_matrix to access the contents of that matrix at the current cell coordinates, or my_matrix.p[0] to access the first plane of that matrix.

Functions and Operators

Within a Jitter expression, Jitter operators can be applied as functions. For the most part, these are the same operators as are defined for the jit.op object. Some of these can be applied as infix operators, for example in[0] + in[1] for the + operator. Others are called as functions, with commas between arguments, like absdiff(in[0], in[1]).

Arithmetic

Trigonometric

Bitwise

Logical

Exponential/Logarithmic/Other

Matrix Operators

Many Jitter Matrix Operators can be used inside of a Jitter expression as well. These are the functional equivalent of Jitter objects like jit.clip, objects that perform a simple operation on their matrix inputs. There is no exhaustive list of these, but if there's a simple Jitter object that you'd like to use in an expression, chances are it will work. You could use the following expression to convolve two matrices.

jit.expr @expr "jit.convolve(in[0], in[1])"

If the Jitter matrix operator can be configured with attributes, those can be supplied as an attribute list following the other arguments to the matrix operator. The following would constrain the values in each plane to be between 0.2 and 0.8.

jit.expr @expr "jit.clip(in[0], @min 0.2 @max 0.8)"

Basis Function Generators

The basis function generators from the jit.bfg object can also be used inside of an expression. These work in much the same way as matrix operators.

jit.expr @expr "noise.gradient(norm[0]*2, norm[1]*2, @seed 313)"

Distance functions

Filter functions

Transfer functions

Noise functions

Fractal functions

Constants

There's also a handful of constants ready as well. An expression like in[0] * DEGTORAD would convert a matrix full of degrees to a matrix full of radians.