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 | |||
) |