Package gov.nih.mipav.model.algorithms

Class HartleyTransform2

java.lang.Object
java.lang.Thread
gov.nih.mipav.model.algorithms.AlgorithmBase
gov.nih.mipav.model.algorithms.HartleyTransform2
All Implemented Interfaces:
ActionListener, WindowListener, Runnable, EventListener
public class HartleyTransform2 extends AlgorithmBase
Smithsonian Astrophysical Observatory Submillimeter Receiver Laboratory am transform.c S. Paine rev. 2018 February 5 Discrete Fourier, Hartley, and Hilbert transforms.

  • Field Details

  • Constructor Details

    • HartleyTransform2

      public HartleyTransform2()

    • HartleyTransform2

      public HartleyTransform2(ModelImage transformImage, ModelImage inverseImage, ModelImage srcImg, int constructionMethod, int filterType, double f1, double f2, int filterOrder, double epsilon, double rs)

  • Method Details

    • testHartley

      public void testHartley()

    • fht2D

      public void fht2D(int yDim, int xDim, double[][] src, double[][] dst, boolean forwardTransform)

    • fht_dif

      public void fht_dif(double[] x, int n)
      void fht_dif(double *x, unsigned long n) Purpose: Computes the discrete Hartley transform of a real sequence x[0..n-1], using a radix 2 decimation-in-frequency FHT. n must be a power of 2. Entering this function, x[] is in normal order. On return, x[] contains the Hartley transform, stored in bit-reversed order. Arguments: double *x - array of n doubles, representing n real numbers unsigned long n - dimension of x, must be a power of 2 Return: none

    • fht_dif_iter

      static void fht_dif_iter(double[] x, int n)
      static void fht_dif_iter(double *x, unsigned long n) Purpose: Computes the discrete Hartley transform of a real sequence x[0..n-1], using an iterative radix 2 decimation-in-frequency FHT. n must be a power of 2. Entering this function, x[] is in normal order. On return, x[] contains the Hartley transform, stored in bit-reversed order. Arguments: double *x - array of n doubles, representing n real numbers unsigned long n - dimension of x, must be a power of 2 Return: none

    • fht_dif_iter_seq

      static void fht_dif_iter_seq(double[] x, int n)
      static void fht_dif_iter_seq(double *x, unsigned long n) Purpose: Computes the discrete Hartley transform of a real sequence x[0..n-1], using an iterative radix 2 decimation-in-frequency FHT. n must be a power of 2. Entering this function, x[] is in normal order. On return, x[] contains the Hartley transform, stored in bit-reversed order. The two inner loops of the FHT computation are ordered to favor sequential memory access at the expense of redundant trig computations. See J. Arndt, "Algorithms for Programmers," online at http://www.jjj.de/fxt/. Arguments: double *x - array of n doubles, representing n real numbers unsigned long n - dimension of x, must be a power of 2 Return: none

    • fht_dif_rec

      static void fht_dif_rec(double[] x, int n, int nbranch)
      static void fht_dif_rec(double *x, unsigned long n, int nbranch) Purpose: Computes the discrete Hartley transform of a real sequence x[0..n-1], using a radix 2 decimation-in-frequency FHT. If the computation is small enough to fit in cache, it is done iteratively. Otherwise, it is done recursively until the recursion descends to cache-sized chunks. n must be a power of 2. Entering this function, x[] must be in normal order. On return, x[] contains the Hartley transform, in bit-reversed order. To support OpenMP parallelism, nbranch keeps track of the number of active transforms at a given recursion level. On the first call to this function, nbranch should be 1. It is then doubled for each recursion. Arguments: double *x - array of n doubles, representing n real numbers unsigned long n - dimension of x, must be a power of 2 int nbranch - number of transforms at this recursion level Return: none

    • fht_dit

      public void fht_dit(double[] x, int n)
      void fht_dit(double *x, unsigned long n) Purpose: Computes the discrete Hartley transform of a real sequence x[0..n-1], using a radix 2 decimation-in-time FHT. n must be a power of 2. Entering this function, x[] must be in bit-reversed order. On return, x[] contains the Hartley transform, returned to normal order. Arguments: double *x - array of n doubles, representing n real numbers unsigned long n - dimension of x, must be a power of 2 Return: none

    • fht_dit_iter

      static void fht_dit_iter(double[] x, int n)
      static void fht_dit_iter(double *x, unsigned long n) Purpose: Computes the discrete Hartley transform of a real sequence x[0..n-1], using an iterative radix 2 decimation-in-time FHT. n must be a power of 2. Entering this function, x[] must be in bit-reversed order. On return, x[] contains the Hartley transform, returned to normal order. Arguments: double *x - array of n doubles, representing n real numbers unsigned long n - dimension of x, must be a power of 2 Return: none

    • fht_dit_iter_seq

      static void fht_dit_iter_seq(double[] x, int n)
      static void fht_dit_iter_seq(double *x, unsigned long n) Purpose: Computes the discrete Hartley transform of a real sequence x[0..n-1], using an iterative radix 2 decimation-in-time FHT. n must be a power of 2. Entering this function, x[] must be in bit-reversed order. On return, x[] contains the Hartley transform, returned to normal order. The two inner loops of the FHT computation are ordered to favor sequential memory access at the expense of redundant trig computations. See J. Arndt, "Algorithms for Programmers," online at http://www.jjj.de/fxt/. Arguments: double *x - array of n doubles, representing n real numbers unsigned long n - dimension of x, must be a power of 2 Return: none

    • fht_dit_rec

      static void fht_dit_rec(double[] x, int n, int nbranch)
      static void fht_dit_rec(double *x, unsigned long n, int nbranch) Purpose: Computes the discrete Hartley transform of a real sequence x[0..n-1], using a radix 2 decimation-in-time FHT. If the computation is small enough to fit in cache, it is done iteratively. Otherwise, it is done recursively until the recursion descends to cache-sized chunks. n must be a power of 2. Entering this function, x[] must be in bit-reversed order. On return, x[] contains the Hartley transform, returned to normal order. To support OpenMP parallelism, nbranch keeps track of the number of active transforms at a given recursion level. On the first call to this function, nbranch should be 1. It is then doubled for each recursion. Arguments: double *x - array of n doubles, representing n real numbers unsigned long n - dimension of x, must be a power of 2 int nbranch - number of transforms at this recursion level Return: none

    • bitrevorder

      private double[] bitrevorder(double[] X)

    • runAlgorithm

      public void runAlgorithm()
      Description copied from class: AlgorithmBase
      Actually runs the algorithm. Implemented by inheriting algorithms.
      Specified by:
      runAlgorithm in class AlgorithmBase

    • makeGaussianFilter

      private void makeGaussianFilter(double[] buffer, double rmsFreq)

    • makeButterworthFilter

      private void makeButterworthFilter(double[] buffer, double fr1, double fr2)
      DOCUMENT ME!
      Parameters:
      fr1 - DOCUMENT ME!
      fr2 - DOCUMENT ME!

    • makeEllipticFilter

      private void makeEllipticFilter(double[] buffer, double fr1, double fr2)

    • Chebyshev

      private double Chebyshev(int order, double w)

    • makeChebyshevTypeIFilter

      private void makeChebyshevTypeIFilter(double[] buffer, double fr1, double fr2)

    • makeChebyshevTypeIIFilter

      private void makeChebyshevTypeIIFilter(double[] buffer, double fr1, double fr2)

    • center

      private void center(double[] data)
      Centers the FFT for display purposes.
      Parameters:
      rData - real data buffer
      iData - imaginary data buffer