Skip to content

MRIBase ​

MRIBase defines the data types that the other packages build on: raw data organized like an ISMRMRD file (RawAcquisitionData), k-space data prepared for reconstruction (AcquisitionData) and k-space trajectories (Trajectory), together with functions to access and convert them. MRIBase does not depend on other packages of this repository. MRIReco re-exports it, so using MRIReco makes all names on this page available.

Raw Data ​

MRIBase.RawAcquisitionData Type

RawAcquisitionData object.

Fields

  • params::Dict{String, Any} - Dict containing the information of the XML header in ISMRMRD

  • profiles::Vector{Profile} - Vector containing all the profiles of the acquisition

source
MRIBase.Profile Type

Struct to describe data from one profile of a trajectory (from all coils).

source
MRIBase.AcquisitionHeader Type

Header of a profile of a RawAcquisitionData object, with the fields of the acquisition header of the ISMRMRD format, for example the number of samples number_of_samples, the time between two samples sample_time_us in µs, the position and orientation of the slice and the encoding counters idx.

source
MRIBase.EncodingCounters Type

Encoding counters used in each Profile of a RawAcquisitionData object.

source
MRIBase.Limit Type
julia
Limit(minimum, maximum, center)

Minimum, maximum and center of one of the encoding limits in the ISMRMRD header, for example of the phase encoding steps. When an ISMRMRD file is read, the limits of the k-space encoding steps, averages, slices, contrasts, phases, repetitions, sets and segments in the header are stored in params with the prefix enc_lim_, for example params["enc_lim_kspace_encoding_step_1"].

source
MRIBase.MeasurementDependency Type
julia
MeasurementDependency(dependencyType, measurementID)

Measurement that the data depends on, from the ISMRMRD header, for example a noise measurement with the dependencyType "Noise". When an ISMRMRD file is read, it is stored in params["measurementDependency"], as a vector if there are several.

source
MRIBase.CoilDescription Type
julia
CoilDescription(number, name)

Number and name of a receive coil from the element coilLabel of the ISMRMRD header. When an ISMRMRD file is read, the coils are stored in params["coilLabel"], as a vector if there are several.

source
MRIBase.RawAcquisitionData Method
julia
RawAcquisitionData(acqData::AcquisitionData)

converts acqData into the equivalent RawAcquisitionData object.

source
MRIBase.AcquisitionData Method
julia
AcquisitionData(f::RawAcquisitionData; estimateProfileCenter::Bool=false, OffsetBruker=false)

converts RawAcquisitionData into the equivalent AcquisitionData object. If OffsetBruker=true, add a phase offset to correct position only along Y/Z direction

source
MRIBase.minimalHeader Method
julia
minimalHeader(encodingSize, fov::NTuple{3,AbstractFloat};
              f_res::Integer=1, tr_name::AbstractString="cartesian", numChannels::Int=1)

returns a parameter dictionary for RawAcquisitionData with the entries "encodedSize" and "encodedFOV", which hold encodingSize and fov (in mm) as vectors, "trajectory" (tr_name), "receiverChannels" (numChannels) and "H1resonanceFrequency_Hz" (f_res). encodingSize is the size of the encoded grid, for example (256, 256, 1) for 2D data. These entries suffice to convert raw data with Cartesian profiles into AcquisitionData.

source
MRIBase.numChannels Method
julia
numChannels(f::RawAcquisitionData)

returns the number of channels in a RawAcquisitionData object.

source
MRIBase.trajectory Method
julia
trajectory(f::RawAcquisitionData; slice::Int=1, contrast::Int=1)

returns the Trajectory for given slice and contrast of a RawAcquisitionData object.

source

Flags ​

The guide Select and Prepare Profiles shows how to use the flags. Each name in FLAGS is also exported as a UInt64 bit mask, for example ACQ_IS_NOISE_MEASUREMENT, for working with head.flags directly.

MRIBase.FLAGS Constant
julia
FLAGS::Dict{String, Int}

A dictionary mapping string keys (representing flag names) to bit positions, counting from 1 for the least significant bit. Flags are used to indicate specific attributes of the corresponding Profile. Example flag names include "ACQ_FIRST_IN_ENCODE_STEP1", "ACQ_LAST_IN_SLICE", etc.

source
MRIBase.create_flag_bitmask Method
julia
create_flag_bitmask(flag::AbstractString) -> UInt64
create_flag_bitmask(flag::Integer) -> UInt64

Creates a bitmask for the given flag.

  • If the flag is a string, its integer value is looked up in FLAGS.

  • If the flag is an integer, it must be positive. The bitmask is created by left-shifting 1 to the corresponding bit position.

Arguments

  • flag: A string representing the flag name or a positive integer.

Returns

  • A UInt64 bitmask where only the bit corresponding to the flag is set.

Throws

  • KeyError if the string flag is not found in FLAGS.

  • DomainError if the integer flag is not positive.

Example

julia
create_flag_bitmask("ACQ_FIRST_IN_ENCODE_STEP1")  # 0x0000000000000001
create_flag_bitmask(2)                           # 0x0000000000000002
source
MRIBase.filter_raw_by_flags Method
julia
filter_raw_by_flags(rawData::RawAcquisitionData, flags::Vector{String})

Filters the profiles in a RawAcquisitionData object based on specified flags.

Arguments

  • rawData::RawAcquisitionData: The RawAcquisitionData object to filter.

  • flags::Vector{String}: A vector of flag names to filter the profiles by.

Returns

  • RawAcquisitionData: A new RawAcquisitionData object containing only the profiles that have all the specified flags set.

Examples

julia
# Assuming `rawData` is a RawAcquisitionData object
filteredData = filter_raw_by_flags(rawData, ["ACQ_IS_NOISE_MEASUREMENT"])
source
MRIBase.flag_is_set Method
julia
flag_is_set(obj::Profile, flag) -> Bool
flag_is_set(head::AcquisitionHeader, flag) -> Bool

Checks whether a specific flag is set in the given Profile or AcquisitionHeader object.

Arguments

  • obj: A Profile or AcquisitionHeader object field containing a flags attribute (as a bitmask).

  • flag: A string (flag name) or an integer (bit position).

Returns

  • true if the flag is set in the obj.head.flags bitmask; otherwise, false.

Example

julia
flag_is_set(profile, "ACQ_FIRST_IN_ENCODE_STEP1")  # true or false
flag_is_set(head, "ACQ_FIRST_IN_ENCODE_STEP1")  # true or false
source
MRIBase.flag_remove! Method
julia
flag_remove!(obj::Profile, flag)
flag_remove!(head::AcquisitionHeader, flag)

Removes (clears) the specified flag in the given Profile or AcquisitionHeader object.

Arguments

  • obj: A Profile object with a head field containing a flags attribute (as a bitmask).

  • head: An AcquisitionHeader object containing a flags attribute (as a bitmask).

  • flag: A string (flag name) or an integer (bit position), or a vector of such values.

Modifies

  • obj.head.flags or head.flags by clearing the bit corresponding to the flag.

Example

julia
flag_remove!(profile, "ACQ_LAST_IN_PHASE")
flag_remove!(profile, ["ACQ_LAST_IN_PHASE","ACQ_USER8"])

head = AcquisitionHeader()
flag_remove!(head, "ACQ_LAST_IN_PHASE")
source
MRIBase.flag_remove_all! Method
julia
flag_remove_all!(obj::Profile)
flag_remove_all!(head::AcquisitionHeader)

Clears all flags in the given Profile object or AcquisitionHeader object.

Arguments

  • obj: A Profile object with a head field containing a flags attribute (as a bitmask).

  • head: An AcquisitionHeader object containing a flags attribute (as a bitmask).

Modifies

  • obj.head.flags or head.flags, setting it to 0 (all flags cleared).

Example

julia
flag_remove_all!(profile)
flag_remove_all!(head)
source
MRIBase.flag_set! Method
julia
flag_set!(obj::Profile, flag)
flag_set!(head::AcquisitionHeader, flag)

Sets the specified flag in the given Profile or AcquisitionHeader object.

Arguments

  • obj: A Profile object with a head field containing a flags attribute (as a bitmask).

  • head: An AcquisitionHeader object containing a flags attribute (as a bitmask).

  • flag: A string (flag name) or an integer (bit position), or a vector of such values.

Modifies

  • obj.head.flags or head.flags by setting the bit corresponding to the flag.

Example

julia
flag_set!(profile, "ACQ_FIRST_IN_SLICE")
flag_set!(profile, ["ACQ_LAST_IN_PHASE","ACQ_USER8"])

head = AcquisitionHeader()
flag_set!(head, "ACQ_FIRST_IN_SLICE")
source
MRIBase.flags_of Method
julia
flags_of(obj::Profile) -> Vector{String}
flags_of(head::AcquisitionHeader) -> Vector{String}

Returns a list of all flags that are set in the given Profile object or AcquisitionHeader object.

Arguments

  • obj: A Profile object with a head field containing a flags attribute (as a bitmask).

  • head: An AcquisitionHeader object containing a flags attribute (as a bitmask).

Returns

  • An array of strings representing the names of the flags that are currently set.

Example

julia
flags = flags_of(profile)  # ["ACQ_FIRST_IN_ENCODE_STEP1", "ACQ_LAST_IN_SLICE"]
source
MRIBase.remove_raw_by_flags Function
julia
remove_raw_by_flags(rawData::RawAcquisitionData, flags::Vector{String} = ["ACQ_IS_NOISE_MEASUREMENT", "ACQ_IS_PARALLEL_CALIBRATION", "ACQ_IS_NAVIGATION_DATA", "ACQ_IS_PHASECORR_DATA", "ACQ_IS_DUMMYSCAN_DATA", "ACQ_IS_PHASE_STABILIZATION_REFERENCE", "ACQ_IS_PHASE_STABILIZATION"])

Removes profiles from a RawAcquisitionData object based on specified flags.

Arguments

  • rawData::RawAcquisitionData: The RawAcquisitionData object to filter.

  • flags::Vector{String}: A vector of flag names to filter the profiles by. Defaults to a list of common flags indicating non-imaging data.

Returns

  • RawAcquisitionData: A new RawAcquisitionData object containing only the profiles that do not have any of the specified flags set.

Examples

julia
# Assuming `rawData` is a RawAcquisitionData object
filteredData = remove_raw_by_flags(rawData)
source

AcquisitionData ​

The guide Create AcquisitionData from Arrays shows how to create it from arrays, and Data Model explains its fields.

MRIBase.AcquisitionData Type

struct describing MRI acquisition data with floating point precision T and D encoding dimensions (2 or 3).

Fields

  • sequenceInfo::Dict{Symbol,Any} - additional information on the pulse sequence

  • traj::Vector{Trajectory{T}} - trajectories for each echo/contrast

  • kdata::Array{Matrix{Complex{T}},3} - each matrix contains data for one trajectory (1. dim k-space nodes, 2. dim coils) the outer dims describe: 1. dim echoes, 2. dim slices, 3. dim repetitions

  • subsampleIndices::Vector{Vector{Int64}} - indices sampled for each echo/contrast

  • encodingSize::NTuple{D,Int64} - size of the underlying image matrix

  • fov::NTuple{3,Float64} - field of view in mm

source
MRIBase.AcquisitionData Method
julia
AcquisitionData(kspace::Array{Complex{T},6}; enc2D=false)

Returns an AcquisitionData struct created from a zero-filled kspace with 6 dimensions : [x,y,z or slices,channels,echoes,repetitions]

Different undersampling patterns can be handled only along the echo dimension.

This method assumes the data to correspond to a single volume encoded with a 3d Cartesian sequence or in 2D multi-slice with keyword enc2D = true

Keywords :

  • enc2D=false: if true, the 3rd dimension is supposed to store the 2D slices

Notes :

  • The current implementation is using the same subsampling mask for all NR and Slices (only echoes can be different)
source
MRIBase.AcquisitionData Method
julia
AcquisitionData(tr::K,kdata::Array{Matrix{Complex{T}},3}; seqInfo=Dict{Symbol,Any}()
                    , idx=nothing, encodingSize=ntuple(d->0, ndims(tr)), fov=(0.0, 0.0, 0.0)
                    , kargs...) where {T <: AbstractFloat, K <: Union{Trajectory,Vector{Trajectory{T}}}}

constructor for AcquisitionData

Arguments

  • tr - a Trajectory{T}, or a Vector{Trajectory{T}} with one trajectory per contrast

  • kdata::Array{Matrix{Complex{T}},3} - k-space data, a matrix of samples × coils for each contrast, slice and repetition

  • (seqInfo=Dict{Symbol,Any}()) - stored in the field sequenceInfo

  • (idx=nothing) - sampled indices of each contrast (subsampleIndices), by default all nodes

  • (encodingSize) - size of the underlying image matrix, by default zeros; pass it for a vector of trajectories, for which the default has only one entry

  • (fov=(0.0, 0.0, 0.0)) - field of view in mm

Other keyword arguments are ignored.

source
MRIBase.changeEncodingSize2D Method
julia
changeEncodingSize2D(acqData::AcquisitionData, newEncodingSize::NTuple{2,Int64})

changes the encoding size of 2d encoded acqData to newEncodingSize by rescaling the k-space positions and removing the samples outside of the new size; the field encodingSize keeps its old value. Returns a new AcquisitionData object.

source
MRIBase.convert3dTo2d Method
julia
convert3dTo2d(acqData::AcquisitionData)

convert the 3d encoded AcquisitionData acqData to the equivalent 2d AcquisitionData.

source
MRIBase.convertUndersampledData Method
julia
convertUndersampledData(acqData::AcquisitionData)

converts undersampled AcquisitionData, where only profiles contained in acqData.subsampleIndices are sampled, into a format where trajectories only contain the sampled profiles.

source
MRIBase.encodingSize Method
julia
encodingSize(acq::AcquisitionData)

returns the size of the image grid that acq encodes, which the reconstruction uses as the default image size (zeros if it was not given when acq was created)

source
MRIBase.fieldOfView Method
julia
fieldOfView(acq::AcquisitionData)

returns the field of view of acq in mm, a tuple with three entries that are zero for data without this information

source
MRIBase.kData Function
julia
kData(acqData::AcquisitionData, echo::Int64=1, coil::Int64=1, slice::Int64=1;rep::Int64=1)

returns the k-space contained in acqData for given echo, coil, slice and rep(etition).

source
MRIBase.kDataCart Method
julia
kDataCart(acqData::AcquisitionData)

Returns the cartesian k-space contained in acqData for all echo, coil, slice and rep(etition) with dimension : [x,y,z*slices,channels,echoes,repetitions]

source
MRIBase.multiCoilData Method
julia
multiCoilData(acqData::AcquisitionData, echo::Int64, slice::Int64;rep::Int64=1)

returns the k-space contained in acqData for all coils and given echo, slice and rep(etition).

source
MRIBase.multiCoilMultiEchoData Method
julia
multiCoilMultiEchoData(acqData::AcquisitionData, slice::Int64; rep=1)

returns the k-space contained in acqData for all coils, echoes and given slice and rep(etition).

source
MRIBase.multiEchoData Method
julia
multiEchoData(acqData::AcquisitionData, coil::Int64, slice::Int64;rep::Int64=1)

returns the k-space contained in acqData for all echoes and given coil, slice and rep(etition).

source
MRIBase.numChannels Method
julia
numChannels(acqData::AcquisitionData)

returns the number of channels/coils in acqData

source
MRIBase.numContrasts Method
julia
numContrasts(acqData::AcquisitionData)

returns the number of contrasts/echoes in acqData

source
MRIBase.numRepetitions Method
julia
numRepetitions(acqData::AcquisitionData)

returns the number of repetitions in acqData

source
MRIBase.numSlices Method
julia
numSlices(acqData::AcquisitionData)

returns the number of slices in acqData

source
MRIBase.samplingDensity Method
julia
samplingDensity(acqData::AcquisitionData, shape::Tuple)

returns the square roots of the density compensation factors of the trajectories contained in acqData, one vector for each contrast, for an image of size shape. For Cartesian trajectories, they are constant, 1/sqrt(prod(shape)), one for each measured sample.

source
MRIBase.trajectory Function
julia
trajectory(acqData::AcquisitionData,i::Int64=1)

returns the i-th trajectory contained in acqData.

source

Trajectories ​

The guide Create a Trajectory shows how to create trajectories.

MRIBase.Trajectory Type

struct describing a trajectory with element type T

Fields

  • name::String - name of the trajectory

  • nodes::Matrix{T} - sampling locations in k-space. (1.dim <-> dimensions of k-space, 2. dim <-> sampling points)

  • times::Vector{T} - sampling times in s

  • TE::T - echo time in s

  • AQ::T - readout duration in s (per profile)

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • numSlices::Int64 - number of slices (for 3d trajectories)

  • cartesian::Bool - true if sampling points lie on a cartesian grid

  • circular::Bool - true if kspace is covered in a circular domain

source
MRIBase.Trajectory Method
julia
Trajectory(nodes::AbstractMatrix{T}, numProfiles::Int64, numSamplingPerProfile;
           times=nothing, TE=0.0, AQ=1.e-3, numSlices::Int64=1,
           cartesian::Bool=false, circular::Bool=false) where T <: AbstractFloat

creates a trajectory named "Custom" from the k-space positions nodes, a Matrix{T} with one row per dimension and one column per sample, ordered profile by profile and, in a stacked 3d trajectory, partition by partition. Without times, the samples of each profile are spread over the readout duration AQ, starting at TE.

Arguments

  • nodes::Matrix{T} - k-space positions between -0.5 and 0.5 (other matrix types, such as a transpose, have to be converted with Matrix first)

  • numProfiles::Int64 - number of profiles per partition

  • numSamplingPerProfile - number of sampling points per profile

  • (times=nothing) - sampling times in s, a Vector{T} with one time per node

  • (TE=0.0) - echo time in s

  • (AQ=1.e-3) - readout duration in s (per profile)

  • (numSlices::Int64=1) - number of partitions (slices) of a stacked 3d trajectory

  • (cartesian::Bool=false) - true if the nodes lie on the cartesian grid in the order of CartesianTrajectory (CartesianTrajectory3D in 3d): without a correction map, the reconstruction and the default simulation then use FFTs, which ignore the nodes

  • (circular::Bool=false) - true if the nodes cover a circular region of k-space, as in radial and spiral trajectories: the reconstructions "direct", "standard" and "multiCoil" then set the image outside a circle (a sphere in 3d) whose diameter is the largest side of the image to zero, and with a correction map, the encoding operator ignores the image outside it

source
MRIBase.acqTimePerProfile Method

acqTimePerProfile(tr::Trajectory) returns the acquisition time per profile of a trajectory

source
MRIBase.echoTime Method

echoTime(tr::Trajectory) returns the echo time of a trajectory

source
MRIBase.isCartesian Method

isCartesian(tr::Trajectory) returns whether the trajectory nodes lie on a cartesian grid

source
MRIBase.isCircular Method

isCircular(tr::Trajectory) returns whether the trajectory has circular k-space coverage

source
MRIBase.kspaceNodes Method

kspaceNodes(tr::Trajectory) returns the kspace sampling points of a trajectory

source
MRIBase.numProfiles Method

numProfiles(tr::Trajectory) returns the number of profiles of a trajectory

source
MRIBase.numSamplingPerProfile Method

numSamplingPerProfile(tr::Trajectory) returns the number of samples per profile of a trajectory

source
MRIBase.numSlices Method

numSlices(tr::Trajectory) returns the number of slices of a trajectory

source
MRIBase.readoutTimes Method

readoutTimes(tr::Trajectory) returns the readoutTimes for the sampling points of a trajectory

source
MRIBase.scale Method
julia
scale(tr::Trajectory, factor::Real)

returns a copy of tr with the nodes divided by factor

source
MRIBase.trajectory Method
julia
trajectory(::Type{T}, trajName::AbstractString, numProfiles::Int, numSamplingPerProfile::Int;
           numSlices::Int64=1, TE::AbstractFloat=0.0, AQ::AbstractFloat=1.e-3, kargs...) where T

is a factory method to construct a trajectory with element type T, for example Float64, from its name trajName

Arguments

  • T - element type of the nodes and times

  • trajName::AbstractString - name of the trajectory

  • numProfiles::Int - number of profiles

  • numSamplingPerProfile::Int - number of sampling points per profile

  • (numSlices::Int64=1) - number of slices (for 3d trajectories)

  • (TE::AbstractFloat=0.0) - echo time in s

  • (AQ::AbstractFloat=1.e-3) - readout duration in s (per profile)

  • kargs... - additional keyword arguments, passed on to the constructor of the trajectory

source

Predefined Trajectories ​

MRIBase.CartesianTrajectory Method
julia
CartesianTrajectory(T, numProfiles, numSamplingPerProfile
              ; TE::T=0.0
              , AQ::T=1.e-3
              , kmin=(-0.5,-0.5)
              , kmax=(0.5,0.5)
              , kargs...)

returns a 2d cartesian trajectory.

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::Float64=0.0) - echo time in s

  • (AQ::Float64=1.e-3) - readout duration in s (per profile)

  • (kmin=(-0.5,-0.5)) - minimum values of the covered k-space (for partial Fourier imaging)

  • (kmax=(0.5,0.5)) - maximum values of the covered k-space (for partial Fourier imaging)

source
MRIBase.EPITrajectory Method
julia
EPITrajectory(T, numProfiles, numSamplingPerProfile
              ; TE::T=0.0
              , AQ::T=1.e-3
              , EPI_factor::Int64=1
              , profileOffset= :equispaced
              , kargs...)

returns a 2d cartesian trajectory.

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::T=0.0) - echo time in s

  • (AQ::T=1.e-3) - readout duration in s (per profile)

  • (EPI_factor::Int64=1) - EPI factor, e.g. how many profiles to acquire per shot

  • (profileOffset= :equispaced) - equispaced or random ordering of the shots

source
MRIBase.RadialTrajectory Method
julia
RadialTrajectory(T, numProfiles, numSamplingPerProfile
              ; TE::T=0.0
              , AQ::T=1.e-3
              , angleOffset= :equispaced
              , kargs...)

returns a 2d radial trajectory.

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::T=0.0) - echo time in s

  • (AQ::T=1.e-3) - readout duration in s (per profile)

  • (angleOffset= :equispaced) - spacing of profile angles (:equispaced sampling, :golden angle sampling or :random sampling)

source
MRIBase.SpiralTrajectory Method
julia
SpiralTrajectory(T, numProfiles, numSamplingPerProfile
              ; TE::Float64=0.0
              , AQ::Float64=1.e-3
              , windings::Real= 6.25
              , kmax::Real=0.5
              , angleOffset::String="equispaced"
              , kargs...)

returns a 2d spiral trajectory.

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::Float64=0.0) - echo time in s

  • (AQ::Float64=1.e-3) - readout duration in s (per profile)

  • (windings::Real= 6.25) - number of windings of the spiral profiles

  • (kmax::Real=0.5) - distance of the last sample of each profile from the center of k-space

  • (angleOffset::String="equispaced") - spacing of profile angles ("equispaced" sampling, "golden" angle sampling or "random" sampling)

source
MRIBase.spiralDensity Method

Calculating the density using VoronoiCells

source
MRIBase.SpiralTrajectoryVarDens Method
julia
SpiralTrajectoryVarDens(T, numProfiles, numSamplingPerProfile
              ; TE::Float64=0.0
              , AQ::Float64=1.e-3
              , windings::Real= 6.25
              , alpha=2.0
              , kmax::Real=0.5
              , angleOffset::String="equispaced"
              , kargs...)

returns a 2d spiral trajectory with variable density

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::Float64=0.0) - echo time in s

  • (AQ::Float64=1.e-3) - readout duration in s (per profile)

  • (windings::Real= 6.25) - number of windings of the spiral profiles

  • (alpha=2.0) - exponent describing the evolution of the magnitude of the sampling points along the profiles

  • (kmax::Real=0.5) - distance of the last sample of each profile from the center of k-space

  • (angleOffset::String="equispaced") - spacing of profile angles ("equispaced" sampling, "golden" angle sampling or "random" sampling)

source
MRIBase.SpiralPerturbedTrajectory Method
julia
SpiralPerturbedTrajectory(T, numProfiles, numSamplingPerProfile
              ; TE::Float64=0.0
              , AQ::Float64=1.e-3
              , windings::Real= 6.25
              , alpha::Real=2.0
              , kmax::Real=0.5
              , angleOffset::String="equispaced"
              , kargs...)

returns a 2d spiral trajectory with variable density, whose radius at the k-th sample of each profile is that of SpiralTrajectoryVarDens with the same arguments times (1 + 0.025 cos(0.1 k)) (kmax - 0.025) / kmax. Each coordinate is limited to the interval [-0.5, 0.5), which changes the nodes only for kmax above about 0.51.

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::Float64=0.0) - echo time in s

  • (AQ::Float64=1.e-3) - readout duration in s (per profile)

  • (windings::Real= 6.25) - number of windings of the spiral profiles

  • (alpha::Real=2.0) - exponent describing the evolution of the magnitude of the sampling points along the profiles

  • (kmax::Real=0.5) - the sampling points lie within this distance from the center of k-space

  • (angleOffset::String="equispaced") - spacing of profile angles ("equispaced" sampling, "golden" angle sampling or "random" sampling)

source
MRIBase.CartesianTrajectory3D Method
julia
CartesianTrajectory3D(T, numProfiles, numSamplingPerProfile
              ; TE::Float64=0.0
              , AQ::Float64=1.e-3
              , numSlices=1
              , kargs...)

returns a 3d cartesian trajectory.

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::Float64=0.0) - echo time in s

  • (AQ::Float64=1.e-3) - readout duration in s (per profile)

  • (numSlices=1) - number of slices

source
MRIBase.KooshballTrajectory Method
julia
KooshballTrajectory(T, numProfiles, numSamplingPerProfile
              ; TE::Float64=0.0
              , AQ::Float64=1.e-3
              , kargs...)

returns a 3d kooshball trajectory.

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::Float64=0.0) - echo time in s

  • (AQ::Float64=1.e-3) - readout duration in s (per profile)

source
MRIBase.StackOfStarsTrajectory Method
julia
StackOfStarsTrajectory(T, numProfiles, numSamplingPerProfile
              ; TE::Float64=0.0
              , AQ::Float64=1.e-3
              , numSlices=1
              , angleOffset= :equispaced
              , kargs...)

returns a 2d radial trajectory.

Arguments

  • numProfiles::Int64 - number of profiles

  • numSamplingPerProfile::Int64 - number of sampling points per profile

  • (TE::Float64=0.0) - echo time in s

  • (AQ::Float64=1.e-3) - readout duration in s (per profile)

  • (numSlices=1) - number of slices

  • (angleOffset= :equispaced) - spacing of profile angles (:equispaced sampling, :golden angle sampling or :random sampling)

source