SamplingOp(pattern::Array{Int}, shape::Tuple)

builds a LinearOperator which only returns the vector elements at positions indicated by pattern.

Arguents

• pattern::Array{Int} - indices to sample
• shape::Tuple - size of the array to sample

WeightingOp(::Type{T}; weights::Vector{T}, rep::Int=1) where T

generates a LinearOperator which multiplies an input vector index-wise with weights

Arguments

• weights::Vector{T} - weights vector
• rep::Int=1 - number of sub-arrays that need to be multiplied with weights

DiagOp(ops...)
DiagOp(ops::Vector{...})
DiagOp(ops::NTuple{N,...})

create a bloc-diagonal operator out of the LinearOperators or Arrays contained in ops

GradientOp(T::Type; shape::Tuple, dims=1:length(shape))

directional gradient operator along the dimensions dims for an array of size shape.

Required Argument

• T - type of elements, .e.g. Float64 for ComplexF32

Required Keyword argument

• shape::NTuple{N,Int} - shape of the array (e.g., image)

Optional Keyword argument

• dims - dimension(s) along which the gradient is applied; default is 1:length(shape)

ProdOp(A,B)

composition/product of two Operators. Computes (A * (B * x)). Differs with composition via * since it can handle normal operator and allows for specialisation on A and B.

NormalOp(T::Type; parent, weights)

Lazy normal operator of parent with an optional weighting operator weights. Computes adjoint(parent) * weights * parent.

Required Argument

• T - type of elements, .e.g. Float64 for ComplexF32

Required Keyword argument

• parent - Base operator

Optional Keyword argument

• weights - Optional weights for normal operator. Must already be of form weights = adjoint.(w) .* w

normalOperator(prod::ProdOp{T, <:WeightingOp, matT}; kwargs...)

Fuses weights of ẀeightingOp by computing adjoint.(weights) .* weights

normalOperator(parent (, weights); kwargs...)

Constructs a normal operator of the parent in an opinionated way, i.e. it tries to apply optimisations to the resulting operator.

WaveletOp(shape, wt=wavelet(WT.db2))

returns a ẀaveletOp <: AbstractLinearOperator, which performs a Wavelet transform on a given input array.

Arguments

• shape - size of the Array to transform
• (wt=wavelet(WT.db2)) - Wavelet to apply

RadonOp(::Type{T}; shape::NTuple{N, Int}, angles, geometry = RadonParallelCircle(shape[1], -(shape[1]-1)÷2:(shape[1]-1)÷2), μ = nothing, S = Vector{T}) where {T, N}

Generates a RadonOp which evaluates the Radon transform operator and its adjoint (backprojection) for a given geometry and projection angles.

Arguments:

• T - element type for the operator (e.g., Float64, ComplexF32)
• shape::NTuple{N, Int} - size of the image
• angles - array of projection angles
• geometry - Radon geometry descriptor (default: parallel beam circle)
• μ - optional attenuation map (for attenuated Radon transform)
• S - storage type for internal vectors (default: Vector{T})

NFFTOpImpl(shape::Tuple, tr::Trajectory; kargs...)
NFFTOpImpl(shape::Tuple, tr::AbstractMatrix; kargs...)

generates a NFFTOpImpl which evaluates the MRI Fourier signal encoding operator using the NFFT.

Arguments:

• shape::NTuple{D,Int64} - size of image to encode/reconstruct
• tr - Either a Trajectory object, or a ND x Nsamples matrix for an ND-dimenensional (e.g. 2D or 3D) NFFT with Nsamples k-space samples
• (nodes=nothing) - Array containg the trajectory nodes (redundant)
• (kargs) - additional keyword arguments

FFTOp(T::Type; shape::Tuple, shift=true, unitary=true)

returns an operator which performs an FFT on Arrays of type T

Arguments:

• T::Type - type of the array to transform
• shape::Tuple - size of the array to transform
• (shift=true) - if true, fftshifts are performed
• (unitary=true) - if true, FFT is normalized such that it is unitary
• (S = Vector{T}) - type of temporary vector, change to use on GPU
• (kwargs...) - keyword arguments given to fft plan

DCTOpImpl(T::Type, shape::Tuple, dcttype=2)

returns a DCTOpImpl <: AbstractLinearOperator which performs a DCT on a given input array.

Arguments:

• T::Type - type of the array to transform
• shape::Tuple - size of the array to transform
• dcttype - type of DCT (currently 2 and 4 are supported)

DSTOp(T::Type, shape::Tuple)

returns a LinearOperator which performs a DST on a given input array.

Arguments:

• T::Type - type of the array to transform
• shape::Tuple - size of the array to transform