API Documentation

raster(grid_size, points, rotation, translation, [background, out_weight])

Interpolate points (multi-) linearly into an Nd-array of size grid_size.

Before points are interpolated into the array, each point $p$ is first transformed according to

\[\hat{p} = R p + t\]

with rotation $R$ and translation $t$.

Points $\hat{p}$ that fall into the N-dimensional hypercube with edges spanning from (-1, 1) in each dimension, are interpolated into the output array.

The total weight of each point (out_weight * point_weight) is distributed onto the 2^N nearest pixels/voxels of the output array (according to the closeness of the voxel center to the coordinates of point $\hat{p}$) via N-linear interpolation.

Arguments

• grid_size: Tuple of integers defining the output dimensions
• points::AbstractVector{<:AbstractVector}: A vector of same length vectors representing points
• rotation: Either a single matrix(-like object) or a vector of such, that linearly transform(s) points before rasterisation.
• translation: Either a single vector or a vector of such, that translates points after rotation. If rotation includes a projection, translation thus needs to have the same length as rotation * points[i].
• background: Either a single number or a vector of such.
• out_weight: Either a single number or a vector (one per image) of such.
• point_weight: A vector of numbers (one per point).

rotation, translation, background and out_weight can have an additional "batch" dimension (by providing them as vectors of single parameters. The length of these vectors must be the same for all four arguments). In this case, the output array will have dimensionality +1 with an additional axis on last position corresponding to the number of elements in the batch. See Raster a single point cloud to a batch of poses for more details.

See also: raster!

raster!(out, points, rotation, translation, [background, out_weight, point_weight])

Interpolate points (multi-) linearly into the Nd-array out. In-place version of raster. See there for details.

raster_pullback!(
    ds_dout, args...;
    [points, rotation, translation, background, out_weight, point_weight]
)

Pullback for raster / raster!.

Take as input ds_dout the sensitivity of some quantity (s for "scalar") to the output out of the function out = raster(grid_size, args...) (or out = raster!(out, args...)), as well as the exact same arguments args that were passed to raster/raster!, and return the sensitivities of s to the inputs args of the function raster/raster!.

Optionally, pre-allocated output arrays for each input sensitivity can be specified as keyword arguments with the name of the original argument to raster as key, and a nd-array as value, where the n-th dimension is the batch dimension. For example to provide a pre-allocated array for the sensitivity of s to the translation argument of raster, do: sensitivities = raster_pullback!(ds_dout, args...; translation = [zeros(2) for _ in 1:8]) for 2-dimensional points and a batch size of 8. See also Raster a single point cloud to a batch of poses

digitstuple(k, Val(N))

Return a N-tuple containing the bit-representation of k

reference_coordinate_and_deltas(point, rotation, origin, scale)

Return

• The cartesian coordinate of the voxel of an N-dimensional rectangular grid that is the one closest to the origin, out of the 2^N voxels that are next neighbours of the (N-dimensional) point
• A Nx2 array containing coordinate-wise distances of the scaled point to the voxel that is
  • closest to the origin (out of the 2^N next neighbors) in the first column
  • furthest from the origin (out of the 2^N next neighbors) in the second column.

The grid is implicitely assumed to discretize the hypercube ranging from (-1, 1) in each dimension. Before point is discretized into this grid, it is first translated by -origin and then scaled by scale.

voxel_shifts(Val(N), [int_type])

Enumerate nearest neighbor coordinate shifts with respect to "upper left" voxel.

For a N-dimensional voxel grid, return a 2^N-tuple of N-tuples, where each element of the outer tuple is a cartesian coordinate shift from the "upper left" voxel.