# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English version of the page.

## Syntax

```I = iradon(R, theta) I = iradon(R,theta,interp,filter,frequency_scaling,output_size) [I,H] = iradon(...) [___]= iradon(gpuarrayR,___) ```

## Description

`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,interp,filter,frequency_scaling,output_size)` specifies parameters to use in the inverse Radon transform. You can specify any combination of the last four arguments. `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'`

Nearest-neighbor interpolation

`'linear'`

Linear interpolation (the default)

`'spline'`

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

`'Ram-Lak'`

Cropped Ram-Lak or ramp filter. This is the default. The frequency response of this filter is | `f` |. Because this filter is sensitive to noise in the projections, one of the filters listed below might be preferable. These filters multiply the Ram-Lak filter by a window that deemphasizes high frequencies.

`'Shepp-Logan'`

Multiplies the Ram-Lak filter by a `sinc` function

`'Cosine'`

Multiplies the Ram-Lak filter by a `cosine` function

`'Hamming'`

Multiplies the Ram-Lak filter by a Hamming window

`'Hann'`

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™.

### Note

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

## Class Support

`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`.

## Examples

collapse all

Create an image of the phantom. Display the image.

```P = phantom(128); imshow(P) title('Original image')```

Perform a Radon transform of the image.

`R = radon(P,0:179);`

Perform filtered backprojection.

`I1 = iradon(R,0:179);`

Perform unfiltered backprojection.

`I2 = iradon(R,0:179,'linear','none');`

Display the reconstructed images.

```figure subplot(1,2,1) imshow(I1,[]) title('Filtered Backprojection') subplot(1,2,2) imshow(I2,[]) title('Unfiltered Backprojection')```

Create an image of the phantom.

`P = phantom(128);`

Perform a Radon transform of the image, then get the projection vector corresponding to a projection at a 45 degree angle.

```R = radon(P,0:179); r45 = R(:,46);```

Perform the inverse Radon transform of this single projection vector. The `iradon` syntax does not allow you to do this directly, because if `theta` is a scalar it is treated as an increment. You can accomplish the task by passing in two copies of the projection vector and then dividing the result by 2.

`I = iradon([r45 r45], [45 45])/2;`

Display the result.

```imshow(I, []) title('Backprojection from 45 degrees')```

Calculate the inverse Radon transform on a GPU.

```P = gpuArray(phantom(128)); R = radon(P,0:179); I1 = iradon(R,0:179); I2 = iradon(R,0:179,'linear','none'); subplot(1,3,1), imshow(P), title('Original') subplot(1,3,2), imshow(I1), title('Filtered backprojection') subplot(1,3,3), imshow(I2,[]), title('Unfiltered backprojection') ```

## Algorithms

`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.

## References

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