API

ExplicitOp(shape::NTuple{D,Int64}, tr::Trajectory, correctionmap::Array{ComplexF64,D}
        ; echoImage::Bool=false, kargs...) where D

generates a ExplicitOp which explicitely evaluates the MRI Fourier signal encoding operator.

Arguments:

• shape::NTuple{D,Int64} - size of image to encode/reconstruct
• tr::Trajectory - Trajectory with the kspace nodes to sample
• correctionmap::Array{ComplexF64,D} - fieldmap for the correction of off-resonance effects
• echoImage::Bool=false - if true sampling times will only be considered relative to the echo time this results in complex valued image even for real-valued input.
• kargs - additional keyword arguments

FieldmapNFFTOp(shape::NTuple{D,Int64}, tr::Trajectory,
                    correctionmap::Array{ComplexF64,D};
                    method::String="nfft",
                    echoImage::Bool=true,
                    alpha::Float64=1.75,
                    m::Float64=3.0,
                    K=20,
                    kargs...) where D

generates a FieldmapNFFTOp which evaluates the MRI Fourier signal encoding operator, including B0-inhomogeneities using time-segmented NFFTs.

Arguments:

• shape::NTuple{D,Int64} - size of image to encode/reconstruct
• tr::Trajectory - Trajectory with the kspace nodes to sample
• correctionmap::Array{ComplexF64,D} - fieldmap for the correction of off-resonance effects
• (method::String="nfft") - method to use for time-segmentation when correctio field inhomogeneities
• (echoImage::Bool=false) - if true sampling times will only be considered relative to the echo time this results in complex valued image even for real-valued input.
• (alpha::Float64=1.75) - oversampling factor for interpolation
• (m::Float64=3.0) - truncation size of interpolation kernel
• (K=20) - number of translates for LeastSquares approaches (not NFFT-approach) to time-segmentation
• (kargs) - additional keyword arguments

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

buildsa 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

SensitivityOp(sensMaps::Matrix{ComplexF64}, numEchoes::Int=1)

builds a LinearOperator which performs multiplication of a given image with the coil sensitivities specified in sensMaps

Arguments

• sensMaps::Matrix{ComplexF64} - sensitivity maps ( 1. dim -> voxels, 2. dim-> coils)
• numEchoes - number of contrasts to which the opetaor will be applied

SensitivityOp(sensMaps::Array{T,4}, numContr::Int=1) where T

builds a LinearOperator which performs multiplication of a given image with the coil sensitivities specified in sensMaps

Arguments

• sensMaps::Array{T,4} - sensitivity maps ( 1.-3. dim -> voxels, 4. dim-> coils)
• numContr - number of contrasts to which the opetaor will be applied

SparseOp(name::AbstractString, shape::NTuple{N,Int64}; kargs...) where N

generates the sparsifying transform (<: AbstractLinearOperator) given its name.

Arguments

• name::AbstractString - name of the sparsifying transform
• shape::NTuple{N,Int64} - size of the Array to be transformed
• (kargs) - additional keyword arguments

sample(shape::NTuple{N,Int64}, redFac::Float64, patFunc::String; kargs...)

generates a Vector{Int64} of indices to sample an Array of of size shape with a reduction factor redFac.

Arguments

• shape::NTuple{N,Int64} - size of the Array to be sampled
• redFac::Float64 - subsampling factor
• patFunc::String - name of the sampling function ("random, "regular", "lines", "poisson" or "vdPoisson")

sample_kspace(data::AbstractArray, redFac::Float64, patFunc::String; kargs...)

subsamples the Array data with a reduction factor redFac and returns both the subsampled Array (as a vector) and the sampled indices (as a vector)

Arguments

• data::AbstractArray - array to be sampled
• redFac::Float64 - subsampling factor
• patFunc::String - name of the sampling function ("random, "regular", "lines", "poisson" or "vdPoisson")
• kargs... - addional keyword arguments

sample_kspace(acqData::AcquisitionData,redFac::Float64,
            patFunc::AbstractString; rand=true, profiles=true,
            seed = 1234, kargs...)

subsamples the data in acqData with reduction factor redFac and returns a new AcquisitionData object.

Arguments

• acqData::AcquisitionDatay - AcquisitionData to be sampled
• redFac::Float64 - subsampling factor
• patFunc::String - name of the sampling function ("random, "regular", "lines", "poisson" or "vdPoisson")
• (rand=true) - use different patterns for the different contrasts
• (profiles=true) - sample complete profiles
• (seed=1234) - seed for the random number generator
• kargs... - addional keyword arguments

sample_regular(shape::Tuple{Int64,Int64},redFac::Float64;kargs...)

generates a regular sampling pattern for an Array of size shape with a subsampling factor redFac.

Arguments

• shape::NTuple{N,Int64} - size of the Array to be sampled
• redFac::Float64 - subsampling factor

sample_random(shape::Tuple{Int64,Int64},redFac::Float64;calsize::Int64=0,kargs...)

generates a random sampling pattern for an Array of size shape with a subsampling factor redFac.

Arguments

• shape::NTuple{N,Int64} - size of the Array to be sampled
• redFac::Float64 - subsampling factor
• (calsize::Int64=0) - size of the fully sampled calibration area

sample_poissondisk(shape::Tuple{Int64,Int64},redFac::Float64;calsize::Int64=0, seed::Int64=1234,kargs...)

generates a Poisson disk sampling pattern for an Array of size shape with a subsampling factor redFac.

Arguments

• shape::NTuple{2,Int64} - size of the Array to be sampled
• redFac::Float64 - subsampling factor
• (calsize::Int64=0) - size of the fully sampled calibration area
• (seed=1234) - seed for the random number generator

sample_vdpoisson(shape::Tuple{Int64,Int64},redFac::Float64; seed::Int64=1234,kargs...)

generates a variable density Poisson disk sampling pattern for an Array of size shape with a subsampling factor redFac.

Arguments

• shape::NTuple{2,Int64} - size of the Array to be sampled
• redFac::Float64 - subsampling factor
• (seed=1234) - seed for the random number generator

sample_lines(shape::Tuple{Int64,Int64},redFac::Float64;sampleFunc="random",kargs...)

generates a pattern to sample complete lines of an Array of size shape with a subsampling factor redFac.

Arguments

• shape::NTuple{N,Int64} - size of the Array to be sampled
• redFac::Float64 - subsampling factor
• sampleFunc="random" - name of the sampling function ("random, "regular", "lines", "poisson" or "vdPoisson")
• kargs... - addional keyword arguments

calculateIncoherence(acqData::AcquisitionData, recoParams::Dict, slice=1)

calculates the incoherence of the sampling pattern contained in acqData

Arguments

• acqData::AcquisitionData - AcquisitionData containing the sampling pattern
• recoParams::Dict - Dict containing reconstruction parameters
• (slice=1) - slice for which to calculate the incoherence

simulation(image::Array{T,3}, simParams::Dict, filename::String) where T<:Union{Complex{<:AbstractFloat},AbstractFloat}

Performs the same simulation as simulation(image, simParams) and saves the result in a file with name filename

simulation(image::Array{T,2}, simParams::Dict) where T<:Union{Complex{<:AbstractFloat},AbstractFloat}

Simulate MRI raw data from given image data. All simulation parameters are passed to the function in the form of a dictionary.

Adds average white gaussian noise to the signal x

Arguments

• x::Vector - signal vector
• 'snr::Float64' - target SNR

return AcquisitionData with white gaussian noise

Arguments

• acqData::AcquisitionData - AcquisitionData
• 'snr::Float64' - target SNR

add white gaussian noise to AcquisitionData with (in-place)

Arguments

• acqData::AcquisitionData - AcquisitionData
• 'snr::Float64' - target SNR

birdcageSensitivity(N::Int64, ncoils::Int64, relative_radius::Float64)

Computes the sensitivity maps for each coils that are arranged in a birdcage manner.

quadraticFieldmap(Nx::Int64, Ny::Int64, maxOffresonance::Float64=125.0)

Computes a parabolic fieldmap.

reconstruction(acqData::AcquisitionData, recoParams::Dict)

Performs image reconstruction of an AcquisitionData object. Parameters are specified in a dictionary.

Reconstruction types are specified by the symbol :reco. Valid reconstruction names are:

• :direct - direct Fourier reconstruction
• :standard - iterative reconstruction for all contrasts, coils & slices independently
• :multiEcho - iterative joint reconstruction of all echo images
• :multiCoil - SENSE-type iterative reconstruction
• :multiCoilMultiEcho - SENSE-type iterative reconstruction of all echo images

reconstruction(acqData::AcquisitionData, recoParams::Dict,filename::String; force=false)

performs the same image reconstrucion as reconstruction(acqData::AcquisitionData, recoParams::Dict) and saves the image in a file with name filename. If force=false, the reconstructed image is loaded from the the file filename if the latter is present.

setupIterativeReco(acqData::AcquisitionData, recoParams::Dict)

builds relevant parameters and operators from the entries in recoParams

relevant parameters

• reconSize::NTuple{2,Int64} - size of image to reconstruct
• weights::Vector{Vector{Complex{<:AbstractFloat}}} - sampling density of the trajectories in acqData
• sparseTrafo::AbstractLinearOperator - sparsifying transformation
• reg::Regularization - Regularization to be used
• normalize::Bool - adjust regularization parameter according to the size of k-space data
• solvername::String - name of the solver to use
• senseMaps::Array{Complex{<:AbstractFloat}} - coil sensitivities
• correctionMap::Array{Complex{<:AbstractFloat}} - fieldmap for the correction of off-resonance effects
• method::String="nfft" - method to use for time-segmentation when correctio field inhomogeneities

sparseTrafo and reg can also be speficied using their names in form of a string.

Performs iterative image reconstruction independently for the data of all coils, contrasts and slices

Arguments

• acqData::AcquisitionData - AcquisitionData object
• reconSize::NTuple{2,Int64} - size of image to reconstruct
• reg::Regularization - Regularization to be used
• sparseTrafo::AbstractLinearOperator - sparsifying transformation
• weights::Vector{Vector{Complex{<:AbstractFloat}}} - sampling density of the trajectories in acqData
• solvername::String - name of the solver to use
• (normalize::Bool=false) - adjust regularization parameter according to the size of k-space data
• (params::Dict{Symbol,Any}) - Dict with additional parameters

Performs a iterative image reconstruction jointly for all contrasts. Different slices and coil images are reconstructed independently.

Arguments

• acqData::AcquisitionData - AcquisitionData object
• reconSize::NTuple{2,Int64} - size of image to reconstruct
• reg::Regularization - Regularization to be used
• sparseTrafo::AbstractLinearOperator - sparsifying transformation
• weights::Vector{Vector{Complex{<:AbstractFloat}}} - sampling density of the trajectories in acqData
• solvername::String - name of the solver to use
• (normalize::Bool=false) - adjust regularization parameter according to the size of k-space data
• (params::Dict{Symbol,Any}) - Dict with additional parameters

Performs a SENSE-type iterative image reconstruction. Different slices and contrasts images are reconstructed independently.

Arguments

• acqData::AcquisitionData - AcquisitionData object
• reconSize::NTuple{2,Int64} - size of image to reconstruct
• reg::Regularization - Regularization to be used
• sparseTrafo::AbstractLinearOperator - sparsifying transformation
• weights::Vector{Vector{Complex{<:AbstractFloat}}} - sampling density of the trajectories in acqData
• solvername::String - name of the solver to use
• senseMaps::Array{Complex{<:AbstractFloat}} - coil sensitivities
• (normalize::Bool=false) - adjust regularization parameter according to the size of k-space data
• (params::Dict{Symbol,Any}) - Dict with additional parameters

Performs a SENSE-type iterative image reconstruction which reconstructs all contrasts jointly. Different slices are reconstructed independently.

Arguments

• acqData::AcquisitionData - AcquisitionData object
• reconSize::NTuple{2,Int64} - size of image to reconstruct
• reg::Regularization - Regularization to be used
• sparseTrafo::AbstractLinearOperator - sparsifying transformation
• weights::Vector{Vector{Complex{<:AbstractFloat}}} - sampling density of the trajectories in acqData
• solvername::String - name of the solver to use
• senseMaps::Array{Complex{<:AbstractFloat}} - coil sensitivities
• (normalize::Bool=false) - adjust regularization parameter according to the size of k-space data
• (params::Dict{Symbol,Any}) - Dict with additional parameters

espirit(acqData::AcquisitionData, ksize::NTuple{2,Int} = (6,6), ncalib::Int = 24
           ; eigThresh_1::Number=0.02, eigThresh_2::Number=0.95, nmaps = 1)

espirit(calibData::Array{T}, imsize::NTuple{N,Int}, ksize::NTuple{N,Int} = (6,6[,6])
           ; eigThresh_1::Number = 0.02, eigThresh_2::Number = 0.95, nmaps = 1)

Obtains coil sensitivities from a calibration area using ESPIRiT. The code is adapted from the MATLAB code by Uecker et al. (cf. Uecker et al. "ESPIRiT—an eigenvalue approach to autocalibrating parallel MRI: Where SENSE meets GRAPPA"). The matlab code can be found at: [http://people.eecs.berkeley.edu/~mlustig/Software.html]

Method 1

The first method of this function works with 2D/multi-slice data in the MRIReco.jl data format:

espirit(acqData::AcquisitionData, ksize::NTuple{2,Int} = (6,6), ncalib::Int = 24
          ; eigThresh_1::Number=0.02, eigThresh_2::Number=0.95)

Required Arguments

• acqData::AcquisitionData - AcquisitionData

Optional Arguments

• ksize::NTuple{2,Int64} - size of the k-space kernel; default = (6,6)
• ncalib::Int64 - number of calibration points in each dimension; default = 30

Keyword Arguments

• eigThresh_1::Number=0.02 - threshold for the singular values of the calibration matrix (relative to the largest value); reduce for more accuracy, increase for saving memory and computation time.
• eigThresh_2::Number=0.95 - threshold to mask the final maps: for each voxel, the map will be set to 0, if, for this voxel, no singular value > eigThresh_2 exists.
• nmaps = 1 - Number of maps that are calcualted. Set to 1 for regular SENSE; set to 2 for soft-SENSE (cf. Uecker et al. "ESPIRiT—an eigenvalue approach to autocalibrating parallel MRI: Where SENSE meets GRAPPA").

Method 2

The second method of this function works with single slice 2D or 3D data; the first argument is the calibration data, i.e. the cropped center of k-space:

espirit(calibData::Array{T}, imsize::NTuple{N,Int}, ksize::NTuple{N,Int} = (6,6[,6])
          ; eigThresh_1::Number = 0.02, eigThresh_2::Number = 0.95, nmaps = 1)

Required Arguments

• calibData::Array{T} - Center of k-space in the format kx × ky [× kz] × coils, where the kz dimension is optional. The type T of the input data determines the type of the calculated maps. Reasonable choises are in the range of Nx = Ny [= Nz] = 24.
• imsize::NTuple{N,Int} - matrix size of the final maps

Optional Arguments

• ksize::NTuple{N,Int} - number of calibration points in each dimension; the default is (6,6) for 2D and (6,6,6) for 3D.

Keyword Arguments

• eigThresh_1::Number=0.02 - threshold for the singular values of the calibration matrix (relative to the largest value); reduce for more accuracy, increase for saving memory and computation time.
• eigThresh_2::Number=0.95 - threshold to mask the final maps: for each voxel, the map will be set to 0, if, for this voxel, no singular value > eigThresh_2 exists.
• nmaps = 1 - Number of maps that are calcualted. Set to 1 for regular SENSE; set to 2 for soft-SENSE (cf. Uecker et al. "ESPIRiT—an eigenvalue approach to autocalibrating parallel MRI: Where SENSE meets GRAPPA").
• use_poweriterations = true - flag to determine if power iterations are used; power iterations are only used if nmaps == 1. They provide speed benefits over the full eigen decomposition, but are an approximation.

nrmsd(I,Ireco)

computes the normalized root mean squared error of the image Ireco with respect to the image I.