Note: This page has been translated by MathWorks. Please click here

To view all translated materials including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materials including this page, select Japan from the country navigator on the bottom of this page.

Inverse Radon transform

`I = iradon(R, theta)`

I = iradon(R,theta,* interp*,

`filter`

[I,H] = iradon(...)

[___]= iradon(gpuarrayR,___)

`I = iradon(R, theta)`

reconstructs the image `I`

from
projection data in the two-dimensional array `R`

.
The columns of `R`

are parallel beam projection data. `iradon`

assumes
that the center of rotation is the center point of the projections,
which is defined as `ceil(size(R,1)/2)`

.

`theta`

describes the angles (in degrees) at
which the projections were taken. It can be either a vector containing
the angles or a scalar specifying `D_theta`

, the
incremental angle between projections. If `theta`

is
a vector, it must contain angles with equal spacing between them.
If `theta`

is a scalar specifying `D_theta`

,
the projections were taken at angles `theta = m*D_theta`

,
where `m = 0,1,2,...,size(R,2)-1`

. If the input is
the empty matrix (`[]`

), `D_theta`

defaults
to `180/size(R,2)`

.

`iradon`

uses the filtered back-projection
algorithm to perform the inverse Radon transform. The filter is designed
directly in the frequency domain and then multiplied by the FFT of
the projections. The projections are zero-padded to a power of 2 before
filtering to prevent spatial domain aliasing and to speed up the FFT.

`I = iradon(R,theta,`

specifies
parameters to use in the inverse Radon transform. You can specify
any combination of the last four arguments. * interp*,

`filter`

`iradon`

uses
default values for any of these arguments that you omit.`interp`

specifies the type of interpolation
to use in the back projection. The available options are listed in
order of increasing accuracy and computational complexity.

Value | Description |
---|---|

| Nearest-neighbor interpolation |

| Linear interpolation (the default) |

| Spline interpolation |

`'pchip'` | Shape-preserving piecewise cubic interpolation |

`filter`

specifies the filter to use for frequency
domain filtering. `filter`

can be any of the following
values:

Value | Description |
---|---|

| Cropped Ram-Lak or ramp filter. This is the default.
The frequency response of this filter is | |

| Multiplies the Ram-Lak filter by a |

| Multiplies the Ram-Lak filter by a |

| Multiplies the Ram-Lak filter by a Hamming window |

| Multiplies the Ram-Lak filter by a Hann window |

`'None'` | No filtering. When you specify this value, `iradon` returns
unfiltered backprojection data. |

`frequency_scaling`

is a scalar in the range
(0,1] that modifies the filter by rescaling its frequency axis. The
default is 1. If `frequency_scaling`

is less than
1, the filter is compressed to fit into the frequency range `[0,frequency_scaling]`

,
in normalized frequencies; all frequencies above `frequency_scaling`

are
set to 0.

`output_size`

is a scalar that specifies the
number of rows and columns in the reconstructed image. If `output_size`

is
not specified, the size is determined from the length of the projections.

output_size = 2*floor(size(R,1)/(2*sqrt(2)))

If you specify `output_size`

, `iradon`

reconstructs
a smaller or larger portion of the image but does not change the scaling
of the data. If the projections were calculated with the `radon`

function,
the reconstructed image might not be the same size as the original
image.

`[I,H] = iradon(...)`

returns the frequency
response of the filter in the vector `H`

.

`[___]= iradon(gpuarrayR,___)`

reconstructs
the image `gpuarrayI`

from projection data in the
gpuArray `R`

. The input image and the return values
are 2-D gpuArrays. All other numeric arguments must be a `double`

or
a gpuArray of underlying class `double`

. This syntax
requires the Parallel
Computing Toolbox™.

The GPU implementation of this function supports only nearest-neighbor and linear interpolation methods for the back projection.

`R`

can be `double`

or `single`

.
All other numeric input arguments must be of class `double`

. `I`

has
the same class as `R`

. `H`

is `double`

.

`R`

can be a gpuArray of underlying class `double`

or `single`

.
All other numeric input arguments must be `double`

or
gpuArray of underlying class `double`

. `I`

has
the same class as `R`

. `H`

is a
gpuArray of underlying class `double`

.

`iradon`

uses the filtered back projection
algorithm to perform the inverse Radon transform. The filter is designed
directly in the frequency domain and then multiplied by the FFT of
the projections. The projections are zero-padded to a power of 2 before
filtering to prevent spatial domain aliasing and to speed up the FFT.

[1] Kak, A. C., and M. Slaney, *Principles
of Computerized Tomographic Imaging*, New York, NY, IEEE
Press, 1988.

Was this topic helpful?