Guide

Grid(resolutions, [origin], [sz])
Grid(resolutions, rmax)
Grid(cell, [origin], [sz])

Constructs Grid struct Used downstream for interpolation (both read/write). Grids can be in any dimension and be Boundless or bounded. At minimum, a grid stores its discretization cell and origin in pixels. For an orthogonal grid, supply a list of resolutions in each dimension. For non-orthogonal grid, supply the cell vectors as a column-wise matrix. Origin by default is at index (1, ...).

Bounded grids compute and store additional info eg position vectors and their norms of all grid points. To construct bounded grid, supply the overall integer pixel size sz. For bounded cubic grid, use convenience constructor with rmax

Params

• resolutions: list of resolutions in each dimension for orthogonal grids
• origin: indices of the origin, may be decimal valued
• sz: integer size (pixel dimensions) of bounded grid
• rmax: halflength (in length units, not pixels) of bounded cubic grid
• cell: column-wise matrix of discretization cell vectors

fields

Examples

Grid((0.1,)) # 1d grid spaced 0.1 apart with origin at (1,) Grid((0.1, 0.2), (2, 5)) # 2d grid spaced 0.1 along x and 0.2 along y, with origin at (2 ,5) Grid((0.1, 0.1), 20.0) # bounded 2d grid spaced 0.1 apart, halflength 20.0, with origin at (201, 201), pixel size (401, 401) Grid(0.1 * [1 1 0; 1 0 1; 1 1 1]', ones(3), (10, 12, 15)) # bounded 3d grid with cell vectors [.1, .1, 0], [.1, 0, .1], .1, .1, .1. origin (1, 1, 1), pixel size (10, 12, 15). can construct lattice this way

get(collection, key, default)

Return the value stored for the given key, or the given default value if no mapping for the key is present.

Examples

julia> d = Dict("a"=>1, "b"=>2);

julia> get(d, "a", 3)
1

julia> get(d, "c", 3)
3

Base.get(field::AbstractArray, grid::Grid, rvec::AbstractVector)
Base.put!(
    field::AbstractArray,
    grid::Grid,
    rvec::AbstractVector,
    val::AbstractVector,
)

With grid info we can interpolate a scalar or vector field at any location. We can also place a scalar or vector point source anywhere with automatic normalization wrt discretization. Both work via a proximity weighted average of the closest grid points (in general up to 4 in 2d and 8 in 3d).

Op(radfunc, rmax, cell::AbstractMatrix; kw...)

constructs equivariant operator

function (m::Op)(x::AbstractArray, )

" Del(cell; pad = :same, border = :smooth)

constructs gradient operator

Laplacian(cell; pad = :same, border = :smooth)

constructs Laplacian operator

Examples

Gaussian(cell, σ, rmax; kw...)

constructs Normalized Gaussian diffusion operator

cvconv(x, f; product = *, stride = 1, pad = 0, alg = nothing)

"convolution" in computer vision for any dimension, same as Cross correlation. Automatically uses FFT for big kernels. For convolution in signal processing , use dspconv instead.

x input array f filter array product product in convolution, eg *, dot pad amount of padding or padding option

• any integer number of pixels on each boundary
• :same: adds enough padding so ouoverlapdotut is same size as input
• :outer: ouoverlapdotut size is size(x) .+ size(f) .- 1

border type of padding

• 0 value pixels
• :replicate repeats edge values
• periodic or :circular: periodic BC
• :smooth continuous derivatives at boundaries useful for differential operators
• :reflect reflects interior across boundaries which are not repeated
• :symmetric same as :reflect but with boundaries repeated

alg specifies convolution algorithm

• nothing Automatically chooses fastest algorithm
• :direct convolution, scales as O(n^2)
• :fft Fourier convolution, scales as O(n log(n))

Convolutions in other Julia packages, fewer features but perhaps more optimized for speed in their specific use cases

• ImageFiltering.imfilter. Its docs has excellent mathematical explaination of convolutions and correlation as well as padding/border options
• DSP.conv DSP.xcor
• Flux.conv

dspconv(x, f; product = *,pad = :outer,border=0)

Convolution in signal processing. For "convolution" in computer vision, use cvconv instead. Automatically uses FFT for big kernels. By default output size is size(x) .+ size(f) .- 1. See cvconv for its keyword options which also apply here