Windows, binary¶

Add the mex and tools subdirectories to your MATLAB path and/or the Python module to your Python path.

Linux, from source¶

Requirements: g++, boost, CUDA (driver+toolkit), Matlab and/or Python (2.7 or 3.x)

cd build/linux
./autogen.sh   # when building a git version
./configure --with-cuda=/usr/local/cuda \
            --with-matlab=/usr/local/MATLAB/R2012a \
            --with-python
            --prefix=/usr/local/astra
make
make install

Add /usr/local/astra/lib to your LD_LIBRARY_PATH. Add /usr/local/astra/matlab and its subdirectories (tools, mex) to your matlab path. Add /usr/local/astra/python to your PYTHONPATH.

NB: Each matlab version only supports a specific range of g++ versions. Despite this, if you have a newer g++ and if you get errors related to missing GLIBCXX_3.4.xx symbols, it is often possible to work around this requirement by deleting the version of libstdc++ supplied by matlab in MATLAB_PATH/bin/glnx86 or MATLAB_PATH/bin/glnxa64 (at your own risk).

Linux, using conda for python¶

Requirements: conda python environment

There are packages available for the ASTRA Toolbox in the astra-toolbox channel for the conda package manager. To use these, run the following inside a conda environment.

conda install -c astra-toolbox astra-toolbox

Windows, from source using Visual Studio 2008¶

Requirements: Visual Studio 2008, boost, CUDA (driver+toolkit), matlab. Note that a .zip with all required (and precompiled) boost files is available from our website.

Set the environment variable MATLAB_ROOT to your matlab install location. Open astra_vc08.sln in Visual Studio. Select the appropriate solution configuration. (typically Release_CUDA|win32 or Release_CUDA|x64) Build the solution. Install by copying AstraCuda32.dll or AstraCuda64.dll from bin/ and all .mexw32 or .mexw64 files from bin/Release_CUDA or bin/Debug_CUDA and the entire matlab/tools directory to a directory to be added to your matlab path.

Linux, building conda packages¶

To build your own conda packages for the ASTRA toolbox, perform the following steps inside the conda environment:

cd python/conda/libastra
CUDA_ROOT=/path/to/cuda conda-build ./ # Build C++ library
cd ../
CUDA_ROOT=/path/to/cuda conda-build ./ # Build Python interface

The final step includes a test to check whether the build was successful. To be able to perform this test, conda should be able to find the ASTRA C++ library package of the second step. One way of accomplishing this is to temporarily add the conda build directory as a custom channel. To do this, the following steps can be used:

cd python/conda/libastra
CUDA_ROOT=/path/to/cuda conda-build ./ # Build C++ library
cd ../
CUDA_ROOT=/path/to/cuda conda-build \
    -c file://[/path/to/conda_env]/conda-bld/ \
    -c defaults --override-channels ./ # Build Python interface

Geometry¶

Most of the operations supported by the ASTRA Toolbox require you to specify what the geometry of the (real or virtual) experimental setup you have used or want to simulate is.

This has two parts: a volume geometry, and a projection geometry. The volume geometry specifies where in 2D or 3D space the sample or phantom is located. It takes the form of a 2D rectangle or 3D box, and is usually centered around the origin.

The projection geometry specifies the location and trajectory of the ray source and detector. The available types of projection geometries are 2D parallel beam, 2D fan beam, 3D parallel beam and 3D cone beam.

Data¶

Toolbox objects are stored in memory separate from Matlab, and have to be explicitly transferred from/to Matlab matrices.

They come in four varieties: 2D/3D volume data, and 2D/3D projection data.

Data objects are manipulated with the astra_mex_data2d/astra.data2d and astra_mex_data3d/astra.data3d commands. The usage of these commands is illustrated in the available sample scripts.

Algorithms¶

To operate on data objects, the ASTRA Toolbox defines a number of algorithms. These include the basic forward and backward projection operations, and also various reconstruction algorithms.

To create algorithm objects, use the astra_mex_algorithm/astra.algorithm command. The usage of this command is illustrated in the available sample scripts.

Volume Geometries¶

Create a 2D volume geometry:

vol_geom = astra_create_vol_geom(rows_and_cols);
vol_geom = astra_create_vol_geom([rows cols]);
vol_geom = astra_create_vol_geom(rows, cols);
vol_geom = astra_create_vol_geom(rows, cols, min_x, max_x, min_y, max_y);

In the first form, the volume contains an equal number of rows and columns. In the first, second and third forms, volume pixels are squares with sides of unit length, and the volume is centered around the origin. In the fourth, longer form, the extents of the volume can be specified arbitrarily. The long form corresponding to the default short form is:

vol_geom = astra_create_vol_geom(y, x, -x/2, x/2, -y/2, y/2);

Note: For usage with GPU code, the volume must be centered around the origin and pixels must be square. This is not always explicitly checked in all functions, so not following these requirements may have unpredictable results.

Projection Geometries¶

parallel

Create a 2D parallel beam geometry:

proj_geom = astra_create_proj_geom('parallel', det_width, det_count, angles);

• det_spacing: distance between the centers of two adjacent detector pixels
• det_count: number of detector pixels in a single projection
• angles: projection angles in radians

fanflat

Create a 2D flat fan beam geometry:

proj_geom = astra_create_proj_geom('fanflat', det_width, det_count, angles, source_origin, origin_det);

• det_width: distance between the centers of two adjacent detector pixels
• det_count: number of detector pixels in a single projection
• angles: projection angles in radians
• source_origin: distance between the source and the center of rotation
• origin_det: distance between the center of rotation and the detector array

fanflat_vec

Create a 2D flat fan beam geometry specified by 2D vectors:

proj_geom = astra_create_proj_geom('fanflat_vec', det_count, vectors);

• det_count: number of detectors in a single projection
• vectors: a matrix containing the actual geometry. Each row of vectors corresponds to a single projection, and consists of: ( srcX, srcY, dX, dY, uX, uY )
• src : the ray source
• d : the center of the detector
• u : the vector between the centers of detector pixels 0 and 1

To illustrate, this is a matlab script to convert a single projection in a projection geometry of type “fanflat” into such a 6-element row:

% source
vectors(i,1) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginSource;
vectors(i,2) = -cos(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginSource;

% center of detector
vectors(i,3) = -sin(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginDetector;
vectors(i,4) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginDetector;

% vector from detector pixel 0 to 1
vectors(i,5) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorWidth;
vectors(i,6) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorWidth;

This conversion is also available as a function in the toolbox:

proj_geom_vec = astra_geom_2vec(proj_geom);

sparse_matrix

Create a 2D projection geometry defined by its system matrix:

proj_geom = astra_create_proj_geom('sparse_matrix', det_width, det_count, angles, matrix_id);

• det_width: unused, but has to be present (for compatibility reasons)
• det_count: number of detectors in a single projection
• angles: a vector, the length of which is the number of projections. The contents are unused.
• matrix_id: a astra_mex_matrix ID of a sparse matrix of the right dimensions.

The matrix is an ID returned by

matrix_id = astra_mex_matrix('create', matlab_sparse_matrix);

The sparse matrix must be of size (det_count * numel(angles), x*y), where (x,y) is the size of the volume geometry to be used.

The rows of the sparse matrix are ordered by projection: The first row of the matrix corresponds to the first detector pixel of the first projection, and the second row of the matrix corresponds to the second detector pixel of the first projection.

The columns of the sparse matrix are ordered by row: The first column of the matrix corresponds to pixel (1,1) and the second column to pixel (1,2) in the volume.

Volume geometries¶

vol_geom = astra_create_vol_geom(y,x,z);

Create a 3D volume geometry.

Projection geometries¶

parallel3d

proj_geom = astra_create_proj_geom('parallel3d', det_spacing_x, det_spacing_y, det_row_count, det_col_count, angles);

Create a 3D parallel beam geometry.

• det_spacing_x: distance between the centers of two horizontally adjacent detector pixels
• det_spacing_y: distance between the centers of two vertically adjacent detector pixels
• det_row_count: number of detector rows in a single projection
• det_col_count: number of detector columns in a single projection
• angles: projection angles in radians

cone

proj_geom = astra_create_proj_geom('cone',  det_spacing_x, det_spacing_y, det_row_count, det_col_count, angles, source_origin, origin_det);

Create a 3D cone beam geometry.

• det_spacing_x: distance between the centers of two horizontally adjacent detector pixels
• det_spacing_y: distance between the centers of two vertically adjacent detector pixels
• det_row_count: number of detector rows in a single projection
• det_col_count: number of detector columns in a single projection
• angles: projection angles in radians
• source_origin: distance between the source and the center of rotation
• origin_det: distance between the center of rotation and the detector array

parallel3d_vec

proj_geom = astra_create_proj_geom('parallel3d_vec',  det_row_count, det_col_count, vectors);

Create a 3D parallel beam geometry specified by 3D vectors.

• det_row_count: number of detector rows in a single projection
• det_col_count: number of detector columns in a single projection
• vectors: a matrix containing the actual geometry.

Each row of vectors corresponds to a single projection, and consists of:

( rayX, rayY, rayZ, dX, dY, dZ, uX, uY, uZ, vX, vY, vZ )

• ray : the ray direction
• d : the center of the detector
• u : the vector from detector pixel (0,0) to (0,1)
• v : the vector from detector pixel (0,0) to (1,0)

To illustrate, this is a matlab script to convert a single projection in a projection geometry of type “parallel3d” into such a 12-element row:

% ray direction
vectors(i,1) = sin(proj_geom.ProjectionAngles(i));
vectors(i,2) = -cos(proj_geom.ProjectionAngles(i));
vectors(i,3) = 0;

% center of detector
vectors(i,4) = 0;
vectors(i,5) = 0;
vectors(i,6) = 0;

% vector from detector pixel (0,0) to (0,1)
vectors(i,7) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorSpacingX;
vectors(i,8) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorSpacingX;
vectors(i,9) = 0;

% vector from detector pixel (0,0) to (1,0)
vectors(i,10) = 0;
vectors(i,11) = 0;
vectors(i,12) = proj_geom.DetectorSpacingY;

This conversion is also available as a function in the toolbox:

proj_geom_vec = astra_geom_2vec(proj_geom);

cone_vec

proj_geom = astra_create_proj_geom('cone_vec',  det_row_count, det_col_count, vectors);

Create a 3D cone beam geometry specified by 3D vectors.

• det_row_count: number of detector rows in a single projection
• det_col_count: number of detector columns in a single projection
• vectors: a matrix containing the actual geometry.

Each row of vectors corresponds to a single projection, and consists of:

( srcX, srcY, srcZ, dX, dY, dZ, uX, uY, uZ, vX, vY, vZ )

• src : the ray source
• d : the center of the detector
• u : the vector from detector pixel (0,0) to (0,1)
• v : the vector from detector pixel (0,0) to (1,0)

To illustrate, this is a matlab script to convert a single projection in a projection geometry of type “cone” into such a 12-element row:

% source
vectors(i,1) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginSource;
vectors(i,2) = -cos(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginSource;
vectors(i,3) = 0;

% center of detector
vectors(i,4) = -sin(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginDetector;
vectors(i,5) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginDetector;
vectors(i,6) = 0;

% vector from detector pixel (0,0) to (0,1)
vectors(i,7) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorSpacingX;
vectors(i,8) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorSpacingX;
vectors(i,9) = 0;

% vector from detector pixel (0,0) to (1,0)
vectors(i,10) = 0;
vectors(i,11) = 0;
vectors(i,12) = proj_geom.DetectorSpacingY;

Creation¶

id = astra_create_projector(...);

Create a projector object. Projectors determine the (implicit) weight matrix of the geometries. All CPU reconstruction algorithms require a projector.

This script is a wrapper around astra_mex_projector(‘create’, ...) with a more convenient interface. See below for specifics.

The allocated object must be freed after use with a call to

astra_mex_projector('delete', id)

Parallel beam¶

The projectors in this section can be used with the parallel projection geometry.

line

proj_id = astra_create_projector('line', proj_geom, vol_geom);

The weight of a ray/pixel pair is given by the length of the intersection of the pixel and the ray, considered as a zero-thickness line.

strip

proj_id = astra_create_projector('strip', proj_geom, vol_geom);

The weight of a ray/pixel pair is given by the area of the intersection of the pixel and the ray, considered as a strip with the same width as a detector pixel.

linear

proj_id = astra_create_projector('linear', proj_geom, vol_geom);

A ray is traced through successive columns or rows (depending on which are most orthogonal to the ray). The contribution of this column/row to this ray is then given by linearly interpolating between the two nearest volume pixels of the intersection of the ray and the column/row.

This is also known as the Joseph kernel, or a slice-interpolated kernel.

Fan beam¶

line_fanflat

proj_id = astra_create_projector('line_fanflat', proj_geom, vol_geom);

The weight of a ray/pixel pair is given by the length of the intersection of the pixel and the ray, considered as a zero-thickness line. This projector can be used with the fanflat and fanflat_vec geometries.

strip_fanflat

proj_id = astra_create_projector('strip_fanflat', proj_geom, vol_geom);

The weight of a ray/pixel pair is given by the area of the intersection of the pixel and the ray. The ray is considered as a 2D cone from the source to the full width of the detector pixel. The projector can only be used with the fanflat geometry.

NB: This mathematical model does not properly take into account the fan beam magnification effect.

Miscellaneous¶

sparse_matrix

proj_id = astra_create_projector('sparse_matrix', proj_geom, vol_geom);

This projector uses a sparse matrix projection geometry. See the documentation for that geometry for details.

cuda

proj_id = astra_create_projector('cuda', proj_geom, vol_geom);

This projector does not directly specify a weight matrix, but instead is intended to let algorithms use GPU/CUDA code. It can be used with parallel, fanflat and fanflat_vec projection geometries.

NB: This functionality has not yet been implemented everywhere. This projector is currently only usable in astra_create_sino and astra_create_backprojection.

astra_mex_projector¶

astra_mex_projector is used to manage projector objects.

It is a wrapper around the MEX file astra_mex_projector_c.

astra_mex_projector contains the following commands.

• create
• matrix
• volume_geometry
• projection_geometry
• is_cuda
• delete
• clear
• info

create

id = astra_mex_projector('create', cfg);

Create a projector from a config object. This is called internally by the script [[astra_create_projector]], which is the recommended way to create most projectors.

matrix

matrix_id = astra_mex_projector('matrix', projector_id);

Create an explicit sparse matrix for the weight matrix encoded by this projector.

This is only implemented for 2D CPU projectors.

The returned matrix_id can be further manipulated with [astra_mex_matrix]. In particular, it can be retrieved as a Matlab sparse matrix with

S = astra_mex_matrix('get', matrix_id);

It has to be freed after use with

astra_mex_matrix('delete', matrix_id);

NB: Such a matrix can be very large for large geometries.

volume_geometry

vol_geom = astra_mex_projector('volume_geometry', id);

Get the volume geometry attached to the given projector object.

NB: This is not fully implemented yet and the return value may not accurately represent the geometry.

projection_geometry

proj_geom = astra_mex_projector('projection_geometry', id);

Get the projection geometry attached to the given projector object.

NB: This is not fully implemented yet and the return value may not accurately represent the geometry.

is_cuda

c = astra_mex_projector('is_cuda', id);

Return if the the projector is a CUDA projector.

delete

astra_mex_projector('delete', id)
astra_mex_projector('delete', id1, id2, ...)

Free a single or multiple projector(s).

clear

astra_mex_projector('clear')

Free all projectors.

info

astra_mex_projector('info')

Print basic information about all allocated projector objects.

astra_mex_data2d¶

astra_mex_data2d is used to manage 2D data objects. It is a wrapper around the MEX file astra_mex_data2d_c.

2D data objects come in two varieties: volume data and projection data (sinograms).

astra_mex_data2d contains the following commands.

• create
• get
• get_single
• set / store
• get_geometry
• change_geometry
• delete
• clear
• info

create

id = astra_mex_data2d('create', '-vol', vol_geom);
id = astra_mex_data2d('create', '-vol', vol_geom, initializer);

This creates an initialized 2D volume data object for the geometry vol_geom.

Initializer may be:

• a scalar: the object is initialized with this constant value.
• a matrix: the object is initialized with the contents of this matrix. The matrix must be of size (y,x) as defined in the volume geometry. It must be of class single, double or logical.

If an initializer is not present, the volume is initialized to zero.

id = astra_mex_data2d('create', '-sino', proj_geom);
id = astra_mex_data2d('create', '-sino', proj_geom, initializer);

This creates an initialized 2D projection data object for the geometry proj_geom.

Initializer may be:

• a scalar: the object is initialized with this constant value.
• a matrix: the object is initialized with the contents of this matrix. The matrix must be of size (angles,u), where u is the number of detector pixels as defined in the projection geometry. It must be of class single, double or logical.

If an initializer is not present, the volume is initialized to zero.

get

A = astra_mex_data2d('get', id);

This fetches the data object as a 2D matrix of class double.

get_single

A = astra_mex_data2d('get_single', id);

This fetches the data object as a 2D matrix of class single.

set / store

astra_mex_data2d('set', id, A)
astra_mex_data2d('store', id, A)

This stores the matrix A in the data object. The dimensions of A must be the same as when used as an initializer in astra_mex_data2d(‘create’).

Set and store are synonyms.

get_geometry

geom = astra_mex_data2d('get_geometry', id);

This gets the (volume or projection) geometry attached to the object.

NB: This is not fully implemented yet and the return value may not accurately represent the geometry.

change_geometry

astra_mex_data2d('change_geometry', id, geom);

This changes the (volume or projection) geometry attached to the object. It may not change the actual dimensions of the data object. This can be used to change the pixel dimensions or projection angles, for example.

delete

astra_mex_data2d('delete', id);

Free the memory of a data object.

clear

astra_mex_data2d('clear');

Free all data objects.

info

astra_mex_data2d('info')

Print basic information about all allocated data objects.

astra_mex_data3d¶

astra_mex_data3d is used to manage 3D data objects. It is a wrapper around the MEX file astra_mex_data3d_c.

3D data objects come in two varieties: volume data and projection data.

astra_mex_data3d has the following commands.

• create
• get
• get_single
• set / store
• dimensions
• delete
• clear
• info
• link

create

id = astra_mex_data3d('create', '-vol', vol_geom);
id = astra_mex_data3d('create', '-vol', vol_geom, initializer);

This creates an initialized 3D volume data object for the geometry vol_geom.

Initializer may be:

• a scalar: the object is initialized with this constant value.
• a matrix: the object is initialized with the contents of this matrix. The matrix must be of size (x,y,z) as defined in the volume geometry. It must be of class single, double or logical.

If an initializer is not present, the volume is initialized to zero.

id = astra_mex_data3d('create', '-proj3d', proj_geom);
id = astra_mex_data3d('create', '-proj3d', proj_geom, initializer);

This creates an initialized 3D projection data object for the geometry proj_geom.

Initializer may be:

• a scalar: the object is initialized with this constant value.
• a matrix: the object is initialized with the contents of this matrix. The matrix must be of size (u,angles,v), where u is the number of columns of the detector and v the number of rows as defined in the projection geometry. It must be of class single, double or logical.

If an initializer is not present, the volume is initialized to zero.

get

A = astra_mex_data3d('get', id);

This fetches the data object as a 3D matrix of class double.

get_single

A = astra_mex_data3d('get_single', id);

This fetches the data object as a 3D matrix of class single.

set / store

astra_mex_data3d('set', id, A);
astra_mex_data3d('store', id, A);

This stores the matrix A in the data object. The dimensions of A must be the same as when used as an initializer in astra_mex_data3d(‘create’).

Set and store are synonyms.

dimensions

s = astra_mex_data3d('dimensions', id);

Get the dimensions of a data object.

delete

astra_mex_data3d('delete', id);

Free the memory of a data object.

clear

astra_mex_data3d('clear');

Free all data objects.

info

astra_mex_data3d('info')

Print basic information about all allocated data objects.

link

id = astra_mex_data3d_c('link', '-vol', vol_geom, array, readonly, Z);
id = astra_mex_data3d_c('link', '-proj3d', proj_geom, array, readonly, Z);

NB: This must be called on astra_mex_data3d_c, and does not work properly when using the wrapper astra_mex_data3d.

This creates a data object that directly uses a matlab array as storage instead of allocating its own memory. The array must be of the same dimensions as those required for initializers in astra_mex_data3d(‘create’). Additionally, it must be of class ‘single’.

The optional argument ‘readonly’ (default: false), controls the exact behaviour of this operation. See the two sections below for details.

The optional argument ‘Z’ (default: 0) allows creating a data object that is smaller in the third dimension than the Matlab array. The data object will be mapped to slices starting at slice Z. NB: Z is zero-based, unlike matlab array indexing.

Read-only link mode:

The data object becomes an additional reference to the array, effectively behaving the same as a Matlab assignment ‘internal_data = A;’ (if ‘A’ is passed as the ‘array’ argument). If the array A is changed inside Matlab, a copy will be made and the changes to A will not be visible to this data object.

The data object’s read-only state is not enforced by the astra toolbox. Using it as output for algorithms is allowed, but the exact effects depend on Matlab’s internal reference counting mechanics.

Read-write link mode:

The passed array is ‘unshared’ and the data object obtains a second reference to this array. There is no direct Matlab script equivalent to this, but effectively the data object and the passed array will share memory. Any changes to the data object from inside the toolbox will be visible in Matlab.

If the passed array is modified in Matlab, this link is broken (by matlab’s reference counting mechanism), and the changes will not be visible to the astra data object.

2D CPU Algorithms¶

%% create geometries and projector
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);
proj_id = astra_create_projector('linear', proj_geom, vol_geom);

%% store volume
V = phantom(256);
volume_id = astra_mex_data2d('create', '-vol', vol_geom, V);

%% create forward projection
sinogram_id = astra_mex_data2d('create', '-sino', proj_geom, 0);
cfg = astra_struct('FP');
cfg.ProjectorId = proj_id;
cfg.ProjectionDataId = sinogram_id;
cfg.VolumeDataId = volume_id;
fp_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('run', fp_id);
sinogram = astra_mex_data2d('get', sinogram_id);
imshow(sinogram, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, volume_id);
astra_mex_projector('delete', proj_id);
astra_mex_algorithm('delete', fp_id);

[sinogram_id, sinogram] = astra_create_sino(V, proj_id);
[sinogram_id, sinogram] = astra_create_sino(V_id, proj_id);

%% create phantom
V_exact = phantom(256);

%% create geometries and projector
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);
proj_id = astra_create_projector('linear', proj_geom, vol_geom);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino(V_exact, proj_id);

%% reconstruct
recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('FBP');
cfg.ProjectorId = proj_id;
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
fbp_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('run', fbp_id);
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_projector('delete', proj_id);
astra_mex_algorithm('delete', fbp_id);

%% create phantom
V_exact = phantom(256);

%% create geometries and projector
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);
proj_id = astra_create_projector('linear', proj_geom, vol_geom);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino(V_exact, proj_id);

%% reconstruct
recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('SIRT');
cfg.ProjectorId = proj_id;
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
cfg.option.MinConstraint = 0;
cfg.option.MaxConstraint = 255;
sirt_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('iterate', sirt_id, 100);
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_projector('delete', proj_id);
astra_mex_algorithm('delete', sirt_id);

%% create phantom
V_exact = phantom(256);

%% create geometries and projector
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);
proj_id = astra_create_projector('linear', proj_geom, vol_geom);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino(V_exact, proj_id);

%% reconstruct
recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('SART');
cfg.ProjectorId = proj_id;
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
cfg.option.ProjectionOrder = 'custom';
cfg.option.ProjectionOrderList = [0:5:175 1:5:176 2:5:177 3:5:178 4:5:179];
sart_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('iterate', sart_id, 10*180);
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_projector('delete', proj_id);
astra_mex_algorithm('delete', sart_id);

%% create phantom
V_exact = phantom(256);

%% create geometries and projector
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);
proj_id = astra_create_projector('linear', proj_geom, vol_geom);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino(V_exact, proj_id);

%% reconstruct

[p,q] = meshgrid(0:179, 0:255);
rayOrderList = [p(:) q(:)];
rayOrderList = rayOrderList(randperm(numel(p)),:);

recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('ART');
cfg.ProjectorId = proj_id;
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
cfg.option.RayOrder = 'custom';
cfg.option.RayOrderList = rayOrderList;
art_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('iterate', art_id, 3*numel(p));
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_projector('delete', proj_id);
astra_mex_algorithm('delete', art_id);

%% create phantom
V_exact = phantom(256);

%% create geometries and projector
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);
proj_id = astra_create_projector('linear', proj_geom, vol_geom);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino(V_exact, proj_id);

%% reconstruct
recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('CGLS');
cfg.ProjectorId = proj_id;
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
cgls_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('iterate', cgls_id, 100);
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_projector('delete', proj_id);
astra_mex_algorithm('delete', cgls_id);

2D GPU Algorithms¶

%% create geometries
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);

%% store volume
V = phantom(256);
volume_id = astra_mex_data2d('create', '-vol', vol_geom, V);

%% create forward projection
sinogram_id = astra_mex_data2d('create', '-sino', proj_geom, 0);
cfg = astra_struct('FP_CUDA');
cfg.ProjectionDataId = sinogram_id;
cfg.VolumeDataId = volume_id;
fp_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('run', fp_id);
sinogram = astra_mex_data2d('get', sinogram_id);
imshow(sinogram, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, volume_id);
astra_mex_algorithm('delete', fp_id);

[sinogram_id, sinogram] = astra_create_sino_cuda(V, proj_geom, vol_geom);
[sinogram_id, sinogram] = astra_create_sino_cuda(V_id, proj_geom, vol_geom);

%% create phantom
V_exact = phantom(256);

%% create geometries
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino_cuda(V_exact, proj_geom, vol_geom);

%% reconstruct
recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('FBP_CUDA');
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
fbp_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('run', fbp_id);
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_algorithm('delete', fbp_id);

%% create phantom
V_exact = phantom(256);

%% create geometries
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino_cuda(V_exact, proj_geom, vol_geom);

%% reconstruct
recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('SIRT_CUDA');
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
cfg.option.MinConstraint = 0;
cfg.option.MaxConstraint = 255;
sirt_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('iterate', sirt_id, 100);
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_algorithm('delete', sirt_id);

%% create phantom
V_exact = phantom(256);

%% create geometries
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino_cuda(V_exact, proj_geom, vol_geom);

%% reconstruct
recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('SART_CUDA');
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
cfg.option.ProjectionOrder = 'custom';
cfg.option.ProjectionOrderList = [0:5:175 1:5:176 2:5:177 3:5:178 4:5:179];
sart_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('iterate', sart_id, 10*180);
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_algorithm('delete', sart_id);

%% create phantom
V_exact = phantom(256);

%% create geometries
proj_geom = astra_create_proj_geom('parallel', 1.0, 256, linspace2(0,pi,180));
vol_geom = astra_create_vol_geom(256,256);

%% create forward projection
[sinogram_id, sinogram] = astra_create_sino_cuda(V_exact, proj_geom, vol_geom);

%% reconstruct
recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
cfg = astra_struct('CGLS_CUDA');
cfg.ProjectionDataId = sinogram_id;
cfg.ReconstructionDataId = recon_id;
cgls_id = astra_mex_algorithm('create', cfg);
astra_mex_algorithm('iterate', cgls_id, 100);
V = astra_mex_data2d('get', recon_id);
imshow(V, []);

%% garbage disposal
astra_mex_data2d('delete', sinogram_id, recon_id);
astra_mex_algorithm('delete', cgls_id);

3D GPU Algorithms¶

astra_create_sino¶

id = astra_create_sino(data, projector_id);
[id, sinogram] = astra_create_sino(data, projector_id);

Compute a sinogram from a 2D volume using the given projector. See the documentation for astra_create_projector for details on projectors. The projector_id may be for either a CPU or a GPU/CUDA projector.

The input may either be an astra_mex_data2d id for a volume data object of the right volume geometry, or a matrix directly containing the object data. In the latter case, it must be of size (height,width) as defined in the volume geometry. It must be of class single, double or logical.

In its one output argument form, astra_create_sino returns a newly allocated astra_mex_data2d id containing the sinogram.

In its two output argument form, astra_create_sino additionally returns the sinogram itself.

astra_create_backprojection¶

id = astra_create_backprojection(data, projector_id);
[id, volume] = astra_create_backprojection(data, projector_id);

Compute a backprojection of a 2D sinogram using the given projector. See the documentation for astra_create_projector for details on projectors. The projector_id may be for either a CPU or a GPU/CUDA projector.

The input may either be an astra_mex_data2d id for a projection data object of the right projection geometry, or a matrix directly containing the sinogram. In the latter case, it must be of size (#angles, #detector pixels) as defined in the projection geometry. It must be of class single, double or logical.

In its one output argument form, astra_create_backprojection returns a newly allocated astra_mex_data2d id containing the volume.

In its two output argument form, astra_create_backprojection additionally returns the volume data itself.

astra_create_sino_cuda¶

id = astra_create_sino(data, proj_geom, vol_geom);
[id, sinogram] = astra_create_sino(data, proj_geom, vol_geom);

Compute a sinogram from a 2D volume and the given geometry, using a GPU.

The input may either be an astra_mex_data2d id for a volume data object of the right volume geometry, or a matrix directly containing the object data. In the latter case, it must be of size (height,width) as defined in the volume geometry. It must be of class single, double or logical.

In its one output argument form, astra_create_sino_cuda returns a newly allocated astra_mex_data2d id containing the sinogram.

In its two output argument form, astra_create_sino_cuda additionally returns the sinogram itself.

astra_create_backprojection_cuda¶

volume = astra_create_backprojection_cuda(data, proj_geom, vol_geom);

Compute a backprojection of a 2D sinogram and the given geometry, using a GPU.

The input may either be an astra_mex_data2d id for a projection data object of the right projection geometry, or a matrix directly containing the sinogram. In the latter case, it must be of size (#angles, #detector pixels) as defined in the projection geometry. It must be of class single, double or logical.

astra_create_backprojection returns the volume data in a matrix.

Note: as a historical accident, this function has a different return argument signature than the other astra_create_backprojection* functions.

astra_create_sino3d_cuda¶

id = astra_create_sino3d_cuda(data, proj_geom, vol_geom); [id, projdata] = astra_create_sino3d_cuda(data, proj_geom, vol_geom);

Compute projection data from a 3D volume and the given geometry, using a GPU.

The input may either be an astra_mex_data3d id for a volume data object of the right volume geometry, or a matrix directly containing the object data. In the latter case, it must be of size (x,y,z) as defined in the volume geometry. It must be of class single, double or logical.

In its one output argument form, astra_create_sino3d_cuda returns a newly allocated astra_mex_data3d id containing the projection data.

In its two output argument form, astra_create_sino3d_cuda additionally returns the projection data itself.

astra_create_backprojection3d_cuda¶

id = astra_create_backprojection3d_cuda(data, proj_geom, vol_geom);
[id, volume] = astra_create_backprojection(data, proj_geom, vol_geom);

Compute a backprojection of 3D projection data and the given geometry, using a GPU.

The input may either be an astra_mex_data3d id for a projection data object of the right projection geometry, or a matrix directly containing the projection data. In the latter case, it must be of size (u,#angles,v), where u is the number of columns of the detector and v the number of rows as defined in the projection geometry. It must be of class single, double or logical.

In its one output argument form, astra_create_backprojection3d_cuda returns a newly allocated astra_mex_data3d id containing the volume.

In its two output argument form, astra_create_backprojection3d_cuda additionally returns the volume data itself.

astra_geom_2vec¶

proj_geom_vec = astra_geom_2vec(proj_geom);

Convert a projection geometry of type fanflat, cone, or parallel3d into an equivalent geometry of type fanflat_vec, cone_vec, or parallel3d_vec, respectively.

astra_geom_size¶

s = astra_geom_size(geom);
s = astra_geom_size(geom, dim);

Get the size of Matlab arrays for data objects with a given geometry. All geometries (2D, 3D, volume, projection) are supported.

The size returned is the size needed for arrays passed to the astra_mex_data2d/3d ‘create’, ‘set’/’store’ and ‘link’ functions, as well as the size of arrays returned by astra_mex_data2d/3d ‘get’/’get_single’.

Masks¶

Various reconstruction algorithms support projection data and reconstruction volume masks. These behave as follows.

The projection data elements corresponding to locations with SinogramMask value 0.0 will be ignored during the reconstruction. Similarly, the reconstruction data elements corresponding to locations with ReconstructionMask value 0.0 will be ignored during the reconstruction, and their values will be preserved. (Mostly, see note on constraints below.)

The algorithm will behave as if the rows and columns corresponding to the masked voxels and projection data elements have been removed from the projection matrix entirely. In other words, it will iteratively try to match the projection of the non-masked voxels to the non-masked projection data elements.

NB: MinConstraint/MaxConstraint will affect even masked voxels.

astra_struct¶

cfg = astra_struct('NAME');

This is the basic script to create a configuration struct for many astra objects. The returned struct is usually filled with more options after creating it, and then passed to astra functions such as

id = astra_mex_algorithm('create', cfg);
id = astra_mex_projector('create', cfg);

The most common usage is for creating algorithm configuration structs. See the pages on [2D CPU Algorithms], [2D GPU Algorithms], [3D GPU Algorithms] for available algorithms, and the pages for the individual algorithms for the options they support.

astra_mex_matrix¶

astra_mex_matrix is used to manage sparse matrices. These can be created by the ASTRA toolbox itself to obtain explicit weight matrices (see [astra_mex_projector]), or you can create them yourself for use with the sparse_matrix projection geometry.

It is a wrapper around the MEX file astra_mex_matrix_c.

astra_mex_matrix contains the following commands:

• create
• get
• get_size
• store
• delete
• clear
• info

create

id = astra_mex_matrix('create', S);

Create an ASTRA sparse matrix object from a Matlab sparse matrix. get

S = astra_mex_matrix('get', id);

Return an ASTRA sparse matrix object as a Matlab sparse matrix.

get_size

s = astra_mex_matrix('get_size', id);

Get the size (rows,columns) of the sparse matrix object.

store

astra_mex_matrix('store', id, S)

Store a new Matlab sparse matrix in an ASTRA sparse matrix object.

NB: This does not re-allocate memory: the number of rows and non-zero entries may not be larger than they were when the object was first created.

delete

astra_mex_matrix('delete', id)

Free a single sparse matrix.

clear

astra_mex_matrix('clear')

Free all sparse matrices.

info

astra_mex_matrix('info')

Print basic information about all allocated sparse matrix objects.