Functions | |
| NTTW_DLL_SYM nttw_integer | getIsum (nttw_integer *radon, const size_t n) |
| Returns the Isum of the FRT space. | |
| NTTW_DLL_SYM double | getIsum_double (double *radon, const size_t n) |
| Returns the Isum of the FRT space as a double. | |
| NTTW_DLL_SYM nttw_integer | getIsum_Integer (nttw_integer *radon, const size_t n, const nttw_integer modulus) |
| Returns the Isum (modulo the given modulus) of the FRT space. | |
| NTTW_DLL_SYM void | drt (const nttw_integer *field, nttw_integer *bins, const int p) |
| The Discrete Radon Transform (DRT) of Matus & Flusser, 1993 for 2D arrays. O(n^3). | |
| NTTW_DLL_SYM void | drt_dyadic (const nttw_integer *field, nttw_integer *bins, const int n) |
| The Dyadic Discrete Radon Transform (DRT) of Hsung et al, 1996 for 2D arrays. O(n^3). | |
| NTTW_DLL_SYM void | drt_blockcopy (nttw_integer *datain, nttw_integer *dataout, const int p) |
| The Discrete Radon Transform (FRT) of Matus & Flusser, 1993 for 2D arrays. This function uses the intelligent block copy method developed by Imants Svalbe. | |
| NTTW_DLL_SYM void | frt (nttw_integer *field, nttw_integer *bins, const int p) |
| The Fast Radon Transform (FRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). This is for prime lengths. | |
| NTTW_DLL_SYM void | frt_double (double *field, double *bins, const int p) |
| The Fast Radon Transform (FRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). This is for prime lengths. | |
| NTTW_DLL_SYM void | frt_dyadic (nttw_integer *field, nttw_integer *bins, const int n) |
| The Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM void | frt_dyadic_double (double *field, double *bins, const int n) |
| The Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM void | frt_dyadic_signed (long *field, long *bins, const int n) |
| The Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM nttw_integer | idrt (nttw_integer *bins, nttw_integer *result, const int p) |
| The Inverse Discrete Radon Transform (iDRT) of Matus & Flusser, 1993 for 2D arrays. O(n^3). | |
| NTTW_DLL_SYM nttw_integer | idrt_blockcopy (nttw_integer *datain, nttw_integer *dataout, const int p) |
| The Inverse Discrete Radon Transform (iDRT) of Matus & Flusser, 1993 for 2D arrays. This function uses the intelligent block copy method developed by Imants Svalbe. Note m=0 and m=p projections are interchanged in comparision to other DRT functions! | |
| NTTW_DLL_SYM nttw_integer | ifrt (nttw_integer *bins, nttw_integer *result, const int p, const int norm) |
| The Inverse Fast Radon Transform (iFRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM double | ifrt_double (double *bins, double *result, const int p, const int norm) |
| The Inverse Fast Radon Transform (iFRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM nttw_integer | ifrt_signed (nttw_integer *bins, long *result, const int p, const int norm) |
| The Inverse Fast Radon Transform (iFRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM nttw_integer | ifrt_dyadic (nttw_integer *bins, nttw_integer *result, const int n, const int norm) |
| The Inverse Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM double | ifrt_dyadic_double (double *bins, double *result, const int n, const int norm) |
| The Inverse Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM nttw_integer | ifrt_dyadic_signed (nttw_integer *bins, long *result, const int n, const int norm) |
| The Inverse Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). | |
| NTTW_DLL_SYM nttw_integer | ifrt_dyadic_signed2 (long *bins, long *result, const int n, const int norm) |
| The Inverse Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). Complete signed array version. | |
| NTTW_DLL_SYM void | getSlice (int m, fftw_complex *data, fftw_complex *slice, const int size) |
| Extracts the slice at slope m within the FFT space given by data. | |
| NTTW_DLL_SYM void | getSlice_Perp (int s, fftw_complex *data, fftw_complex *slice, const int size) |
| Extracts the slice at (perp) slope s within the FFT space given by data. | |
| NTTW_DLL_SYM void | setSlice (int m, fftw_complex *data, fftw_complex *slice, const int size) |
| Sets the slice at slope m within the FFT space given by data. | |
| NTTW_DLL_SYM void | setSlice_Perp (int s, fftw_complex *data, fftw_complex *slice, const int size) |
| Sets the slice at (perp) slope s within the FFT space given by data. | |
| NTTW_DLL_SYM void | dyadic_oversample (nttw_big_integer *data, const int n) |
| Constructs the oversample filter required to make FFT space isotropic for dyadic sizes. | |
| NTTW_DLL_SYM void | dyadic_1D_filter (nttw_big_integer *data, const int n) |
| Constructs the 1D oversample filter required to make FFT space isotropic for dyadic sizes. | |
| NTTW_DLL_SYM void | filter_oversampling (fftw_complex *fftSpace, nttw_big_integer *samples, const int n) |
| Filters the oversampling within the FFT space for dyadic sizes given by the filter. | |
| drt | ( | const nttw_integer * | field, | |
| nttw_integer * | bins, | |||
| const int | p | |||
| ) |
The Discrete Radon Transform (DRT) of Matus & Flusser, 1993 for 2D arrays. O(n^3).
| field | Contains the data to be transformed. Must be p by p array. | |
| bins | It is assumed that this is already a pointer that has memory is allocated for each bin. The function only does internal initializing with no allocation. It must have size of p+1 by p. | |
| p | The prime which is the size of the square array. |
Init
Get Projections where m denotes projection number
Projection angle
Row
Compute Row
Translate
Compute Column (in 1D)
< Next pixel
Columns
Translate
| drt_blockcopy | ( | nttw_integer * | datain, | |
| nttw_integer * | dataout, | |||
| const int | p | |||
| ) |
The Discrete Radon Transform (FRT) of Matus & Flusser, 1993 for 2D arrays. This function uses the intelligent block copy method developed by Imants Svalbe.
Note that the definition of the m=p projection is non-standard compared to other routines in the libraries.
| datain | Contains the data to be transformed. Must be p by p array in 1D form. | |
| dataout | It is assumed that this is already a pointer that has memory is allocated for each pixel. The function only does internal initializing with no allocation. It must have size of p+1 by p. | |
| p | The prime which is the size of the square array. |
variables /
Initialise /
transform m = 0 /
transform (1 < m < p-1)
| drt_dyadic | ( | const nttw_integer * | field, | |
| nttw_integer * | bins, | |||
| const int | n | |||
| ) |
The Dyadic Discrete Radon Transform (DRT) of Hsung et al, 1996 for 2D arrays. O(n^3).
| field | Contains the data to be transformed. Must be n by n array. | |
| bins | It is assumed that this is already a pointer that has memory is allocated for each bin. The function only does internal initializing with no allocation. It must have size of n+n/2 by n. | |
| n | The dyadic length (32,64,...512,1024,2048,...) which is the size of the square array. |
Init
Get Projections where m denotes projection number
Projection angle
Row
Compute Row
Translate
Compute Column (in 1D)
< Next pixel
Perp Projection Angle
Column
Translate
Compute Row (in 1D)
< Next pixel
| dyadic_1D_filter | ( | nttw_big_integer * | data, | |
| const int | n | |||
| ) |
| dyadic_oversample | ( | nttw_big_integer * | data, | |
| const int | n | |||
| ) |
| filter_oversampling | ( | fftw_complex * | fftSpace, | |
| nttw_big_integer * | samples, | |||
| const int | n | |||
| ) |
Filters the oversampling within the FFT space for dyadic sizes given by the filter.
Use the dyadic_oversample() function to construct the filter.
Correct Coefficients
Correct Coefficients
| frt | ( | nttw_integer * | field, | |
| nttw_integer * | bins, | |||
| const int | p | |||
| ) |
The Fast Radon Transform (FRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). This is for prime lengths.
| field | Contains the data to be transformed. Must be p by p array. | |
| bins | It is assumed that this is already a pointer that has memory is allocated for each bin. The function only does internal initializing with no allocation. It must have size of p+1 by p. | |
| p | The prime which is the size of the square array. |
FFT image
Extract slices
Clean up
| frt_double | ( | double * | field, | |
| double * | bins, | |||
| const int | p | |||
| ) |
The Fast Radon Transform (FRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). This is for prime lengths.
This function is the double version. There is minimal rounding and casting between the FFT and the image.
| field | Contains the data to be transformed. Must be p by p array. | |
| bins | It is assumed that this is already a pointer that has memory is allocated for each bin. The function only does internal initializing with no allocation. It must have size of p+1 by p. | |
| p | The prime which is the size of the square array. |
FFT image
Copy data to real part
Extract slices
Clean up
| frt_dyadic | ( | nttw_integer * | field, | |
| nttw_integer * | bins, | |||
| const int | n | |||
| ) |
The Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
| field | Contains the data to be transformed. Must be n by n array. | |
| bins | It is assumed that this is already a pointer that has memory is allocated for each bin. The function only does internal initializing with no allocation. It must have size of n+n/2 by n. | |
| n | The dyadic size which is the size of the square array. |
FFT image
Extract slices
Clean up
| frt_dyadic_double | ( | double * | field, | |
| double * | bins, | |||
| const int | n | |||
| ) |
The Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
This function is the double version. There is minimal rounding and casting between the FFT and the image.
| field | Contains the data to be transformed. Must be n by n array. | |
| bins | It is assumed that this is already a pointer that has memory is allocated for each bin. The function only does internal initializing with no allocation. It must have size of n+n/2 by n. | |
| n | The dyadic size which is the size of the square array. |
FFT image
Copy data to real part
Extract slices
Clean up
| frt_dyadic_signed | ( | long * | field, | |
| long * | bins, | |||
| const int | n | |||
| ) |
The Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
| field | Contains the signed data to be transformed. Must be n by n array. | |
| bins | It is assumed that this is already a pointer that has memory is allocated for each bin. The function only does internal initializing with no allocation. It must have size of n+n/2 by n. | |
| n | The dyadic size which is the size of the square array. |
FFT image
Extract slices
Clean up
| getIsum | ( | nttw_integer * | radon, | |
| const size_t | n | |||
| ) |
| getIsum_double | ( | double * | radon, | |
| const size_t | n | |||
| ) |
| getIsum_Integer | ( | nttw_integer * | radon, | |
| const size_t | n, | |||
| const nttw_integer | modulus | |||
| ) |
| getSlice | ( | int | m, | |
| fftw_complex * | data, | |||
| fftw_complex * | slice, | |||
| const int | size | |||
| ) |
| getSlice_Perp | ( | int | s, | |
| fftw_complex * | data, | |||
| fftw_complex * | slice, | |||
| const int | size | |||
| ) |
| idrt | ( | nttw_integer * | bins, | |
| nttw_integer * | result, | |||
| const int | p | |||
| ) |
The Inverse Discrete Radon Transform (iDRT) of Matus & Flusser, 1993 for 2D arrays. O(n^3).
| bins | Contains the data to be inverse transformed and should be of size p+1 by p. | |
| result | It is assumed that this is already a pointer that has memory is allocated for each pixel. The function only does internal initializing with no allocation. It must have size of p by p. | |
| p | The prime which is the size of the square array. |
Calculate the Isum from the first row
Get Projections where j denotes projection number
Get the last projection of rows
| idrt_blockcopy | ( | nttw_integer * | datain, | |
| nttw_integer * | dataout, | |||
| const int | p | |||
| ) |
The Inverse Discrete Radon Transform (iDRT) of Matus & Flusser, 1993 for 2D arrays. This function uses the intelligent block copy method developed by Imants Svalbe. Note m=0 and m=p projections are interchanged in comparision to other DRT functions!
Note that the definition of the m=p projection is non-standard compared to other routines in the libraries.
| datain | Contains the data to be inverse transformed. Must be p+1 by p array in 1D form. | |
| dataout | It is assumed that this is already a pointer that has memory is allocated for each pixel. The function only does internal initializing with no allocation. It must have size of p by p. | |
| p | The prime which is the size of the square array. |
variables
Initialise
inverse transform m = 0
inverse transform (1 < m < p-1)
subtract total and divide by p
<
| ifrt | ( | nttw_integer * | bins, | |
| nttw_integer * | result, | |||
| const int | p, | |||
| const int | norm | |||
| ) |
The Inverse Fast Radon Transform (iFRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
| bins | Contains the data to be inverse transformed and should be of size p+1 by p. | |
| result | It is assumed that this is already a pointer that has memory is allocated for each pixel. The function only does internal initializing with no allocation. It must have size of p by p. | |
| p | The prime which is the size of the square array. | |
| norm | Normalise the result? |
FFT projections
Inverse FFT to get result
Cleanup
| ifrt_double | ( | double * | bins, | |
| double * | result, | |||
| const int | p, | |||
| const int | norm | |||
| ) |
The Inverse Fast Radon Transform (iFRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
This function is the double version. There is minimal rounding and casting between the FFT and the image.
| bins | Contains the data to be inverse transformed and should be of size p+1 by p. | |
| result | It is assumed that this is already a pointer that has memory is allocated for each pixel. The function only does internal initializing with no allocation. It must have size of p by p. | |
| p | The prime which is the size of the square array. | |
| norm | Normalise the result? |
FFT projections
Inverse FFT to get result
Copy data from real part
Cleanup
| ifrt_dyadic | ( | nttw_integer * | bins, | |
| nttw_integer * | result, | |||
| const int | n, | |||
| const int | norm | |||
| ) |
The Inverse Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
| bins | Contains the data to be inverse transformed. Must be n by n+n/2 array. | |
| result | The recontructed image. It must have size of n by n. | |
| n | The dyadic size which is the size of the square array. |
FFT projections
Correct for oversampling
Inverse FFT to get result
Cleanup
| ifrt_dyadic_double | ( | double * | bins, | |
| double * | result, | |||
| const int | n, | |||
| const int | norm | |||
| ) |
The Inverse Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
This function is the double version. There is minimal rounding and casting between the FFT and the image.
| bins | Contains the data to be inverse transformed. Must be n by n+n/2 array. | |
| result | The recontructed image. It must have size of n by n. | |
| n | The dyadic size which is the size of the square array. |
FFT projections
Correct for oversampling
Inverse FFT to get result
Copy data from real part
Cleanup
| ifrt_dyadic_signed | ( | nttw_integer * | bins, | |
| long * | result, | |||
| const int | n, | |||
| const int | norm | |||
| ) |
The Inverse Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
| bins | Contains the data to be inverse transformed. Must be n by n+n/2 array. | |
| result | The signed recontructed image. It must have size of n by n. | |
| n | The dyadic size which is the size of the square array. |
FFT projections
Correct for oversampling
Inverse FFT to get result
Cleanup
| ifrt_dyadic_signed2 | ( | long * | bins, | |
| long * | result, | |||
| const int | n, | |||
| const int | norm | |||
| ) |
The Inverse Dyadic Fast Radon Transform (FRT) of Hsung et al, 1996 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT). Complete signed array version.
| bins | Contains the signed data to be inverse transformed. Must be n by n+n/2 array. | |
| result | The signed recontructed image. It must have size of n by n. | |
| n | The dyadic size which is the size of the square array. |
FFT projections
Correct for oversampling
Inverse FFT to get result
Cleanup
| ifrt_signed | ( | nttw_integer * | bins, | |
| long * | result, | |||
| const int | p, | |||
| const int | norm | |||
| ) |
The Inverse Fast Radon Transform (iFRT) of Matus & Flusser, 1993 for 2D arrays. Fourier Slice Theorem version. Complexity is linear logarithmic in time (same as a 2D FFT).
This is the signed version, ideally suited for signed data such as noise.
| bins | Contains the data to be inverse transformed and should be of size p+1 by p. | |
| result | It is assumed that this is already a pointer that has memory is allocated for each pixel. The function only does internal initializing with no allocation. It must have size of p by p. | |
| p | The prime which is the size of the square array. | |
| norm | Normalise the result? |
FFT projections
Inverse FFT to get result
Cleanup
| setSlice | ( | int | m, | |
| fftw_complex * | data, | |||
| fftw_complex * | slice, | |||
| const int | size | |||
| ) |
1.7.1