Field

Take the absolute value of every numeric element in field.

Take the arccosine of every numeric element in field.

Create a field of a given type as an output of the given operation.

Take the arcsine of every numeric element in field.

Compute atan2 of two identically shaped scalar fields.

Convolve a vector field with a vector-field filter frame.

Compute the backward divergence of a 2D vector field.

This is the adjoint operator of forwardGradient.

Compute the backward gradient of a 2D scalar or vector field.

Reduce a vector field to a shorter (by factor factor) vector field by taking the max() of the first factor input vector elements to form the first output vector element, and so forth.

Reduce a vector field to a shorter (by factor factor) vector field by taking the min() of the first factor input vector elements to form the first output vector element, and so forth.

Reduce a vector field to a shorter (by factor factor) vector field by summing the first factor input vector elements to form the first output vector element, and so forth.

Compute the central gradient of a scalar of vector field.

The central gradient at the point (x, y) is computed using the values at (x - 1, y), (x, y - 1), (x, y + 1), and (x + 1, y + 1)

Create a color field from either a scalar field (with an implicit assumption that the field represents a grayscale image) or a vector field (with the implicit assumption that the vector field represents the (red, green, blue) components of the color image.

Create a color field from three scalar fields.

Create a complex field from a real field.

Create a complex field from two scalar fields

Implicit conversion of a Complex to a CogComplex which allows for fields to be combined with floating point numbers in a simple way. This makes it possible to express commutative operations with a common syntax.

For example

Field + Complex

and

Complex + Field

are both legal and compilable with this implicit conversion.

Create a complex vector field by stacking complex scalar fields.

For example, this can be used to stack N complex fields to a single complex vector field where each vector is of length N.

Create a complex vector field by stacking complex scalar fields.

For example, this can be used to stack N complex fields to a single complex vector field where each vector is of length N.

Implicit conversion of a ComplexVector to a 0D constant ComplexVectorField which allows for fields to be combined with ComplexVectors in a simple way. This makes it possible to express commutative operations with a common syntax.

For example

Field + ComplexVector

and

ComplexVector + Field

are both legal and compilable with this implicit conversion.

Take the complex conjugate of each element in a complex field

Convolve a scalar/vector/matrix field with a filter.

Convolve a vector field with a vector-field with "filter adjoint" plane mixing.

Convolve a scalar/vector/matrix field with a row filter and a column filter (separable convolution).

Create a copy of a field. This should not be used normally in a user model, but exists as a debugging tool to help identify Cog core issues. The Cog compiler uses this method internally between pipeline stages that have no other computation between them.

Take the cosine of every numeric element in field.

Take the hyperbolic cosine of every numeric element in field.

Cross-correlate a scalar/vector/matrix field with a filter.

Cross-correlate a vector field with a vector-field with "filter adjoint" plane mixing.

Cross-correlate a scalar/vector/matrix field with a row filter and a column filter (separable convolution).

Multiply a 2D matrix field, field, by a 2D scalar field, f2, to produce a 2D scalar field.

The scalar field f2 must have the same shape as the matrices in field. This operator is basically pretending that the f2 scalar field is really a matrix and simply dotting that matrix with every matrix in the matrix field field, producing a scalar in the corresponding position of the result scalar field.

Takes the DCT (discrete cosine transform) of a 2D field, producing a field with the same shape as the input.

The following sequence will return the original input, within the bounds of computational error:

val field
val transformed: Field =
val restored = transformed.dctInverse
// restored is approximately equal to field

For a somewhat faster version, see dctTransposed.

The DCT has several requirements:

The number of rows and columns must each be a power of 2.

Rows and columns are restricted to the range [256, 2048]

Takes the inverse DCT (discrete cosine transform) of a 2D field, producing a field with the same shape as the input.

The following sequence will return the original input, within the bounds of computational error:

val field
val transformed = field.dct
val restored = transformed.dctInverse
// restored is approximately equal to field

For a somewhat faster version, see dctInverseTransposed.

The DCT has several requirements:

The number of rows and columns must each be a power of 2.

Rows and columns are restricted to the range [256, 2048]

Takes the inverse DCT (discrete cosine transform) of a 2D field, producing a field with the same shape as the input.

The following sequence will return the original input, within the bounds of computational error:

val field
val transformed = field.dctTransposed
val restored = transformed.dctInverseTransposed
// restored is approximately equal to field

This is a somewhat faster version of dctInverse where the transpose is not important to (or can be compensated within) an application.

The DCT has several requirements:

The number of rows and columns must each be a power of 2.

Rows and columns are restricted to the range [256, 2048]

Takes the DCT (discrete cosine transform) of a 2D field and transposes it, producing a field with the same shape as the input transposed.

The following sequence will return the original input, within the bounds of computational error:

val field
val transformed = field.dctTransposed
val restored = transformed.dctInverseTransposed
// restored is approximately equal to field

This is a somewhat faster version of dct where the transpose is not important to (or can be compensated within) an application.

The DCT has several requirements:

The number of rows and columns must each be a power of 2.

Rows and columns are restricted to the range [256, 2048]

Takes the inner product of two identically shaped tensor fields to create a scalar field.

The tensors in both fields must have the same shape. Dotting two tensors involves multiplying corresponding elements in the two tensors and summing the products.

Downsample a field by taking every nth element.

Example: for input field {1,2,3,4}

input.downsample(2) yields {1,3}

input.downsample(2,1) yields {2,4}

Further examples of downsampling on a 2-dimensional input:

Apply the exponential function to every numeric element in field. This works for complex and real fields.

Expand an N-dimensional field by padding it with values per the border policy, maintaining the origin. The supported border policies are BorderZero, BorderClamp and BorderCyclic.

See expand(borderPolicy, shape) for a description of the border policies.

Expand an N-dimensional field by padding it with values per the border policy, maintaining the origin. The supported border policies are BorderZero, BorderClamp and BorderCyclic.

With the BorderZero policy, the border values are all 0.

Border Zero Example. A 3 x 4 input field:

1  2  3  4
5 -1 -1  6
7  8  9  0

If we expand this to 7 x 8, we fill the new elements with zeroes:

1  2  3  4  0  0  0  0
5 -1 -1  6  0  0  0  0
7  8  9  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0

With the BorderClamp policy, the border is extended outwards into the expanded output field, wrapping around as though the output field were a torus. This is useful when doing convolution with the FFT and one wishes to minimize border effects by "border clamping".

BorderClamp Example. A 3 x 4 input field:

1  2  3  4
5 -1 -1  6
7  8  9  0

If we expand this to 7 x 8, we extend the borders, wrapping around as though the output field were a torus:

1  2  3  4  4  4  1  1
5 -1 -1  6  6  6  5  5
7  8  9  0  0  0  7  7
7  8  9  0  0  0  0  0
7  8  9  0  0  0  0  0
1  2  3  4  0  0  0  0
1  2  3  4  0  0  0  0

With the BorderCyclic policy, the border values emulate a cyclic "wrap-around" in the original field, as though the input field were a torus. This is useful when doing cyclic convolution with the FFT and one wishes expand the field to make it a power of 2 (necessary for the FFT) while still preserving cyclic convolution

BorderCyclic Example. A 3 x 4 input field:

1  2  3  4
5 -1 -1  6
7  8  9  0

If we expand this to 7 x 8, we extend the borders, wrapping around as though the input field were a torus:

1  2  3  4  1  2  3  4
5 -1 -1  6  5 -1 -1  6
7  8  9  0  7  8  9  0
1  2  3  4  1  2  3  4
5 -1 -1  6  5 -1 -1  6
5 -1 -1  6  5 -1 -1  6
7  8  9  0  7  8  9  0

Compute the FFT of a complex field.

Compute the FFT of the columns only in a 2D complex field.

Compute the inverse FFT of a complex field (includes scaling).

Compute the inverseFFT of the columns only in a 2D complex field.

Compute the inverse FFT of a complex field represented as separate real and imaginary fields (includes scaling).

Compute the inverse FFT of the rows only in a 2D complex field.

Compute the FFT of a real field.

Compute the FFT of a complex field that is input as two separate real and imaginary fields.

Compute the FFT of the rows only in a 2D complex field.

Implicit conversion of an array of Fields to an array of ScalarFields.

Implicit conversion of an array of Fields to an array of ScalarFields.

Implicit conversion of an array of Fields to an array of ScalarFields.

Reduce a scalar field to a 0D scalar containing a single element which is the maximum element in the input field.

Find the median value in a scalar field.

Reduce a scalar field to a 0D scalar containing a single element which is the minimum element in the input field.

Reduce a scalar field to a 0D scalar containing the sum of all the elements in the input field.

Implicit conversion of a Field to a ColorField. Field is abstract, so this method will perform the appropriate type coercion if the field is already a ColorField but stored in a Field variable. This method also supports converting a ScalarField or VectorField to a ColorField.

Implicit conversion of a Field to a ComplexField. Field is abstract, so this method will perform the appropriate type coercion if the field is already a ComplexField but stored in a Field variable. This method also supports converting a ScalarField to a ComplexField.

Implicit conversion of a Field to a ComplexField. Field is abstract, so this method will perform the appropriate type coercion if the field is already a ComplexField but stored in a Field variable. This method also supports converting a ScalarField to a ComplexField.

Implicit conversion of a Field to a MatrixField. Since Field is abstract, the only possible conversion is if the field is already a MatrixField but is stored in a Field variable. This merely does the necessary type coercion.

Implicit conversion of a Field to a ScalarField. Since Field is abstract, the only possible conversion is if the field is already a ScalarField but is stored in a Field variable. This merely does the necessary type coercion.

Implicit conversion of a Field to a VectorField. Field is abstract, so this method will perform the appropriate type coercion if the field is already a VectorField but stored in a Field variable. This method also supports converting a ColorField to a VectorField.

Flip a field along every dimension.

Example. This 2D scalar field:

1  2  3
4  5  6
7  8  9

looks like this when flipped:

9  8  7
6  5  4
3  2  1

Implicit conversion of a Float to a CogFloat which allows for fields to be combined with floating point numbers in a simple way. This makes it possible to express commutative operations with a common syntax.

For example

Field + Float

and

Float + Field

are both legal and compilable with this implicit conversion.

Map each numeric element of the input field to the largest integer which is less than or equal to that element.

Compute the forward gradient of a 2D scalar or vector field.

This is the adjoint operator of backwardDivergence.

Extract the imaginary part of a complex field as a scalar field.

Declare an internal error described by message.

Apply the natural logarithm to every numeric element in field.

Take the magnitude of each element in a complex field

Create a matrix field from a 2D array of scalar fields.

For example, this can be used to stack N x K scalar fields to a single matrix field. Each matrix in the result will be N x K.

Create a matrix field from a 2D array of scalar fields.

For example, this can be used to stack N x K scalar fields to a single matrix field. Each matrix in the result will be N x K.

Create a matrix field from vector fields by "stacking" the vector fields.

For example, this can be used to stack N vector fields to a single matrix field. If the length of the vectors in the vector fields is K, then each matrix in the result will be N x K.

Create a matrix field from vector fields by "stacking" the vector fields.

For example, this can be used to stack N vector fields to a single matrix field. If the length of the vectors in the vector fields is K, then each matrix in the result will be N x K.

Convert a matrix field to a vector field by stripping out one row from each matrix in the field and making it a vector.

Select the maximum value of corresponding elements in two scalar fields.

For every element, x, in field, compute max(x, that) where 1.0f represents a "true" result and 0.0f represents a "false" result. The resulting field has the same field shape and tensor shape as filed.

Select the minimum value of corresponding elements in two scalar fields.

For every element, x, in field, compute min(x, that) where 1.0f represents a "true" result and 0.0f represents a "false" result. The resulting field has the same field shape and tensor shape as field.

Normalize a scalar field using the L1 norm.

Normalize a scalar field using the L2 norm.

Take the phase of each element in a complex field.

This is also commonly called arg. This is a number in the range (-Pi, Pi]

Create a complex field from polar coordinates.

Raise each number in field to the power that. The resulting field has the same field shape and tensor shape as field.

Raise each number in field to the power that. The resulting field has the same field shape and tensor shape as field.

User mechanism for marking multiple fields as "probed"

If a field is visible to reflection, it will be automatically named.

User mechanism for marking a field as "probed," optionally supplying a name for the field.

If a field is visible to reflection, it will be automatically named. In that case supplying a userName is unnecessary and not recommended.

Cross-correlate a vector field with a vector-field filter frame.

Compute a random field based on this input field using cellular automaton based RNG. The output ranges from [0 to 1] (inclusive) and is uniformly distributed.

Extract the real part of a complex field as a scalar field.

Perform 1/x operation on every numeric element of a field.

Somewhat dangerous to use if any element in the field could be zero, since the resulting element would be NaN which does not throw an exception.

Reduce a vector field to a scalar field by mapping each vector to the maximum of its components.

Reduce a vector field to a scalar field by mapping each vector to the minimum of its components.

Reduce a vector field to a scalar field by mapping each vector to the sum of its components.

Replicate a scalar field as matrices in a matrix field (each matrix in the matrix field is identical to the input scalar field).

Change the shape of a scalar field without changing the number of elements in it.

This depends on the row-major ordering we use for elements in a field. Elements in any scalar field, regardless of dimension, have that linear ordering. Reshaping preserves that ordering; it really does nothing more than change the sizes of each dimension of the field.

Change the shape of a scalar field without changing the number of elements in it.

This depends on the row-major ordering we use for elements in a field. Elements in any scalar field, regardless of dimension, have that linear ordering. Reshaping preserves that ordering; it really does nothing more than change the sizes of each dimension of the field.

Multiply a matrix field, field, by a scalar field, f2, to produce a scalar field.

The matrix field and scalar field operands must have identical field shapes. Each scalar element of the scalar field is multiplied by the corresponding element in the matrix field. These products are then summed to produce the scalar field result (which has the same shape as the matrices in the matrix field).

Dynamically select a scalar field from an array of scalar fields.

Example:

val fields: Array[ScalarFieldExpr] = ...
val index: ScalarFieldExpr
val selected: ScalarFieldExpr = select(fields, index)

Shift a 2D scalar field in both dimensions, pulling in zeroes where necessary. Negative shift amounts result in shifts up and to the left, while positive shift amounts result in shifts down and to the right.

Shift a 1D scalar field left (negative colShift) or right (positive colShift), pulling in zeroes where necessary.

Shift a 2D scalar field in both dimensions, pulling in values from the opposite side where necessary. Negative shift amounts result in shifts up and to the left, while positive shift amounts result in shifts down and to the right.

Shift a 1D scalar field left (negative colShift) or right (positive colShift), pulling in values from the opposite side where necessary.

Apply the signum operator to every numeric element in field.

Signum(x) is defined to be:

1 if x > 0

0 if x: Field =

-1 if x < 0

Apply the sine operator to every numeric element in field.

Apply the hyperbolic sine operator to every numeric element in field.

Solve Ax - b

This actually solves the equation for each matrix / vector pair in the fields field and b, producing a vector field representing x. The vectors in b must be length 2 and the matrices in field must be 2 x 2. Solves the equations using the pseudo inverse

Apply the square operator to every numeric element in field.

Apply the square root operator to every numeric element in field.

Stack tensor fields to create a higher-order tensor field.

For example, this can be used to stack N scalar fields to a single vector field where each vector is of length N.

Stack tensor fields to create a higher-order tensor field.

For example, this can be used to stack N scalar fields to a single vector field where each vector is of length N.

Extracts a window from a 1D or 2D scalar, vector or matrix field, guided by a 0D vector field called "the guide." The guide specifies the upper-left-most (or left-most for 1D fields) point of the window, and shape specifies the size of the window.

A guiding vector with value (v1, v2) means a given point (row, col) extracts the element at location (row + v1, col + v2) as its output. If that location falls outside of the field, the BorderPolicy attached to the the opcode determines how the missing value is computed. If either of the guide vector components v1 and v2 is non-integral, bilinear interpolation is used to to determine the approximate value.

Extract all subfields from a 2D scalar field into a 2-D vector field.

Supersample a scalar field by 2X in each dimension, replicating pixels to fill in the gaps.

Apply the tangent operator to every numeric element in field.

Apply the hyperbolic tangent operator to every numeric element in field.

Explicit conversion of a Field to a ColorField. Field is abstract, so this method will perform the appropriate type coercion if the field is already a ColorField but stored in a Field variable. This method also supports converting a ScalarField or VectorField to a ColorField.

Explicit conversion of a Field to a ComplexField. Field is abstract, so this method will perform the appropriate type coercion if the field is already a ComplexField but stored in a Field variable. This method also supports converting a ScalarField to a ComplexField.

Explicit conversion of a Field to a ComplexVectorField. Field is abstract, so this method will perform the appropriate type coercion if the field is already a ComplexVectorField but stored in a Field variable. This method also supports converting a VectorField to a ComplexVectorField.

Another explicit conversion, this time working on both ScalarFields and VectorFields. The return type is Field though, the common base class of both ComplexFields and ComplexScalarFields.

Explicit conversion of a Field to a MatrixField. Since Field is abstract, the only possible conversion is if the field is already a MatrixField but is stored in a Field variable. This merely does the necessary type coercion.

Explicit conversion of a Field to a ScalarField. Since Field is abstract, the only possible conversion is if the field is already a ScalarField but is stored in a Field variable. This merely does the necessary type coercion.

Explicit conversion of a Field to a VectorField. Field is abstract, so this method will perform the appropriate type coercion if the field is already a VectorField but stored in a Field variable. This method also supports converting a ColorField to a VectorField.

(1) Multiply a matrix field by a matrix field to produce a matrix field; or (2) multiply a matrix field by a vector field to produce a vector field.

For case (1), corresponding matrices in field and f2 are multiplied using standard matrix multiplication to produce the corresponding matrix in the resulting matrix field.

For case (2), corresponding matrix/vector pari in field and f2 are multiplied using standard matrix/vector multiplication to produce the corresponding vector (a linear transformation of the input vector) in the resulting vector field.

Transpose a 2D tensor field or color field.

Transpose all the matrices in a matrix field to produce a new matrix field.

Transpose each vector in a vector field to a single row matrix, thus creating a matrix field from a vector field

"Trim" a field to a smaller size by clipping off indices (maintaining the origin).

Upsample with zeroes inserted between field points, increasing the size of the input in all dimensions.

Example: for input field {1,2,3}

input.upsample(2) yields {1,0,2,0,3,0}

input.upsample(2,1) yields {0,1,0,2,0,3}

Convert a vector field to a scalar field by extracting one element of each vector.

Convert a vector field to a smaller vector field by extracting a dynamically indexed a range of elements

Convert a color field to a vector field, with each vector of length 3 representing, in order, the red, green and blue components of the corresponding pixel.

Create a vector field from scalar fields by "stacking" the scalar fields.

For example, this can be used to stack N scalar fields to a single vector field where each vector is of length N.

Create a vector field from scalar fields by "stacking" the scalar fields.

For example, this can be used to stack N scalar fields to a single vector field where each vector is of length N.

Create a vector field from scalar fields by "stacking" the scalar fields.

For example, this can be used to stack N scalar fields to a single vector field where each vector is of length N.

Implicit conversion of a Vector to a 0D constant VectorField which allows for fields to be combined with vectors in a simple way. This makes it possible to express commutative operations with a common syntax.

For example

Field + Vector

and

Vector + Field

are both legal and compilable with this implicit conversion.

Warps a 2D scalar, vector or matrix field, guided by a vector field called "the guide." The guide must either be zero-dimensional, in which case the input field is translated uniformly, or must be a 2D vector field with exactly the same shape as the input.

The guiding vector with value (v1, v2) at a given point (row, col) extracts the element at location (row - v1, col - v2) as its output. If that location falls outside of the field, the BorderPolicy attached to the the opcode determines how the missing value is computed. If either of the guide vector components v1 and v2 is non-integral, bilinear interpolation is used to to determine the approximate value.

Compute the "winner" of a scalar field by mapping its largest element to 1.0f and the other elements to 0.0f

This is not well-defined when multiple elements share the maximum value, so beware.

Perform bilateral filtering using spatialFilter for spatial filtering (typically this will be a truncated Gaussian) and a Gaussian with width rangeSigma for range filtering.

WARNING: This is an old algorithm that is not very efficient. Consider a newer algorithm such as domain transform filtering.

Given a matrix field, compute the condition number for each matrix in that field. This is currently limited to fields containing 2 x 2 matrices.

Compute the determinant of every matrix in a matrix field.

Perform a "domain filter" on the columns of a color field as a step in edge-aware normalized convolution. This "correlates" an adaptive box filter with each pixel in the columns of the color field, guided by domainTransform.

This operation works only on color fields and is an optimization. The following code sequences, A and B, are functionally identical:

// Prepare for filtering
val rowTransform: Field =
val colTransform: Field =

// Sequence A (slower)
var smooth = colorImage
smooth = smooth.domainFilterRows(rowTransform, ...)
smooth = smooth.transpose.domainFilterRows(colTransform, ...).transpose

// Sequence B, using this operation (faster, no transposes)
var smooth = colorImage
smooth = smooth.domainFilterRows(rowTransform, ...)
smooth = smooth.domainFilterColumns(colTransform, ...)

For details, see the paper "Domain transform for edge-aware image and video processing," Gastal and Oliveira, 2011. Normally this is not useful for end-users, but you're welcome to try it if you would like to write your own edge-aware filters.

Perform a "domain filter" on the rows of a tensor or color field as a step in edge-aware normalized convolution. This "correlates" an adaptive box filter with each pixel in the rows of the color field, guided by domainTransform.

For details, see the paper "Domain transform for edge-aware image and video processing," Gastal and Oliveira, 2011. Normally this is not useful for end-users, but you're welcome to try it if you would like to write your own edge-aware filters.

Perform a "domain transform" on the rows of a color field or tensor field as a step in edge-aware normalized convolution.

For details, see the paper "Domain transform for edge-aware image and video processing," Gastal and Oliveira, 2011. Normally this is not useful for end-users, but you're welcome to try it if you would like to write your own edge-aware filters.

Invert all matrices in a matrix field using Gauss-Jordan elimination.

This is numerically stable only for small matrices, and let's not even get in to singular matrices. Be careful.

Find the local maximum of a neighborhood centered on each pixel in a 2D scalar field.

For each point in the input 2D scalar field, this searches a small neighborhood of that point and extracts the largest scalar found.

The neighborhood is defined by a matrix which is centered on the point. A non-zero value in the kernel means the corresponding point in the field is part of the neighborhood, while a zero implies the point should be ignored.

For example, the kernel

1 1 0
1 1 0
0 0 0

specifies the 2 x 2 neighborhood for the maximum value search.

For a scalar field, find the relative position of the local maximum of a neighborhood centered on the current pixel. This is returned as vector field, with each vector's tail at the current pixel and the head pointing at the pixel containing the neighborhood's local maximum.

The neighborhood is defined by a matrix which is centered on the point. A non-zero value in the kernel means the corresponding point in the field is part of the neighborhood, while a zero implies the point should be ignored.

For example, the kernel

1 1 0
1 1 0
0 0 0

specifies the 2 x 2 neighborhood for the maximum value search.

Find the local minimum of a neighborhood centered on each pixel in a 2D scalar field.

For each point in the input 2D scalar field, this searches a small neighborhood of that point and extracts the smallest scalar found.

The neighborhood is defined by a matrix which is centered on the point. A non-zero value in the kernel means the corresponding point in the field is part of the neighborhood, while a zero implies the point should be ignored.

For example, the kernel

1 1 0
1 1 0
0 0 0

specifies the 2 x 2 neighborhood for the minimum value search.

For a scalar field, find the relative position of the local minimum of a neighborhood centered on the current pixel. This is returned as vector field, with each vector's tail at the current pixel and the head pointing at the pixel containing the neighborhood's local manimum.

The neighborhood is defined by a matrix which is centered on the point. A non-zero value in the kernel means the corresponding point in the field is part of the neighborhood, while a zero implies the point should be ignored.

For example, the kernel

1 1 0
1 1 0
0 0 0

specifies the 2 x 2 neighborhood for the minimum value search.

Find the location/position of the maximum element in a scalar field.

Filter a 2D input scalar field with a 3 x 3 median filter.

Forces locally non-maximum pixels to zero for both scalar fields and vector fields.

Locality is defined to be the 8 nearest neighbors to a given pixel. If a pixel is greater than or equal to any of those neighbors, its value is left intact on the output, otherwise it's set to zero. Note that border pixels have only 5 nearest neighbors and corner pixels have only 3 nearest neighbors, so those are the only ones checked.

Vector fields are treated as though they were an array of scalar fields, so non-maximum suppression is executed independently on each.

Forces locally non-maximum pixels to zero for calar fields, but only when comparing the pixels on either side of a given pixel, using orientation to define where to look for the two pixels for comparison.