VolumeInfo

A volume info contains the complete indexing information for a volume, but no data array.

Constructors

Constructor	Description
`new(origin, size, delta, first)` Signature: (origin:int64 * size:V3l * delta:V3l * first:V3l) -> unit	Construct a VolumeInfo given a complete specification.
`new(origin, size, delta)` Signature: (origin:int64 * size:V3l * delta:V3l) -> unit	Construct a VolumeInfo given a complete specification.
`new(size)` Signature: size:V3l -> unit
`new(size, delta)` Signature: (size:V3l * delta:V3l) -> unit
`new(info)` Signature: info:VolumeInfo -> unit
`new(size)` Signature: size:V3i -> unit	Construct matrix info of specified size.
`new(sizeX, sizeY, sizeZ)` Signature: (sizeX:int64 * sizeY:int64 * sizeZ:int64) -> unit	Construct matrix info of specified size.
`new(sizeX, sizeY, sizeZ)` Signature: (sizeX:int * sizeY:int * sizeZ:int) -> unit	Construct matrix info of specified size.

Instance members

Instance member	Description
`AsMatrixXxYZ()` Signature: unit -> MatrixInfo	If the planes of the volume are stored consecutively without gaps, they can be merged, and the volume can be viewed as a matrix. This methods returns a Matrix with zero as first coordinates.
`AsMatrixXYxZ()` Signature: unit -> MatrixInfo	If the lines of the volume are stored consecutively without gaps, they can be merged, and the volume can be viewed as a matrix. This methods returns a Matrix with zero as first coordinates.
`AsVector()` Signature: unit -> VectorInfo	If the lines and planes of the volume are stored consecutively without gaps, the whole volume can be viewed as a single vector. This methods returns a Vector with zero as first coordinates.
`CheckMatchingSize(t1)` Signature: t1:VolumeInfo -> unit
`CheckMatchingSize(t1, t2)` Signature: (t1:VolumeInfo * t2:VolumeInfo) -> unit
`CheckMatchingSize(t1, t2, t3)` Signature: (t1:VolumeInfo * t2:VolumeInfo * t3:VolumeInfo) -> unit
`Count` Signature: int64	Total number of element in the volume.
`D()` Signature: unit -> unit	Delta
`DeltaArray()` Signature: unit -> unit Modifiers: abstract	Get or set the deltas of the tensor in each dimension as an array of longs.
`DSX` Signature: int64	Cummulative delta for all elements up to this dimension.
`DSY` Signature: int64	Cummulative delta for all elements up to this dimension.
`DSZ` Signature: int64	Cummulative delta for all elements up to this dimension.
`Dv(dx, dy, dz)` Signature: (dx:int64 * dy:int64 * dz:int64) -> int64
`DX()` Signature: unit -> unit	Delta.X
`DY()` Signature: unit -> unit	Delta.Y
`DZ()` Signature: unit -> unit	Delta.Z
`E` Signature: V3l	End (one step beyond the last element in all dimensions).
`End` Signature: V3l	End (one step beyond the last element in all dimensions).
`EX` Signature: int64	End in dimension X (one step beyond the last element).
`EY` Signature: int64	End in dimension Y (one step beyond the last element).
`EZ` Signature: int64	End in dimension Z (one step beyond the last element).
`F()` Signature: unit -> unit	First
`FirstArray()` Signature: unit -> unit Modifiers: abstract	Get or set the first coords of the tensor in each dimension as an array of longs.
`FirstIndex` Signature: int64	Return the index of the first element in the underlying data array.
`ForeachCoord(v_action)` Signature: v_action:Action<V3l> -> unit
`ForeachIndex(i_action)` Signature: i_action:Action<int64> -> unit Modifiers: abstract
`ForeachIndex(x_y_z_i_action)` Signature: x_y_z_i_action:Action<int64,int64,int64,int64> -> unit
`ForeachIndex(t1, i_i1_act)` Signature: (t1:VolumeInfo * i_i1_act:Action<int64,int64>) -> unit
`ForeachX(x_elementAct)` Signature: x_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachXIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachXIndex(x_i_elementAct)` Signature: x_i_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachXIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachXIndex(t1, x_i_i1_elementAct)` Signature: (t1:VolumeInfo * x_i_i1_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachXY(x_y_elementAct)` Signature: x_y_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXY(x_y_elementAct, x_postLineAct)` Signature: (x_y_elementAct:Action<int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXY(x_preLineAct, x_y_elementAct)` Signature: (x_preLineAct:Action<int64> * x_y_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXY(...)` Signature: (x_preLineAct:Action<int64> * x_y_elementAct:Action<int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(preLineAct, i_elementAct)` Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(x_y_i_elementAct)` Signature: x_y_i_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (x_y_i_elementAct:Action<int64,int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (x_preLineAct:Action<int64> * x_y_i_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (x_preLineAct:Action<int64> * x_y_i_elementAct:Action<int64,int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(t1, x_y_i_i1_elementAct)` Signature: (t1:VolumeInfo * x_y_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (t1:VolumeInfo * x_y_i_i1_elementAct:Action<int64,int64,int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (t1:VolumeInfo * x_preLineAct:Action<int64> * x_y_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (t1:VolumeInfo * x_preLineAct:Action<int64> * x_y_i_i1_elementAct:Action<int64,int64,int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXYZ(x_y_z_elementAct)` Signature: x_y_z_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZ(...)` Signature: (x_y_z_elementAct:Action<int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZ(...)` Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZ(...)` Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_elementAct:Action<int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(x_y_z_i_elementAct)` Signature: x_y_z_i_elementAct:Action<int64,int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (x_y_z_i_elementAct:Action<int64,int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_i_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_i_elementAct:Action<int64,int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:VolumeInfo * x_y_z_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:VolumeInfo * x_y_z_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:VolumeInfo * x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:VolumeInfo * x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZ(x_z_elementAct)` Signature: x_z_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZ(x_z_elementAct, x_postLineAct)` Signature: (x_z_elementAct:Action<int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZ(x_preLineAct, x_z_elementAct)` Signature: (x_preLineAct:Action<int64> * x_z_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZ(...)` Signature: (x_preLineAct:Action<int64> * x_z_elementAct:Action<int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(preLineAct, i_elementAct)` Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(x_z_i_elementAct)` Signature: x_z_i_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (x_z_i_elementAct:Action<int64,int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (x_preLineAct:Action<int64> * x_z_i_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (x_preLineAct:Action<int64> * x_z_i_elementAct:Action<int64,int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(t1, x_z_i_i1_elementAct)` Signature: (t1:VolumeInfo * x_z_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (t1:VolumeInfo * x_z_i_i1_elementAct:Action<int64,int64,int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (t1:VolumeInfo * x_preLineAct:Action<int64> * x_z_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (t1:VolumeInfo * x_preLineAct:Action<int64> * x_z_i_i1_elementAct:Action<int64,int64,int64,int64> * x_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachXZY(x_z_y_elementAct)` Signature: x_z_y_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZY(...)` Signature: (x_z_y_elementAct:Action<int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZY(...)` Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZY(...)` Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_elementAct:Action<int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(x_z_y_i_elementAct)` Signature: x_z_y_i_elementAct:Action<int64,int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (x_z_y_i_elementAct:Action<int64,int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_i_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_i_elementAct:Action<int64,int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:VolumeInfo * x_z_y_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:VolumeInfo * x_z_y_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:VolumeInfo * x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:VolumeInfo * x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachY(y_elementAct)` Signature: y_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachYIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachYIndex(y_i_elementAct)` Signature: y_i_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachYIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachYIndex(t1, y_i_i1_elementAct)` Signature: (t1:VolumeInfo * y_i_i1_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachYX(y_x_elementAct)` Signature: y_x_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYX(y_x_elementAct, y_postLineAct)` Signature: (y_x_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYX(y_preLineAct, y_x_elementAct)` Signature: (y_preLineAct:Action<int64> * y_x_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYX(...)` Signature: (y_preLineAct:Action<int64> * y_x_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(preLineAct, i_elementAct)` Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(y_x_i_elementAct)` Signature: y_x_i_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (y_x_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (y_preLineAct:Action<int64> * y_x_i_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (y_preLineAct:Action<int64> * y_x_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(t1, y_x_i_i1_elementAct)` Signature: (t1:VolumeInfo * y_x_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (t1:VolumeInfo * y_x_i_i1_elementAct:Action<int64,int64,int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (t1:VolumeInfo * y_preLineAct:Action<int64> * y_x_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (t1:VolumeInfo * y_preLineAct:Action<int64> * y_x_i_i1_elementAct:Action<int64,int64,int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYXZ(y_x_z_elementAct)` Signature: y_x_z_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZ(...)` Signature: (y_x_z_elementAct:Action<int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZ(...)` Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZ(...)` Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_elementAct:Action<int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(y_x_z_i_elementAct)` Signature: y_x_z_i_elementAct:Action<int64,int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (y_x_z_i_elementAct:Action<int64,int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_i_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_i_elementAct:Action<int64,int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:VolumeInfo * y_x_z_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:VolumeInfo * y_x_z_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:VolumeInfo * y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:VolumeInfo * y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZ(y_z_elementAct)` Signature: y_z_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZ(y_z_elementAct, y_postLineAct)` Signature: (y_z_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZ(y_preLineAct, y_z_elementAct)` Signature: (y_preLineAct:Action<int64> * y_z_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZ(...)` Signature: (y_preLineAct:Action<int64> * y_z_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(preLineAct, i_elementAct)` Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(y_z_i_elementAct)` Signature: y_z_i_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (y_z_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (y_preLineAct:Action<int64> * y_z_i_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (y_preLineAct:Action<int64> * y_z_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(t1, y_z_i_i1_elementAct)` Signature: (t1:VolumeInfo * y_z_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (t1:VolumeInfo * y_z_i_i1_elementAct:Action<int64,int64,int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (t1:VolumeInfo * y_preLineAct:Action<int64> * y_z_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (t1:VolumeInfo * y_preLineAct:Action<int64> * y_z_i_i1_elementAct:Action<int64,int64,int64,int64> * y_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachYZX(y_z_x_elementAct)` Signature: y_z_x_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZX(...)` Signature: (y_z_x_elementAct:Action<int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZX(...)` Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZX(...)` Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_elementAct:Action<int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(y_z_x_i_elementAct)` Signature: y_z_x_i_elementAct:Action<int64,int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (y_z_x_i_elementAct:Action<int64,int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_i_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_i_elementAct:Action<int64,int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:VolumeInfo * y_z_x_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:VolumeInfo * y_z_x_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:VolumeInfo * y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:VolumeInfo * y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZ(z_elementAct)` Signature: z_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachZIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachZIndex(z_i_elementAct)` Signature: z_i_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachZIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachZIndex(t1, z_i_i1_elementAct)` Signature: (t1:VolumeInfo * z_i_i1_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.
`ForeachZX(z_x_elementAct)` Signature: z_x_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZX(z_x_elementAct, z_postLineAct)` Signature: (z_x_elementAct:Action<int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZX(z_preLineAct, z_x_elementAct)` Signature: (z_preLineAct:Action<int64> * z_x_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZX(...)` Signature: (z_preLineAct:Action<int64> * z_x_elementAct:Action<int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(preLineAct, i_elementAct)` Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(z_x_i_elementAct)` Signature: z_x_i_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (z_x_i_elementAct:Action<int64,int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (z_preLineAct:Action<int64> * z_x_i_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (z_preLineAct:Action<int64> * z_x_i_elementAct:Action<int64,int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(t1, z_x_i_i1_elementAct)` Signature: (t1:VolumeInfo * z_x_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (t1:VolumeInfo * z_x_i_i1_elementAct:Action<int64,int64,int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (t1:VolumeInfo * z_preLineAct:Action<int64> * z_x_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (t1:VolumeInfo * z_preLineAct:Action<int64> * z_x_i_i1_elementAct:Action<int64,int64,int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZXY(z_x_y_elementAct)` Signature: z_x_y_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXY(...)` Signature: (z_x_y_elementAct:Action<int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXY(...)` Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXY(...)` Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_elementAct:Action<int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(z_x_y_i_elementAct)` Signature: z_x_y_i_elementAct:Action<int64,int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (z_x_y_i_elementAct:Action<int64,int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_i_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_i_elementAct:Action<int64,int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:VolumeInfo * z_x_y_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:VolumeInfo * z_x_y_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:VolumeInfo * z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:VolumeInfo * z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZY(z_y_elementAct)` Signature: z_y_elementAct:Action<int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZY(z_y_elementAct, z_postLineAct)` Signature: (z_y_elementAct:Action<int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZY(z_preLineAct, z_y_elementAct)` Signature: (z_preLineAct:Action<int64> * z_y_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZY(...)` Signature: (z_preLineAct:Action<int64> * z_y_elementAct:Action<int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(preLineAct, i_elementAct)` Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(z_y_i_elementAct)` Signature: z_y_i_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (z_y_i_elementAct:Action<int64,int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (z_preLineAct:Action<int64> * z_y_i_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (z_preLineAct:Action<int64> * z_y_i_elementAct:Action<int64,int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (t1:VolumeInfo * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(t1, z_y_i_i1_elementAct)` Signature: (t1:VolumeInfo * z_y_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (t1:VolumeInfo * z_y_i_i1_elementAct:Action<int64,int64,int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (t1:VolumeInfo * z_preLineAct:Action<int64> * z_y_i_i1_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (t1:VolumeInfo * z_preLineAct:Action<int64> * z_y_i_i1_elementAct:Action<int64,int64,int64,int64> * z_postLineAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.
`ForeachZYX(z_y_x_elementAct)` Signature: z_y_x_elementAct:Action<int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYX(...)` Signature: (z_y_x_elementAct:Action<int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYX(...)` Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_elementAct:Action<int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYX(...)` Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_elementAct:Action<int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(i_elementAct)` Signature: i_elementAct:Action<int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(z_y_x_i_elementAct)` Signature: z_y_x_i_elementAct:Action<int64,int64,int64,int64> -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (z_y_x_i_elementAct:Action<int64,int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_i_elementAct:Action<int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_i_elementAct:Action<int64,int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(t1, i_i1_elementAct)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:VolumeInfo * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:VolumeInfo * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,int64> * postLineAct:Action * postPlaneAct:Action) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:VolumeInfo * z_y_x_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:VolumeInfo * z_y_x_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:VolumeInfo * z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_i_i1_elementAct:Action<int64,int64,int64,int64,int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:VolumeInfo * z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_i_i1_elementAct:Action<int64,int64,int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit	Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.
`FX()` Signature: unit -> unit	First.X
`FY()` Signature: unit -> unit	First.Y
`FZ()` Signature: unit -> unit	First.Z
`GetJX(size)` Signature: size:V3l -> int64
`GetJX0(size)` Signature: size:V3l -> int64
`GetJXY(size)` Signature: size:V3l -> int64
`GetJXZ(size)` Signature: size:V3l -> int64
`GetJY(size)` Signature: size:V3l -> int64
`GetJY0(size)` Signature: size:V3l -> int64
`GetJYX(size)` Signature: size:V3l -> int64
`GetJYZ(size)` Signature: size:V3l -> int64
`GetJZ(size)` Signature: size:V3l -> int64
`GetJZ0(size)` Signature: size:V3l -> int64
`GetJZX(size)` Signature: size:V3l -> int64
`GetJZY(size)` Signature: size:V3l -> int64
`HasMatchingLayout(t1)` Signature: t1:VolumeInfo -> bool
`HasMatchingLayout(t1, t2)` Signature: (t1:VolumeInfo * t2:VolumeInfo) -> bool
`HasMatchingLayout(t1, t2, t3)` Signature: (t1:VolumeInfo * t2:VolumeInfo * t3:VolumeInfo) -> bool
`III` Signature: V3l
`IIO` Signature: V3l
`Index(x, y, z)` Signature: (x:int64 * y:int64 * z:int64) -> int64	Calculate element index for underlying data array.
`Index(v)` Signature: v:V3l -> int64	Calculate element index for underlying data array.
`Index(v)` Signature: v:V3i -> int64	Calculate element index for underlying data array.
`IndicesX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order.
`IndicesXY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesXYZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesXZY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order.
`IndicesYX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesYXZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesYZX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order.
`IndicesZX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesZXY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesZYX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IOI` Signature: V3l
`IOO` Signature: V3l
`JX` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X.
`JX0` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X in a loop around another loop in dimension 0.
`JXY` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X in a loop around another loop in dimension Y.
`JXZ` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X in a loop around another loop in dimension Z.
`JY` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y.
`JY0` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y in a loop around another loop in dimension 0.
`JYX` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y in a loop around another loop in dimension X.
`JYZ` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y in a loop around another loop in dimension Z.
`JZ` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z.
`JZ0` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z in a loop around another loop in dimension 0.
`JZX` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z in a loop around another loop in dimension X.
`JZY` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z in a loop around another loop in dimension Y.
`OII` Signature: V3l
`OIO` Signature: V3l
`OOI` Signature: V3l
`OOO` Signature: V3l
`OriginIndex()` Signature: unit -> unit Modifiers: abstract
`Rank` Signature: int Modifiers: abstract	Return the rank or dimension of the the volume (3).
`S()` Signature: unit -> unit	Size
`SizeArray()` Signature: unit -> unit Modifiers: abstract	Get or set the size of the tensor in each dimension as an array of longs.
`SubMatrix(origin, size, delta)` Signature: (origin:V3l * size:V2l * delta:V2l) -> MatrixInfo	A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates.
`SubMatrix(origin, size, delta)` Signature: (origin:V3i * size:V2i * delta:V2l) -> MatrixInfo	A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates.
`SubMatrix(bx, by, bz, sx, sy, dx, dy)` Signature: (bx:int64 * by:int64 * bz:int64 * sx:int64 * sy:int64 * dx:int64 * dy:int64) -> MatrixInfo	A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates.
`SubVector(begin, size, delta)` Signature: (begin:V3l * size:int64 * delta:int64) -> VectorInfo	A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Vector with zero as first coordinates.
`SubVector(begin, size, delta)` Signature: (begin:V3i * size:int64 * delta:int64) -> VectorInfo	A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Vector with zero as first coordinates.
`SubVolume(begin, size)` Signature: (begin:V3l * size:V3l) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.
`SubVolume(begin, size)` Signature: (begin:V3i * size:V3i) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.
`SubVolume(begin, size, delta)` Signature: (begin:V3l * size:V3l * delta:V3l) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.
`SubVolume(begin, size, delta)` Signature: (begin:V3i * size:V3i * delta:V3i) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.
`SubVolume(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.
`SubVolume(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.
`SubVolumeWindow(begin, size)` Signature: (begin:V3l * size:V3l) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.
`SubVolumeWindow(begin, size)` Signature: (begin:V3i * size:V3i) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.
`SubVolumeWindow(begin, size, delta)` Signature: (begin:V3l * size:V3l * delta:V3l) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.
`SubVolumeWindow(begin, size, delta)` Signature: (begin:V3i * size:V3i * delta:V3i) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.
`SubVolumeWindow(...)` Signature: (begin:V3l * size:V3l * delta:V3l * first:V3l) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.
`SubVolumeWindow(...)` Signature: (begin:V3i * size:V3i * delta:V3i * first:V3i) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.
`SubVolumeWindow(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.
`SubVolumeWindow(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64) -> VolumeInfo	A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.
`SubXVectorAsReadOnlyVolume(...)` Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> VolumeInfo	Return a full X vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXVectorAsReadOnlyVolumeWindow(...)` Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> VolumeInfo	Return a full X vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.
`SubXYMatrix(z)` Signature: z:int64 -> MatrixInfo	Return a full XY matrix slice of the volume. This methods returns a matrix with zero as first coordinates.
`SubXYMatrixAsReadOnlyVolume(z, sizez)` Signature: (z:int64 * sizez:int64) -> VolumeInfo	Return a full XY matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXYMatrixAsReadOnlyVolumeWindow(...)` Signature: (z:int64 * sizez:int64) -> VolumeInfo	Return a full XY matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.
`SubXYMatrixWindow(z)` Signature: z:int64 -> MatrixInfo	Return a full XY matrix slice of the volume. This method retains the coordinates of the parent volume.
`SubXZMatrix(y)` Signature: y:int64 -> MatrixInfo	Return a full XZ matrix slice of the volume. This methods returns a matrix with zero as first coordinates.
`SubXZMatrixAsReadOnlyVolume(y, sizey)` Signature: (y:int64 * sizey:int64) -> VolumeInfo	Return a full XZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXZMatrixAsReadOnlyVolumeWindow(...)` Signature: (y:int64 * sizey:int64) -> VolumeInfo	Return a full XZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.
`SubXZMatrixWindow(y)` Signature: y:int64 -> MatrixInfo	Return a full XZ matrix slice of the volume. This method retains the coordinates of the parent volume.
`SubYVectorAsReadOnlyVolume(...)` Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> VolumeInfo	Return a full Y vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubYVectorAsReadOnlyVolumeWindow(...)` Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> VolumeInfo	Return a full Y vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.
`SubYZMatrix(x)` Signature: x:int64 -> MatrixInfo	Return a full YZ matrix slice of the volume. This methods returns a matrix with zero as first coordinates.
`SubYZMatrixAsReadOnlyVolume(x, sizex)` Signature: (x:int64 * sizex:int64) -> VolumeInfo	Return a full YZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubYZMatrixAsReadOnlyVolumeWindow(...)` Signature: (x:int64 * sizex:int64) -> VolumeInfo	Return a full YZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.
`SubYZMatrixWindow(x)` Signature: x:int64 -> MatrixInfo	Return a full YZ matrix slice of the volume. This method retains the coordinates of the parent volume.
`SubZVectorAsReadOnlyVolume(...)` Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> VolumeInfo	Return a full Z vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubZVectorAsReadOnlyVolumeWindow(...)` Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> VolumeInfo	Return a full Z vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.
`SX()` Signature: unit -> unit	Size.X
`SY()` Signature: unit -> unit	Size.Y
`SZ()` Signature: unit -> unit	Size.Z

Aardvark.Base

VolumeInfo

Constructors

Instance members