MRecon Methods¶

Activate (Static)¶

Activates MRecon with an activation token (see Licensing and Activation)

>> MRecon.Activate(<token>)

AddPath (Static)¶

Adds all subdirectories of the MRecon installation folder to the Matlab path

>> MRecon.AddPath

Anonymize (Static)¶

Anonymizes the rawfile given as input.

>> MRecon.Anonymize(rawfile, pars2anonymize, user_def_values)

Description/Algorithm: A list of parameters which will be anonymized can be gotten with the GetPars2Anonymize function. A user defined list can be passed as input to anonymize a different set of parameters. Furthermore user defined values can be specified for each parameter. The values needs to be passed as struct, where the field name corresponds to the parameter name and the field value to the value after anonymization.

Warning

For implementation reasons the user defined values will be cropped/padded to the length of the original value.

Examples:

anonymize a rawfile:

>> MRecon.Anonymize('MyRawfile.raw');

anonymize a rawfile but keep the patients birth date:

>> pars2anonymize = MRecon.GetPars2Anonymize;
>> pars2anonymize{18:19} = []
>> MRecon.Anonymize('MyRawfile.raw', pars2anonymize);

anonymize a rawfile and specify a user defined patient name and institution name

>> user_def_values.RFR_PATIENT_DICOM_PATIENT_NAME = 'Martin';
>> user_def_values.RFR_SERIES_DICOM_INSTITUTION_NAME = 'GyroTools'
>> MRecon.Anonymize('MyRawfile.raw', [], user_def_values);

Average¶

Averages the data in the 12th dimension of the data array.

>> r.Average;

Location: k-space | image-space

Formats: Raw | ExportedRaw

Description/Algorithm: This function averages the data in the 12th dimension of the data array (where the different averages are stored). This function only has an effect if immediate averaging is disabled (r.Parameter.Recon.ImmediateAveraging). If immediate averaging is enabled, then the data is averaged in the SortData function already. Some data, however should not be averaged in k-space (e.g. diffusion scans). That is why this function is called in image space to average the remaining averages which have not been processed yet.

Notes: For diffusion scans only the magnitude is averaged.

BasicCorrections¶

Averages the data in the 12th dimension of the data array.

>> r.BasicCorrections;

Location: k-space | image-space

Formats: Raw | ExportedRaw

Description/Algorithm: Will perform the basic corrections which are necessary in order to reconstruct an artifact free image. Calling this function is identical to:

>> r.NonLinearityCorrection;
>> r.RandomPhaseCorrection;
>> r.RemoveOversampling;
>> r.PDACorrection;
>> r.DcOffsetCorrection;
>> r.MeasPhaseCorrection;

CheckForUpdates (Static)¶

Checks if there is an update available for MRecon

>> MRecon.CheckForUpdates

CheckoutLicense (Static)¶

From time to time MRecon connects to the license server and renews the license key. In order to do that an internet connection must be available. Periods without an internet connection are usually not a problem, since one can stay offline up to 2 weeks with a valid license key. However for longer periods without internet, one can checkout the license for a given number of days. The license can be checkout up to 30 days. Please note that your license will be locked for that period of time. It cannot be modified or transferred to another computer.

>> MRecon.CheckoutLicense(days)

CombineCoils¶

Combines the individual coil images into one single image. Several combination methods have been implemented in MRecon (see below).

>> r.CombineCoils

Recon Flag: Parameter.ReconFlags.iscombined

Location: Image-space.

Formats: Raw | ExportedRaw | Cpx | Bruker

Notes:

For a non-phase-contrast scan the image phase is lost after CombineCoils. If you want to preserve the phase please perform a SENSE/CLEAR reconstruction see the SENSEUnfold function.
The CombineCoils function destroys the label lookup table (Parameter.LabelLookupTable) since the profiles cannot be related to the labels after combining the coils.
The coils have to be in the 4th dimension of the Data array to be combined.

Compare¶

Compares to MRecon classes and displays the differences

>> r.Compare( other );

Formats: All

Description/Algorithm: The compare function iterates through all the parameters values of the MRecon class and compares them with the values of another reconstruction object.

Examples: To compare the current reconstruction object (r) with another one (r1) call:

>> r.Compare(r1)

ConcomitantFieldCorrection¶

Performs a concomitant field correction on the current data.

>> r.ConcomitantFieldCorrection;

Recon Flag: Parameter.ReconFlags.isconcomcorrected

Location: Image-space.

Formats: Raw

Description/Algorithm: Maxwell’s equations imply that imaging gradients are accompanied by higher order spatially varying fields (concomitant fields) that can cause artifacts in MR imaging. The lowest order concomitant fields depend quadratically on the imaging gradient amplitude and inversely on the static field strength. On the scanner these extra magnetic fields are expressed along the directions of the physical gradients (scanner fixed xyz-coordinate system). Therefore the images have to be transformed into that system before the correction. The correction itself adds a quadratic phase to the images defined by the correction parameters.

Notes:

The concomitant field correction will not work on data measured without the ReconFrame patch.
The concomitant field correction is only executed for phase contrast flow scans. Only then correction parameters are provided by the scanner.

Copy¶

Copies the MRecon object

>> r.Copy( other );

Formats: All

Description/Algorithm: This function will perform a deep copy of the MRecon object

Examples: To copy the current reconstruction object (r) to another one (r1) call:

>> r.Copy(r1)

Notes: The MRecon object is derived from the “handle” class, meaning that an assignment does NOT copy the object. Assigning one object to another simply creates a new reference:

>> r = MRecon('rawfile.raw');
>> r1 = r;      % r1 and r is the same object! Changing r1 will change r.
>> r.Copy(r2)   % r2 is a copy of r. Changing r2 will not change r

For more information on handle classes see: https://www.mathworks.com/help/matlab/handle-classes.html

CreateVideo¶

Creates a video from reconstructed images stored in the MRecon object

>> CreateVideo(Dimension, Filename, Framerate, OutputFormat, StartFrame, EndFrame );

Inputs:

Dimension: Dimension of the Data array over which the video is generated. Default = 5 (dynamics)

Filename: Name of the output video file. Default = generated from parameters

Framerate: Desired framerate of the output video (frames/s). Default = 15

OutputFormat: The output format(‘avi’ or ‘gif’). Default = ‘avi’

StartFrame: First frame of the video. Default = 1

EndFrame: Last frame of the video. Default = nr_images

Formats: All

Notes: Animated .gifs with framerates higher than approx. 15 fps are not played at the right speed with some video player (e.g. Microsoft Power Point). Use .avi format for higher framerates.

Doc (Static)¶

Opens the MRecon documentation in the web-browser

>> MRecon.Doc

DivideFlowSegments¶

Calculates the flow phase image by dividing the flow encoded segments by the non-flow encoded segment. In case of Hadamard encoding it will perform a Hadamard reconstruction.

>> r.DivideFlowSegments;

Recon Flag: Parameter.ReconFlags.isdcoffsetcorr

Location: k-space (before the partial Fourier reconstruction)

Formats: Raw

Description/Algorithm: In flow acquisitions multiple flow segments are acquired, either with negative and positive flow encoding (symmetric) or with flow and no flow encoding (asymmetric). To obtain the quantitative flow values a phase image proportional to the flow is calculated, by dividing the flow encoded segments by the non-flow encoded segment. In case of Hadamard encoding DivideFlowSegments will perform a Hadamard reconstruction. The phase values in the divided image reach from -pi-pi corresponding to flow values from 0-venc.

Notes: The flow segments are stored in the 10^th dimension of the Data array.

DcOffsetCorr¶

Corrects for a signal offset that might occur in the acquired samples.

>> r.DcOffsetCorrection;

Recon Flag: Parameter.ReconFlags.isdcoffsetcorr

Location: k-space (before the partial Fourier reconstruction)

Formats: Raw

Description/Algorithm: Acquired raw samples can sometimes exhibit a signal offset originating from hardware inaccuracies of the receiver. If not corrected this offset can cause an artifact which will appear as bright signal peak in the middle of the image. Since noise in the MR signal is normally distributed with a mean of zero, the offset can be calculated by calculating the mean of the noise samples. Therefore if the raw data contains noise samples (from a noise acquisition prior to the scan), these samples are read and the mean is calculated. If the data does not contain any noise, the offset is calculated from the noise like outer k-space positions. After calculating the offset it is subtracted from the data.

Notes: The offset is calculated separately for every channel.

EPIPhaseCorrection¶

Performs the EPI correction to correct for the FOV/2 ghost originating from eddy current effects.

>> r.EPIPhaseCorrection;

Recon Flag: Parameter.ReconFlags.isdepicorr

Location: Between FFT in readout and phase encoding direction.

Formats: Raw | ExportedRaw | Bruker

Description/Algorithm: In EPI imaging multiple k-space lines are acquired after a single excitation of the imaging volume. This is achieved by inverting the readout gradient after every acquired profile and thus sampling the k-space in a forward-backward fashion. Due to eddy current effects however, the positive readout gradients (forward sampling) is not exactly the same as the negative gradient (backward sampling), which results in a temporal shift between the forward and backward sampled profiles. After fourier transformation this shift results in a ghost like artifact located at half of the FOV.

To correct for this effect EPI correction profiles are acquired prior to every scan. The correction profiles consist of a full EPI shot, but acquired without phase encoding blips, therefore sampling the central k-space line multiple times. Since these profiles should be identical (apart from relaxation effects), the temporal shift, caused by eddy current effects of the readout gradients, can be calculated. A temporal shift in k-space corresponds to a linear phase in image space. Therefore the correction profiles are first transferred into image space and the phase difference between two subsequent profiles is calculated. The phase difference is then linearly fitted and the linear phase is added to every odd (or even) profile, thus realigning them in k-space.

Optionally a nonlinear correction can be enabled via Parameter.Recon.EPICorrectionMethod. In the nonlinear correction the calculated linear phase is subtracted from the original phase difference. The remaining part is then smoothed and added to the linear phase.

Optionally an image based correction can be enabled via Parameter.Recon.EPI2DCorr. This correction tries to improve the images further by minimizing the amount of ghosts in the image. Thereby the offsets found by the regular EPI crrection are slighly modified and the amount of ghosts in the resulting images is quantified, to find the optimal correction value.

Notes:

Every coil has its own EPI correction parameters.

The x-axis for the linear fit is given by: x = -floor(n/2):ceil(n/2)-1; where n is the number of samples in the correction profiles.

The linear fit is weighted by the magnitude of the correction profiles (points with a high magnitude value are weighted higher in the fit)

The EPI correction profiles are labeled as data type 3 and can be read by setting: r.Parameter.Parameter2Read.typ = 3, followed by r.ReadData.

Examples: The user has the possibility to specify own correction parameters and pass them to the function. To do that Parameter.EPICorrData must be filled:

Every coil has its own slope and offset. To identify the coil we must label them in the correction parameter:

>> r.Parameter.EPICorrData.coil = r.Parameter.Parameter2Read.chan;

Assign the same slope for all the coils:

>> r.Parameter.EPICorrData.slope = 0.1;

Assign a different offset for every coil (4 coils in this example):

>> r.Parameter.EPICorrData.offset = [0, 0.2, 0.4, 0.6];

Call the EPI correction:

>> r.EPIPhaseCorrection;

ExportLabels¶

Exports the imaging labels, which are stored in the .lab file to a textfile

>> r.ExportLabels( filename );

Location: k-space, image-space.

Formats: Raw | ExportedRaw | Bruker

Description/Algorithm: This function exports the imaging labels, which were sent from the spectrometer to the reconstructor, to a textfile. Every row in the file corresponds to an measured k-space line in the order they have been acquired. Exporting the labels is useful to get an overview over the sampling order for example.

Notes: The format of the textfile is virtually identical to the one of the .list file of the exported raw data format.

FlowPhaseCorrection¶

Exports the imaging labels, which are stored in the .lab file to a textfile

>> r.FlowPhaseCorrection;

Location: image-space.

Formats: Raw | ExportedRaw | Bruker

Description/Algorithm: The flow phase correction removes an offset on the flow phase which is introduced by eddy-current effects. The function performs a 3^rd order fit on the static tissue in the phase images. The result of the fit is then subtracted from the phase. For more information see: Busch J, Giese D, Kozerke S. Image-based background phase error correction in 4D flow MRI revisited. J Magn Reson Imaging. 2017;46:1516-1525

GeometryCorrection¶

Corrects for gradient non-linearity’s over large FOV’s

>> r.GeometryCorrection;

Recon Flag: Parameter.ReconFlags.isgeocorrected

Location: Image-space.

Formats: Raw

Description/Algorithm: Imaging gradients are not perfectly linear over the whole possible FOV. The further away we are from the isocenter the stronger the non-linear effects become, which will result in a slight distortion of the resulting image. This effect is corrected with the correction parameters provided by the scanner.

Notes: The correction parameters are scanner specific and vary with the gradient system.

GeometryCorrectionFromSinfile (Static)¶

Performs a geometry correction on the data given as input with the parameters from the sin file

>> MRecon.GeometryCorrectionFromSinfile(data, sinfile, options)

Options:

‘patient_position’:
specifies the patient position. If not given as input then head-first-supine is assumed. The possible patient positions are:
HFS: Head-first supine

HFP: Head-first prone

HFR: Head-first right

HFL: Head-first left

FFS: Feet-first supine

FFP: Feet-first prone

FFR: Feet-first right

FFL: Feet-first left

Formats: Raw

Description/Algorithm: A gradient non-linearity correction is performed on the data given as input with the parameters from the sin file. Please note that the images should already be in the correct radiological display orientation (e.g. for transversal slice orientation A is at the top of the image and L is to the right.)

Examples:

>> corrected_data = MRecon.GeometryCorrectionFromSinfile(data, 'my_sinfile.sin', 'patient_position', 'HFR');

GeometryCorrectionUserDef (Static)¶

Performs a geometry correction on the input data with user defined geometry parameters

>> corrected_data = MRecon.GeometryCorrectionUserDef(data, angulation_midslice, offcentre_midslice, patient_position, orientation, resolutionMPS, sCoeffY, cCoeffX, cCoeffZ, r0)

Inputs:

data
Data to be geometry corrected. The dimension order must be the same as in the MRecon Data array (see MRdata)
angulation_midslice:
Angulation for the center slice
offcentre_midslice:
Offcentre for the center slice
patient_position:
Patient position [HFS, HFP, HFR, HFL, FFS, FFP, FFR, FFL]
orientation:
Slice orientation [TRA, SAG, COR]
resolutionMPS:
Resolution of the data in mm along the M-P-S axis
sCoeffY:
Geometry correction coefficients for the Y gradient (matrix with size 12x14)
cCoeffX:
Geometry correction coefficients for the X gradient (matrix with size 12x14)
cCoeffZ:
Geometry correction coefficients for the Z gradient (vector with 16 elements)
r0:
Geometry correction reference radius

Formats: Raw

Description/Algorithm: A gradient non-linearity correction is performed on the data given as input with user defined geometry parameters Please note that the data should already be in the correct radiological display orientation (e.g. for transversal slice orientation A is at the top of the image and L is to the right.)

Examples:

>> sinfile = 'MySinfile.sin';
>> [sCoeffY, cCoeffX, cCoeffZ, r0] = MRecon.GetGeoCorrCoeffsFromSinfile(sinfile);
>> data = zeros(128,128,128);
>> data(:, [1:10:128], :) = 1;
>> corrected_data = MRecon.GeometryCorrectionUserDef(data, [0,0,0], [0, 13.5, -17.24], 'HFS', 'TRA', [3,3,2], sCoeffY, cCoeffX, cCoeffZ, r0);

GetGeoCorrCoeffsFromSinfile (Static)¶

Reads the coefficients needed for a geometry correction from the sinfile

>> [sCoeffY, cCoeffX, cCoeffZ, r0] = MRecon.GetGeoCorrCoeffsFromSinfile(sinfile)

Examples:

>> sinfile = 'MySinfile.sin';
>> [sCoeffY, cCoeffX, cCoeffZ, r0] = MRecon.GetGeoCorrCoeffsFromSinfile(sinfile);

GetMemoryInformation¶

Obtains information about the available memory on the current machine and how much memory is expected to be used during the reconstruction.

>> [MemoryNeeded, MemoryAvailable, MaxDataSize] = r.GetMemoryInformation;

Formats: All

Example:

>> [MemoryNeeded, MemoryAvailable, MaxDataSize] = r.GetMemoryInformation

MemoryNeeded =

   1.3023e+09

MemoryAvailable =

   1.6050e+10

MaxDataSize =

   566231040

GetPars2Anonymize (Static)¶

Returns a list of parameter names with will be anoynmized when the “Anonymize” function is called

>> pars = MRecon.GetPars2Anonymize(<token>)

GridData¶

GridData: Grids k-space data on a predefined trajectory.

>> r.GridData

Recon Flag: Parameter.ReconFlags.isgridded

Location: k-space after SortData.

Formats: Raw | ExportedRaw

Description/Algorithm: The fast fourier transform (FFT) requires the data to be on a regular cartesian grid. Therefore in order to use the FFT on non-cartesian data such as radial or spiral acquistions, we have to grid the k-space data from the nominal trajectory to a cartesian grid. There are several predefined trajectories already built-in into MRecon, including: 2D-radial, 3D-stack of radials, 3D-kooshball, 2D/3D spiral, EPI ramp sampling. On the other side, user defined trajectories can easily be defined by setting the Gridder Parameters. Please see the example below on how to do that. If the Gridder Parameters are not set manually MRecon automatically detects the type of the scan and decides if it should be gridded or not.

Notes:

For non-cartesian scans the zero-filling process in k-space and oversampling removal is automatically performed during gridding, by chosing the grid appropriately. See example 3)
The Gridder parameter can also be filled using the GridderCalculateTrajectory function.

Examples:

1) Reconstruct a golden angle radial acquisition by changing the radial angles in the gridder parameters:

Golden angle scans exhibit a radial angle increment of 111.246°, whilethe rest is exactly the same as a “normal” radial trajectory. Therefore all we have to do to reconstruct a golden angle scan is to change the radial angles in the gridder parameter:

Create a new reconstruction object with a golden angle scan:

>> r = MRecon('golden_angle_scan.raw');

Calculate the total number of phase encoding profiles:

>> nr_profs = r.Parameter.Scan.Samples(2) * r.Parameter.Scan.Samples(3)

Set the radial angles to an increment of 111.246°

>> r.Parameter.Gridder.RadialAngles = 0:pi/180*111.246:(nr_profs-1)*pi/180*111.246;

Perform the recon

>> r.Perform;

2) Define a completely new trajectory and weights

In this example we mirror the final image in readout direction by gridding a cartesian scan to a inverted kx trajectory. To do that we define a completely new trajectory and pass it to the gridder parameters:

Create a new reconstruction object using a cartesian scan:

>> r = MRecon('cartesian.raw');

Obtain the number of samples in every direction:

>> no_kx_samples = r.Parameter.Scan.Samples(1);
>> no_ky_samples = r.Parameter.Scan.Samples(2);
>> no_kz_samples = r.Parameter.Scan.Samples(3);

Create a regular cartesian grid. These are the sampled k-space coordinates of a cartesian scan. By definition the k-space coordinates of a sampled trajectory are in the range of -floor(n/2):ceil(n/2)-1, where n is the number of samples:

>> [kx,ky,kz] = ndgrid( -floor(no_kx_samples / 2):ceil( no_kx_samples/2)-1, -floor(no_ky_samples / 2):ceil( no_ky_samples /2)-1, -floor(no_kz_samples / 2):ceil( no_kz_samples /2)-1 );

Modify the k-space grid by inverting the readout direction:

>> kx_inverted = -kx;

Create the modified k-space. These are the coordinates we grid on. By definition the coordinates must be of dimension: no_samples x no_y_profiles x no_z_profiles x 3 (See Gridder Parameters for more information):

>> k = cat( 4, kx\_inverted, ky, kz );

Assign the new trajectory to the Gridder:

>> r.Parameter.Gridder.Kpos = k;

Assign gridder weights (sampling density). In this example the samples are uniformly distributed on the whoe k-space (all weights are set to 1):

>> r.Parameter.Gridder.Weights = ones(no_kx_samples, no_ky_samples, no_kz_samples);

Perform the reconstruction:

>> r.Perform;

Show the data. Observe that the image is flipped in readout direction compared to the ungridded reconstruction (a flip in k-space corresponds to a flip in image-space):

>> r.ShowData;

3) Gridder and matrix sizes:

Oversampling:

During the gridding process we have the possibility to sample on an arbitrary grid. This means that we can for example sample on a finer or coarser grid than the acquired one, which corresponds to add or remove oversampling and therefore changing the FOV in the reconstructed image. The parameter which specifies the amount of oversampling introduced by the gridder is Parameter.Gridder.GridOvsFactor. For example if we set:

>> r.Parameter.Gridder.GridOvsFactor = 2;

then we grid to half the sampled k-space distance and therefore to twice the FOV. A value smaller than 1 corresponds to a coarser grid than acquired and therefore a smaller FOV.

In radial scans the acquired oversampling factor in readout direction is always 2 (hardcoded in the pulse programming environment). However If we check the oversampling factor in r.Parameter.Encoding.KxOversampling we can usually find a value like 1.25. This is the oversampling factor AFTER gridder, which means that we should set:

>> r.Parameter.Gridder.GridOvsFactor = r.Parameter.Encoding.KxOversampling / 2;

This is done automatically done for radial scans, and means that we grid to a coarser grid leaving an oversampling factor of 1.25.

Zero Filling:

Apart from gridding on a finer grid we also have the possibility to grid on a larger/smaller k-space and therefore changing the resolution of the scan. Gridding to a larger k-space means that we perform zero filling whlie gridding to a smaller one is reducing the resolution of the scan. The parameter which specifies the size of the k-space to be gridded on is: Parameter.Gridder.OutputMatrixSize.

The output size is the matrix size after gridding. Lets assume we have a radial scan with 256 acquired samples. If we set:

>> r.Parameter.Gridder.GridOvsFactor = 1;
>> r.Parameter.Gridder.OutputMatrixSize = [512,512,1];

The the output matrix has the size 512x512 which means that we have zero filled the 256x256 sampled k-space to that value. However if we set:

>> r.Parameter.Gridder.GridOvsFactor = 2;
>> r.Parameter.Gridder.OutputMatrixSize = [512,512,1];

Then we have gridded it to a grid twice as fine but NOT zero-filled. To zero-fill and oversample we have to set:

>> r.Parameter.Gridder.GridOvsFactor = 2;
>> r.Parameter.Gridder.OutputMatrixSize = [1024,1024,1];

Summary:

For radial scans the zero filling and oversampling removal usually takes place directly in the gridder. Below is an example from a real radial experiment:

Number of acquired samples: 464 (oversampling factor = 2)
r.Parameter.Encoding.KxOversampling = 1.25
r.Parameter.Encoding.XRes = 240

–> Matrix size after gridding = 240 * 1.25 = 300

–> Gridding oversampling = 1.25 / 2 = 0.625

–> Set gridder parameters to:

>> r.Parameter.Gridder.GridOvsFactor = 0.625;
>> r.Parameter.Gridder.OutputMatrixSize = [300,300,1];

GridderCalculateTrajectory¶

Calculated the gridder trajectory for the current scan and fills the gridder parameter

>> r.GridderCalculateTrajectory

Location: k-space after SortData.

Formats: Raw | ExportedRaw

Description/Algorithm: When the gridder parameter are not defined by the user, they are calculated internally and will not be visible or changeable. If one wants to observe or change the gridding parameter, this function can be called which calculates the trajectory for the gridding process and fills the gridder parameter accordingly. The function can be called for any preset scan (radial, spiral, EPI), before calling the GridData function. This is useful if the user wants to modify a preset trajectory without calculating it by himself. To do so one would call this function, modify the gridder parameter followed by the call of GridData.

GridderNormalization¶

Corrects for the signal weighting in image-space originating from the convolution with a bessel kernel in the gridding process.

>> r.GridderNormalization

Location: Image-space.

Formats: Raw | ExportedRaw

Description/Algorithm: Gridding is essentially a convolution with a bessel kernel in k-space. In image-space this corresponds to a multiplication with the fourier transform of the bessel-kernel leaving a signal weighing on the reconstructed image. This function corrects for that by dividing the image by the fourier-transform of the bessel kernel.

I2K¶

Performs a fourier transformation from image-space to k-space

>> r.I2K

Recon Flag: Parameter.ReconFlags.isimspace

Location: Image-Space

Formats: Raw | ExportedRaw | Cpx | Rec | Bruker

Description/Algorithm: I2K first checks which dimensions should be transformed, defined in Parameter.Encoding.FFTDims. Afterwards it checks which of these dimensions are in image-space and then only transforms these ones. The fourier transformation along one dimension is given by:

kspace = 1/sqrt(n)\*fftshift(fft(ifftshift(img,dim),[],dim),dim);

where n are the number of samples along the specific dimension.

K2I¶

Performs a fourier transformation from k-space to image-space

>> r.K2I

Recon Flag: Parameter.ReconFlags.isimspace

Location: k-space

Formats: Raw | ExportedRaw | Cpx | Rec | Bruker

Description/Algorithm: K2I first checks which dimensions should be transformed, defined in Parameter.Encoding.FFTDims. Afterwards it checks which of these dimensions are in k-space and then only transforms these ones. The fourier transformation along one dimension is given by:

img = sqrt(n.\*fftshift(ifft(ifftshift(kspace,dim),[],dim),dim);

where n are the number of samples along the specific dimension.

After the fourier transform from k- to image-space, the images are shifted in image-space as defined in Parameter.Encoding.X/Y/ZRange. Thereby the images are shifted by the amount which leads to a symmetric range around 0. E.g. if the range is given as [-42, 21] then the image is shifted by 10 pixel to the right. ( [-42, 21] + 10 = [-32, 31] )

K2IM¶

Performs a fourier transformation from k-space to image-space in measurement direction. See K2I for more information.

K2IP¶

Performs a fourier transformation from k-space to image-space in phase encoding directions direction. See K2I for more information.

LicenseInfo (Static)¶

Displays information about the license

>> MRecon.LicenseInfo

MeasPhaseCorrection¶

Corrects for an offset phase which might have been added to certain profiles

>> r.MeasPhaseCorrection

Recon Flag: Parameter.ReconFlags.ismeasphasecorr

Location: k-space

Formats: Raw

Description/Algorithm: Different profiles can sometimes exhibit a phase shift, which originates from either the RF pulse phase or the acquistion phase specified in the AQ object. Different averages for example are usually acquired with a phase difference of pi between them. If we wouldn’t correct for this phase then the signal would effectively cancel out when summing up the averages. MeasPhaseCorrection therefore corrects for this possible phase shift using the values in the labels, received by the scanner.

Let mi be the measurement phase of the i-th profile:

mi = Parameter.Labels.Index.meas_phase(i);

then the phase added to that profile is given by:

phase = -mi * pi/2

NonLinearityCorrection¶

Corrects for receiver channel non-linearities

>> r.NonLinearityCorrection

Recon Flag: Parameter.ReconFlags.isnonlincorr

Location: k-space

Formats: Raw

Description/Algorithm: During the preparation phase the scanner sends channel non-linearity information to the reconstructor. This function corrects for these non-linearities.

PDACorrection¶

Corrects the profile dependent amplification (PDA)

>> r.PDACorrection

Recon Flag: Parameter.ReconFlags.ispdacorr

Location: k-space

Formats: Raw

Description/Algorithm: In some cases the receiver weights certain k-space profiles differently than others. In 3D imaging for example the outer k-space lines are amplified compared to the central ones, to ensure a sufficient signal range. Of course the amplification has to be corrected in reconstruction, if not the edges in the image would be enhanced. The amplification factors are provided by the scanner and this function simply divides the profiles by them.

PartialFourier¶

Performs a partial fourier reconstruction (homodyne method).

>> r.PartialFourier

Recon Flag: Parameter.ReconFlags.ispartialfourier

Location: k-space | image-space

Formats: Raw | ExportedRaw | Bruker

Description/Algorithm: In partial fourier imaging only a fraction of k-space is acquired for improved scan- or echo-time. If the k-space is partly sampled in readout direction we speak of partial echo and halfscan for a partly sampled space in phase encoding direction. In the first case the echo time is reduced while in the second one the scantime is shortened. Performing a standard imaging reconstruction on the partly sampled k-space however leads to image bluring and reduced SNR. Therefore a partial fourier reconstruction is performed which utilizes the k-space symmetry to reconstruct images of better quality. In MRecon a so called homodyne reconstruction is implemented: Noll, D.C.; Nishimura, D.G.; Macovski, A.; “Homodyne detection in magnetic resonance imaging” Medical Imaging, IEEE Transactions on, vol.10, no.2, pp.154-163, Jun 1991.

Notes: In principle the partial fourier reconstruction can either be performed in k- or image space. However if executed in k-space it is not possible to perform a SENSE or CLEAR reconstruction afterwards since the phase information will be lost. Therefore we suggest to execute it in image space after SENSEUnfold which works in any case.

Perform¶

Performs a complete reconstruction for imaging. Only standard data (typ = 1) is read and reconstructed. Furthermore if not enough memory is available the data is reconstructed in chunks of: x-y-z-coils. The complete code for this function can be found earlier in this manual or in the file StandardRecon.m in the example directory.

RandomPhaseCorrection¶

Corrects for the random phase which is added to the measured profiles

>> r.RandomPhaseCorrection

Recon Flag: Parameter.ReconFlags.israndphasecorr

Location: k-space

Formats: Raw

Description/Algorithm: The receiver adds a random phase to every acquired profile to reduce artifacts. This random phase has to be subtracted in reconstruction since the phase is used for spatial encoding. The added phase is stored in the profile labels and the phase which is subtracted is given by:

Let ri be the random phase label of the i-th profile:

ri = Parameter.Labels.Index.meas_phase(i);

then the phase subtracted to that profile is given by:

phase = 2*pi / double( intmax('uint16') ) * ri;

ReadChunk¶

Reads a data chunk of a user defined size

>> r.ReadChunk('reset', <true, false>, 'size', <size_in_MB>, 'typ', <image_type>

Recon Flag: Parameter.ReconFlags.isread

Location: Beginning of recon

Formats: Raw | ExportedRaw

Description/Algorithm: The ReadChunk function reads a data chunk of a user defined size from the selected file. The data is stored in the Data property of the MRecon object. Subsequent calls will read the next chunk from the rawfile. When ‘reset’ is true then the function rewinds the rawfile and starts reading from the beginning. When the specified size is larger than the rawfile, the entire file will be read.

Examples: Read the imaging data in chunks of 10MB:

>> r = MRecon( 'rawfile.raw' );
>> r.ReadChunk('size', 10);     % Reads 10 MB of data from the rawfile and stores it in r.Data
>> r.ReadChunk('size', 10);     % Reads the next 10MB
>> r.ReadChunk('reset', true, 'size', 10);    % Rewinds the file and reads the first 10MB again

ReadData¶

Reads all supported data formats into Matlab.

>> r.ReadData

Recon Flag: Parameter.ReconFlags.isread

Location: Beginning of recon

Formats: Raw | ExportedRaw | Cpx | Rec | Bruker

Description/Algorithm: The ReadData function reads the MR data from the selected file and stores it into Matlab. The function supports selective reading, meaning that the user can specify what data should be read via r.Parameter.Parameter2Read. After calling the ReadData function, the data is stored in the order it was saved in the data file. This means that for raw data we obtain a matrix containing the individual k-space profiles in the order they have been measured. For Rec and Cpx data however we obtain (partly) reconstructed images in image-space. Generally the data is stored in a cell array where the different rows hold different data types (e.g. imaging data, correction data, noise data etc) and the columns different data sizes (e.g. kt-undersampled and training data). The number of rows in the cell array is predefined while the number of columns varies depending on the data in the file.

Examples: Read only imaging data from the first coil and the third dynamic:

>> r = MRecon( 'rawfile.raw' );
>> r.Parameter.Parameter2Read.typ = 1; % Imaging data
>> r.Parameter.Parameter2Read.chan = 0; % First coil
>> r.Parameter.Parameter2Read.dyn = 2; % Third dynamic
>> r.ReadData;

Read the noise samples from a raw file:

>> r = MRecon( 'rawfile.raw' );
>> r.Parameter.Parameter2Read.typ = 5; % Noise data
>> r.ReadData;

For simplicity the image type can also be specified as input in the ReadData function:

>> r = MRecon( 'rawfile.raw' );
>> r.ReadData(5);  % Noise data

RemoveOversampling¶

Removes the oversampling from the image by cropping the data in image-space

>> r.RemoveOversampling

Recon Flag: Parameter.ReconFlags.isoversampled

Location: k-space | Image-space.

Formats: Raw | ExportedRaw | Cpx | Bruker

Description/Algorithm: Generally the receiver samples data denser in readout direction than specified in the user interface. The denser sampling produces a larger field-of view (FOV) and prevents fold-over artifacts in readout direction. Oversampling in readout direction does not increase the scan time as the receiver can sample at a much higher frequency than desired. In 3D acquisitions the data is usually oversampled in slice encoding direction as well to correct for improper slice excitation of the outer slices. Oversamlling in slice encoding direction does affect the scan time however. Since the denser sampling basically results in the acquisiton of a larger FOV we have to remove the oversampling by cropping the image in image-space and thereby preserving the signal-to-noise ratio (SNR). Removing the oversampling in k-space would not be beneficial as we would lose SNR. In MRecon the RemoveOversampling can be called at three different locations:

1) Before SortData: The oversampling is only removed in readout direction by fourier transforming the data in that direction and cropping it. This is usually done to reduce the amount of data and save memory.

2) After SortData: The oversampling is removed in all directions by fourier transforming the data in every oversampled direction and cropping it in image space.

3) In image-space: The oversampling is removed in all directions by cropping the data.

Notes: The oversampling is not removed for data which has to be gridded when called before SortData (radial, spiral, EPI).

RenewLicense (Static)¶

Renews the license key. When called MRecon fetches a new license key from the server which is valid for 2 weeks. Normally there is no need to call this function since MRecon renews the license key automatically in regular time intervals.

>> MRecon.RenewLicense

RingingFilter¶

Removes ringing artifacts by applying a hamming filter on the k-space data

>> r.RingingFilter

Location: k-space

Formats: Raw | ExportedRaw

Description/Algorithm: Sharp edges in k-space can result in ringing artifacts in image-space. Such edges are introduced by zero-filling or by sampling a low resultion image. The ringing filter tries the soften the edges by applying a hamming filter on the k-space data, lowering the values on the edge. The amount by which the edge-values are lowered is specified by the filter strength. A filter strength of 0.5 for example will bring down the edge value by 50%. A strength of brings the value down to 0 and therefore removing the edges completely. However a large filter strength might cause image blurring. Therefore it is important to find an optimal compromise between artifact removal and image blurring. The default filter strength is set to 0.25.

Notes: The ringing filter should be applied before k-space zero filling to work effectively.

RotateImage¶

Rotates the images such that they are oriented in the same way as on the scanner console.

>> r.RotateImage

Recon Flag: Parameter.ReconFlags.isrotated

Location: Image-space

Formats: Raw

Description/Algorithm: After reading the raw data it is oriented in The MPS system, meaning that the rows in the Data matrix are aligned along the measurement direction and the columns along the phase encoding direction. The MPS system however heavily depends on the chosen scan parameters, such as orientation, fold-over direction, fat shift direction etc. The reconstructed images, displayed on the scanner console on the other hand are oriented in a well-defined fashion expressed in the patient coordinate system (right-left (RL), anterior-posterior (AP), feet-head (FH) ). The RotateImage function transforms the Data from the current coordinate system (usually MPS) the final orientation displayed on the scanner console.

Examples: The Rotate Image basically performs a transformation between the system specified in r.Parameter.Scan.ijk and r.Parameter.Scan.REC. These coordinates systems are always expressed in the patient system (RL, AP, FH). Let’s assume these values are given as:

r.Parameter.Scan.ijk = [RL, FH, AP]
r.Parameter.Scan.REC = [HF, RL, AP]

To transform the ijk system to the REC system, we have to switch the first and the second axis of the Data matrix (permute it):

[RL, FH, AP] --> [FH, RL, AP]

and then flip the first axis (flipdim):

[FH, RL, AP] --> [HF, RL, AP]

Search¶

Search for a parameter within the whole MRecon class and all GoalC parameters, objects and groups

>> r.Search( 'search_string' )

Formats: All

Description/Algorithm: The search function iterates through all the parameters objects and groups of the MRecon class and checks if it matches the search string. Wildcards are possible.

Examples: To search for the field-of-view (FOV) call:

>> r.Search('FOV')

which will display all MRecon fields, and GoalC parameter/objects which contain the string FOV. You can also use wildcards to limit or extend your search space:

Assume we want to find all ex parameters with “FOV” in the name:

>> r.Search('EX_*FOV');

Assume we want to find all control parameters related to diffusion:

>> r.Search('CSC_*diff');

SENSEUnfold¶

Performs a SENSE reconstruction using the coil sensitivity information provided by the user.

>> r.SENSEUnfold

Recon Flag: Parameter.ReconFlags.isunfolded

Location: image-space

Formats: Raw | ExportedRaw

Description/Algorithm: Please see the MRsense manual for more infomation on the implemented algorithms and examples.

ScaleData¶

Clips the data such that 98% of its histogram is preserved

>> r.ScaleData

Location: Image-space

Formats: Raw | ExportedRaw | Cpx | Rec | Bruker

Description/Algorithm: A histogram is calculated over all values in the Data array and the value is found which includes 98% of the histograms integral. The data is then clipped at that value. This function is usefull to remove unwanted signal peaks.

ShowData¶

Displays the Data array using MRecon’s built-in 3D image viewer.

>> r.ShowData

Location: k-space | Image-space

Formats: Raw | ExportedRaw | Cpx | Rec | Bruker

Description/Algorithm: Opens the built-in 3D image viewer of MRecon and displays the Data array.

Notes:

The MRecon image viewer is a standalone tool and can be used to visualize any Matlab matrix. It can be called as:

>> image_slide( <matrix> )

r.ShowData therefore is equivalent to:

>> image_slide( r.Data )

SortData¶

Sorts the acquired profiles by their image attributes and generates proper k-space data.

>> r.SortData

Recon Flag: Parameter.ReconFlags.issorted

Location: After ReadData

Formats: Raw | ExportedRaw | ExportedCpx

Description/Algorithm: After reading the data into Matlab with ReadData, the acquired profiles are stored in temporal order (in the order they have been measured). The SortData function sorts the profiles by their image attributes phase encoding number, cardiac phase, dynamic scan number etc. After the sorting the data the data array holds proper k-space data which can be fourier transformed to generate images. Please note that averages are summed up immediately during sorting if immediate averaging is enabled (see above).

After SortData the data array has a predefined form with 12 dimensions, where every array dimension corresponds to an image attribute:

r.Data = [kx, ky, kz, coils, dynamics, cadiac phases, echoes, locations, mixes, extra1, extra2, averages ]

Transform¶

Transforms coordinates from one scanner coordinate system to another

>> [xyz_transformed, A] = r.Transform( xyz, from_system, to_system, stack_nr);

Or

>> A = r.Transform( from_system, to_system, stack_nr);

Location: k-space | image-space

Formats: Raw | Rec

Description/Algorithm: Please see the transformation manual for more information on the different coordinate systems and examples.

To transform a coordinate from one coordinate system to another the following parameters have to be known:

Patient Position (defines coordinate system)

Patient Orientation (defines coordinate system)

Image Orientation (defines coordinate system)

Fold Over Direction (defines coordinate system)

Fat Shift Direction (defines coordinate system)

Angulation (fixed, used in Transform)

Offcentre (fixed, used in Transform)

Slice Gap (fixed, used in Transform)

Resolution (variable, used in Transform: Resolution = curFOV / size(Data) )

Image Matrix (variable, used in Transform for ijk, REC systems)

The first 5 parameters are used to define the different coordinate systems (ijk, MPS, RAF, xyz, REC), which are stored in Parameter.Scan and used in the Transform function. Therefore the parameters itself are not needed in the Transform function anymore. Basically the parameters which are used in the Transform function can be divided into 2 groups: fixed and variable parameters. The fixed ones, such as the image angulation, do not change during the reconstruction process whereas the variable ones can change. The image resolution for example changes if we perform a k-space zero filling. In transform the current image resolution is calculated by dividing the current FOV by the current matrix size. Therefore if you are performing your own reconstruction and are not using the built-in MRecon functions (e.g. RemoveOversampling) always make sure that Parameter.Scan.curFOV corresponds to the current FOV of your data when calling the Transform function.

Update (Static)¶

Updates MRecon

>> MRecon.Update

UserPortal (Static)¶

Opens the user portal in the web-browser

>> MRecon.UserPortal

Version (Static)¶

Displays the MRecon version

>> version = MRecon.Version

WriteDICOM¶

Exports the data to Philips rec format.

>> r.WriteDICOM( output_directory )

Location: image-space.

Formats: Raw | Rec

Description/Algorithm: Exports the images in the data array to DICOM format. The DICOM files are written into the specified output directory in classic format (one file per image). If possible a DICOMDIR is created as well.

Notes: The number of parameters in the DICOM depends on the number of parameters available in MRecon.

WriteExportedRaw¶

Exports the data to Philips exported raw format.

>> [datafile, listfile] = r.WriteExportedRaw( Filename, Parameter2Write );

Location: k-space | image-space.

Formats: Raw | ExportedRaw

Description/Algorithm: Exports the images in the data array to Philips exported format (data/list file pair). The Parameter2Write which have to be given as input is usually the current Parameter2Read struct (r.Parameter.Parameter2Read).

WritePar¶

Exports the parameter to a Philips par file.

>> r.WritePar( filename )

Location: image-space.

Formats: Raw | ExportedRaw | Cpx | Rec

Description/Algorithm: Exports the parameters in to a Philips par file.

WriteRec¶

Exports the data to Philips rec format.

>> r.WriteRec( filename )

Location: image-space.

Formats: Raw | ExportedRaw | Cpx | Rec

Description/Algorithm: Exports the images in the data array to Philips rec format. During the export the data is rescaled according to:

Magnitude data, Real part, Imagenary part:

Value_in\Rec File = round( (Value_in_r.Data - RescaleIntercept) / RescaleSlope )

Phase data:

Value_in_Rec_File = round( (1000 \* Phase_in_r.Data - RescaleIntercept) / RescaleSlope )

Notes: When the exported rec data is reimported into the scanner database the values are rescaled such that they correspond the original values in r.Data before exporting.

WriteXMLPar¶

Exports the parameter to a Philips XML par file.

>> r.WriteXMLPar( filename )

Location: image-space.

Formats: Raw | ExportedRaw | Cpx | Rec

Description/Algorithm: Exports the parameters in to a Philips XML par file.

ZeroFill¶

Zero pads the data either in k-space or image-space

>> r.ZeroFill

Recon Flag: Parameter.ReconFlags.iszerofilled

Location: k-space | Image-space.

Formats: Raw | ExportedRaw | Cpx | Bruker

Description/Algorithm: The ZeroFill function zero-pads the current data to the dimensions specified in the Encoding parameters (see above). Thereby we have a different dimension depending whether we are in k-space or image-space. For example the dimension in y-direction after zero filling in k-space is given by:

yres = r.Parameter.Encoding.YRes \* cur_ovs

where the current oversampling cur_ovs is given by:

cur_ovs = r.Parameter.Encoding.KyOversampling
(if oversampling is not removed)

Or

cur_ovs = 1
(if oversampling is removed)

Whether and in which directions the data is oversampled is defined by the oversampling ReconFlag (Parameters.ReconFlags.isoversampled).

Zero filling in k-space is used to correct for anisotropic voxel sizes and the artificially increase image resolution. Zero filling in k-space isused to correct for a rectangular field-of-view and to produce quadratic images.

Parameter Methods¶

DisplayAllGroups¶

Displays all GoalC parameter groups (not supported for sinfiles)

>> r.Parameter.DisplayAllGroups

Formats: Raw

Description/Algorithm: Displays all parameter groups which are available in the pulsprogramming environment

DisplayGroupOfParameter¶

Displays the group(s) of the specified GoalC parameter (not supported for sinfiles)

>> r.Parameter.DisplayGroupOfParameter('<parameter name>')

Formats: Raw

Description/Algorithm: Displays all groups the specified parameter is a member of.

Examples: Assume we want to find the parameter group of VAL04_RFE_bw_sel_echo. To do so, execute the following command:

>> r.Parameter.DisplayGroupOfParameter('VAL04_RFE_bw_sel_echo');

DisplayObject¶

Displays all attributes of the specified object (not supported for sinfiles)

>> r.Parameter.DisplayObject('<object name>')

Formats: Raw

Description/Algorithm: Displays all attributes and their values of the specified GoalC object.

Examples: Assume we want to see the attribute of the base sequence object:

>> r.Parameter.DisplayObject('SQ::base');

DisplayObjectNames¶

Displays all objects of the specified object-class (not supported for sinfiles)

>> r.Parameter.DisplayObjectNames('<object class>')

Formats: Raw

Description/Algorithm: Displays all GoalC objects of the specified class.

Examples: Assume we want to display all RF objects

>> r.Parameter.DisplayObjectNames('RF');

DisplayParameterInGroup¶

Displays all parameter in the specified group (not supported for sinfiles)

>> r.Parameter.DisplayParameterInGroup('<group name>')

Formats: Raw

Description/Algorithm: Displays all GoalC parameter in the specified group

Examples: Assume we want to see all parameters in the respiratory navigator group:

>> r.Parameter.DisplayParameterInGroup('VAL01_RNAV_all_pars');

ExtractPDFFile¶

Creates a PDF file for the Philips graphical viewer (not supported for sinfiles)

>> r.Parameter.ExtractPDFFile ('<filename>')

Formats: Raw

Description/Algorithm: Creates a .gve file which can be opened with the Philips graphical viewer and contains the graphical representation of the PDF code. The input argument <filename> is optional. If it isn’t specified the .gve file will have the same name as the current raw file.

GetGroup¶

Gets the specified parameter group (not supported for sinfiles).

>> group = r.Parameter.GetGroup('<group name>')

Formats: Raw

Description/Algorithm: Gets the specified parameter group and returns a GoalcGroup object containing all the information.

Examples: Assume we want to get the respiratory navigator group:

>> G = r.Parameter.GetGroup('VAL01_RNAV_all_pars');

GetGroupOfParameter¶

Gets the group of the specified parameter (not supported for sinfiles).

Syntax: group = r.Parameter.GetGroupOfParameter(‘<parameter name>’);

Formats: Raw

Description/Algorithm: Gets the parameter group of the specified parameter and returns a GoalcGroup object.

Examples: Assume we want to get the group which VAL04_RFE_bw_sel_echo is a member of:

>> G = r.Parameter.GetGroupOfParameter ('VAL04_RFE_bw_sel_echo');

GetObject¶

Gets the specified object (not supported for sinfiles).

>> object = r.Parameter.GetObject('<object name>')

Formats: Raw

Description/Algorithm: Gets the specified object and returns a GoalcObject object containing all the information.

Examples: Assume we want to get the excitation pulse:

>> O = r.Parameter.GetObject('RF::ex');

GetObjectNames¶

Gets all the object names of the specified class (not supported for sinfiles)

>> object_names = r.Parameter.GetObjectNames('<object_class>');

Formats: Raw

Description/Algorithm: Gets all the object names of the specified class and returns them as a cell array.

Examples: Assume we want to get all the RF object names:

>> N = r.Parameter.GetObjectNames('RF');

GetParameter¶

Gets the specified parameter

>> par = r.Parameter.GetParameter('<parameter name>')

Formats: Raw

Description/Algorithm: Gets the specified parameter and returns a GoalcParameter object when the dataset was measured with the ReconFrame patch, or a cell array of parsed sin entries when the MRecon object was initialized from the sin file.

Examples: Assume we want to get the parameter attributes of VAL04_RFE_bw_sel_echo:

>> P = r.Parameter.GetParameter('VAL04_RFE_bw_sel_echo');

GetParameterInGroup¶

Gets all the parameter of the specified group (not supported for sinfiles).

>> par_array = r.Parameter.GetParameterInGroup ('<group_name>');

Formats: Raw

Description/Algorithm: Gets all the parameter of the specified group and returns an array of GoalCParameter objects.

Examples: Assume we want to get all the parameter in the respiratory navigator group:

>> P = r.Parameter.GetParameterInGroup('VAL01_RNAV_all_pars');

GetValue¶

Gets the value of a GOAL parameter, a GOAL object or an entry in the sin file.

>> value = r.Parameter.GetValue ('<name>', array_index, numeric);

Formats: Raw

Description/Algorithm: Gets the value of a Goalc parameter or object.

The input arguments “array_index” and “numeric” are optional. “array_index” can be used to selectively return certain elements if the specified parameter is an array. “numeric” is only valid for parameters of type enumeration and if it is true will return a numeric value instead of a string.

The return value depends on the type of the parameter/object and its dimension and can either be a scalar, array or cell array.

Examples: Assume we want to get all value of VAL01_RNAV_beam_order:

>> val = r.Parameter.GetValue('VAL01_RNAV_beam_order');

Please note that val is an array because the parameter is also an array. If we only want the first 2 values we can use the second input argument:

>> val = r.Parameter.GetValue('VAL01_RNAV_beam_order', 1:2);

If the parameter type is a string or enumeration then val will also be a string:

>> val = r.Parameter.GetValue('VAL01_RNAV_enable');

If we prefer a numeric value for the enumeration instead of the string we can use the third input argument:

>> val = r.Parameter.GetValue('VAL01_RNAV_enable', [], true);

We can also ask for values of an object attribute in the following way:

>> val = r.Parameter.GetValue('SQ::base->dur');

If the object is a composite object we should also specify the composite index (note that it starts at 1):

>> val = r.Parameter.GetValue('LCA::ima->prep_dir.cmp(1)');

If the MRecon object was initialized from a sin file we can get its values in the same way:

>> val = r.Parameter.GetValue('nr_mixes');

The return value is a cell array where each element corresponds to the parsed line in the sinfile where the parameter occurs.

IsParameter¶

Checks if a parameter exists

>> is_par = r.Parameter.IsParameter ('<parameter name>')

Formats: Raw

Description/Algorithm: Checks if a GoalC or sin Parameter is available in the MRecon object

Examples:

>> is\_par = r.Parameter.IsParameter('VAL01_RNAV_all_pars');

IsObject¶

Checks if an object exists (not supported for sinfiles)

>> is\_obj = r.Parameter.IsObject ('<object name>')

Formats: Raw

Description/Algorithm: Checks if a GoalC object is available in the MRecon object

Examples:

>> is_obj = r.Parameter.IsObject('SQ::base');

Search¶

See Search function in MRecon Methods.