java.lang.Object
- java.lang.Thread
- - gov.nih.mipav.model.algorithms.AlgorithmBase
  - - gov.nih.mipav.model.algorithms.filters.PyWavelets

All Implemented Interfaces:

java.awt.event.ActionListener, java.awt.event.WindowListener, java.lang.Runnable, java.util.EventListener
```
public class PyWavelets
extends AlgorithmBase
```
Copyright (c) 2006-2012 Filip Wasilewski Copyright (c) 2012-2017 The PyWavelets Developers Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private class`	`PyWavelets.ArrayInfo`
`private class`	`PyWavelets.BaseWavelet`
`private static class`	`PyWavelets.Coefficient`
`private class`	`PyWavelets.ContinuousWavelet`
`private static class`	`PyWavelets.DiscreteTransformType`
`class`	`PyWavelets.DiscreteWavelet`
`static class`	`PyWavelets.MODE`
`private static class`	`PyWavelets.SYMMETRY`
`static class`	`PyWavelets.WAVELET_NAME`

Nested classes/interfaces inherited from class java.lang.Thread
java.lang.Thread.State, java.lang.Thread.UncaughtExceptionHandler

Field Summary

Fields
Modifier and Type	Field	Description
`private int[]`	`axes`
`(package private) static double[][][]`	`bior_double`
`(package private) static double[]`	`bior1_0_double`
`(package private) static double[]`	`bior1_1_double`
`(package private) static double[]`	`bior1_3_double`
`(package private) static double[]`	`bior1_5_double`
`(package private) static double[][]`	`bior1_double`
`(package private) static double[]`	`bior2_0_double`
`(package private) static double[]`	`bior2_2_double`
`(package private) static double[]`	`bior2_4_double`
`(package private) static double[]`	`bior2_6_double`
`(package private) static double[]`	`bior2_8_double`
`(package private) static double[][]`	`bior2_double`
`(package private) static double[]`	`bior3_0_double`
`(package private) static double[]`	`bior3_1_double`
`(package private) static double[]`	`bior3_3_double`
`(package private) static double[]`	`bior3_5_double`
`(package private) static double[]`	`bior3_7_double`
`(package private) static double[]`	`bior3_9_double`
`(package private) static double[][]`	`bior3_double`
`(package private) static double[]`	`bior4_0_double`
`(package private) static double[]`	`bior4_4_double`
`(package private) static double[][]`	`bior4_double`
`(package private) static double[]`	`bior5_0_double`
`(package private) static double[]`	`bior5_5_double`
`(package private) static double[][]`	`bior5_double`
`(package private) static double[]`	`bior6_0_double`
`(package private) static double[]`	`bior6_8_double`
`(package private) static double[][]`	`bior6_double`
`(package private) static double[][]`	`coif_double`
`(package private) static double[]`	`coif1_double`
`(package private) static double[]`	`coif10_double`
`(package private) static double[]`	`coif11_double`
`(package private) static double[]`	`coif12_double`
`(package private) static double[]`	`coif13_double`
`(package private) static double[]`	`coif14_double`
`(package private) static double[]`	`coif15_double`
`(package private) static double[]`	`coif16_double`
`(package private) static double[]`	`coif17_double`
`(package private) static double[]`	`coif2_double`
`(package private) static double[]`	`coif3_double`
`(package private) static double[]`	`coif4_double`
`(package private) static double[]`	`coif5_double`
`(package private) static double[]`	`coif6_double`
`(package private) static double[]`	`coif7_double`
`(package private) static double[]`	`coif8_double`
`(package private) static double[]`	`coif9_double`
`(package private) static double[][]`	`db_double`
`(package private) static double[]`	`db1_double`
`(package private) static double[]`	`db10_double`
`(package private) static double[]`	`db11_double`
`(package private) static double[]`	`db12_double`
`(package private) static double[]`	`db13_double`
`(package private) static double[]`	`db14_double`
`(package private) static double[]`	`db15_double`
`(package private) static double[]`	`db16_double`
`(package private) static double[]`	`db17_double`
`(package private) static double[]`	`db18_double`
`(package private) static double[]`	`db19_double`
`(package private) static double[]`	`db2_double`
`(package private) static double[]`	`db20_double`
`(package private) static double[]`	`db21_double`
`(package private) static double[]`	`db22_double`
`(package private) static double[]`	`db23_double`
`(package private) static double[]`	`db24_double`
`(package private) static double[]`	`db25_double`
`(package private) static double[]`	`db26_double`
`(package private) static double[]`	`db27_double`
`(package private) static double[]`	`db28_double`
`(package private) static double[]`	`db29_double`
`(package private) static double[]`	`db3_double`
`(package private) static double[]`	`db30_double`
`(package private) static double[]`	`db31_double`
`(package private) static double[]`	`db32_double`
`(package private) static double[]`	`db33_double`
`(package private) static double[]`	`db34_double`
`(package private) static double[]`	`db35_double`
`(package private) static double[]`	`db36_double`
`(package private) static double[]`	`db37_double`
`(package private) static double[]`	`db38_double`
`(package private) static double[]`	`db4_double`
`(package private) static double[]`	`db5_double`
`(package private) static double[]`	`db6_double`
`(package private) static double[]`	`db7_double`
`(package private) static double[]`	`db8_double`
`(package private) static double[]`	`db9_double`
`(package private) static double[]`	`dmey_double`
`private boolean`	`doBayesShrinkThresholdComputation`
`static int`	`FILTER_GREATER`
`static int`	`FILTER_HARD`
`static int`	`FILTER_LESS`
`static int`	`FILTER_NN_GARROTE`
`static int`	`FILTER_NONE`
`static int`	`FILTER_SOFT`
`static int`	`FILTER_THRESHOLD_FIRM`
`(package private) int[]`	`filterType`
`(package private) double[]`	`filterVal1`
`(package private) double[]`	`filterVal2`
`private ModelImage`	`imageA`
`private ModelImage`	`imageA_filter`
`private ModelImage`	`imageAn`
`private ModelImage`	`imageAn_filter`
`private ModelImage[]`	`imageAnSWT`
`private ModelImage[]`	`imageAnSWT_filter`
`private ModelImage`	`imageD`
`private ModelImage`	`imageD_filter`
`private ModelImage[]`	`imageDn`
`private ModelImage[]`	`imageDn_filter`
`private ModelImage`	`imageH`
`private ModelImage`	`imageH_filter`
`private ModelImage`	`imageHH`
`private ModelImage`	`imageHH_filter`
`private ModelImage`	`imageHHH`
`private ModelImage`	`imageHHH_filter`
`private ModelImage[]`	`imageHHHn`
`private ModelImage[]`	`imageHHHn_filter`
`private ModelImage`	`imageHHL`
`private ModelImage`	`imageHHL_filter`
`private ModelImage[]`	`imageHHLn`
`private ModelImage[]`	`imageHHLn_filter`
`private ModelImage[]`	`imageHHn`
`private ModelImage[]`	`imageHHn_filter`
`private ModelImage`	`imageHL`
`private ModelImage`	`imageHL_filter`
`private ModelImage`	`imageHLH`
`private ModelImage`	`imageHLH_filter`
`private ModelImage[]`	`imageHLHn`
`private ModelImage[]`	`imageHLHn_filter`
`private ModelImage`	`imageHLL`
`private ModelImage`	`imageHLL_filter`
`private ModelImage[]`	`imageHLLn`
`private ModelImage[]`	`imageHLLn_filter`
`private ModelImage[]`	`imageHLn`
`private ModelImage[]`	`imageHLn_filter`
`private ModelImage[]`	`imageHn`
`private ModelImage[]`	`imageHn_filter`
`private ModelImage`	`imageL`
`private ModelImage`	`imageL_filter`
`private ModelImage`	`imageLH`
`private ModelImage`	`imageLH_filter`
`private ModelImage`	`imageLHH`
`private ModelImage`	`imageLHH_filter`
`private ModelImage[]`	`imageLHHn`
`private ModelImage[]`	`imageLHHn_filter`
`private ModelImage`	`imageLHL`
`private ModelImage`	`imageLHL_filter`
`private ModelImage[]`	`imageLHLn`
`private ModelImage[]`	`imageLHLn_filter`
`private ModelImage[]`	`imageLHn`
`private ModelImage[]`	`imageLHn_filter`
`private ModelImage`	`imageLL`
`private ModelImage`	`imageLL_filter`
`private ModelImage`	`imageLLH`
`private ModelImage`	`imageLLH_filter`
`private ModelImage[]`	`imageLLHn`
`private ModelImage[]`	`imageLLHn_filter`
`private ModelImage`	`imageLLL`
`private ModelImage`	`imageLLL_filter`
`private ModelImage`	`imageLLLn`
`private ModelImage`	`imageLLLn_filter`
`private ModelImage[]`	`imageLLLnSWT`
`private ModelImage[]`	`imageLLLnSWT_filter`
`private ModelImage[]`	`imageLLn`
`private ModelImage[]`	`imageLLn_filter`
`private ModelImage[]`	`imageLn`
`private ModelImage[]`	`imageLn_filter`
`private ModelImage`	`imageV`
`private ModelImage`	`imageV_filter`
`private ModelImage[]`	`imageVn`
`private ModelImage[]`	`imageVn_filter`
`private int`	`levels`
`private PyWavelets.MODE[]`	`modes`
`static int`	`MULTILEVEL_DWT`
`private double[]`	`noiseStandardDeviation`
`private boolean`	`showFilteredTransform`
`private boolean`	`showTransform`
`static int`	`SINGLE_LEVEL_DWT`
`(package private) static double`	`sqrt2_double`
`private int`	`start_level`
`static int`	`SWT`
`(package private) static double[][]`	`sym_double`
`(package private) static double[]`	`sym10_double`
`(package private) static double[]`	`sym11_double`
`(package private) static double[]`	`sym12_double`
`(package private) static double[]`	`sym13_double`
`(package private) static double[]`	`sym14_double`
`(package private) static double[]`	`sym15_double`
`(package private) static double[]`	`sym16_double`
`(package private) static double[]`	`sym17_double`
`(package private) static double[]`	`sym18_double`
`(package private) static double[]`	`sym19_double`
`(package private) static double[]`	`sym2_double`
`(package private) static double[]`	`sym20_double`
`(package private) static double[]`	`sym3_double`
`(package private) static double[]`	`sym4_double`
`(package private) static double[]`	`sym5_double`
`(package private) static double[]`	`sym6_double`
`(package private) static double[]`	`sym7_double`
`(package private) static double[]`	`sym8_double`
`(package private) static double[]`	`sym9_double`
`private int`	`tType`
`private boolean`	`useNoiseStdConstructor`
`private PyWavelets.DiscreteWavelet[]`	`wavelets`

Fields inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase
destFlag, destImage, image25D, mask, maxProgressValue, minProgressValue, multiThreadingEnabled, nthreads, progress, progressModulus, progressStep, runningInSeparateThread, separable, srcImage, threadStopped

Fields inherited from class java.lang.Thread
MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY

Constructor Summary

Constructors
Constructor	Description
`PyWavelets()`
`PyWavelets(ModelImage srcImg, double[] noiseStandardDeviation)`
`PyWavelets(ModelImage dstImg, ModelImage srcImg, int tType, PyWavelets.WAVELET_NAME[] names, int[] orders, PyWavelets.MODE[] modes, int[] axes, int[] filterType, double[] filterVal1, double[] filterVal2, boolean showTransform, boolean showFilteredTransform, int levels, int start_level, boolean doBayesShrinkThresholdComputation)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private double[]`	`_integrate(double[] arr, double step)`
`private double[][][]`	`_sign(double[][] xReal, double[][] xImag)`
`private double[][][]`	`_soft(double[][] xReal, double[][] xImag, double thresh)`
`private double`	`BayesShrinkThresholdComputation(double[] data, double noise_var)`
`(package private) PyWavelets.ContinuousWavelet`	`blank_continuous_wavelet()`
`private PyWavelets.DiscreteWavelet`	`blank_discrete_wavelet(int filters_length)`
`double[][][]`	`BM3Dwavedec2(double[][] patch, int level)`
`double[][]`	`BM3Dwaverec2(double[][] bior_img, int level)`
`private double`	`central_frequency(PyWavelets.ContinuousWavelet wavelet, int precision)`
`private double`	`central_frequency(PyWavelets.DiscreteWavelet wavelet, int precision)`
`private void`	`cgau(double[] input, double[] output_r, double[] output_i, int N, int number)`
`private boolean`	`check_coefficients(PyWavelets.DiscreteWavelet w)`
`private boolean`	`check_coefficients_biorthogonal(PyWavelets.DiscreteWavelet w)`
`(package private) boolean`	`check_coefficients_orthogonal(PyWavelets.DiscreteWavelet w)`
`private int`	`check_level(int sizes, int dec_lens, int level)`
`private boolean`	`check_reconstruction(PyWavelets.MODE mode, PyWavelets.DiscreteWavelet wavelet)`
`private void`	`cmor(double[] input, double[] output_r, double[] output_i, int N, double FB, double FC)`
`private boolean`	`coeffs_ok13or23(java.util.HashMap<java.lang.String,double[][][]> coeffs)`
`private boolean`	`coeffs_ok2(java.util.HashMap<java.lang.String,double[][]> coeffs)`
`private boolean`	`coeffs_ok3(java.util.HashMap<java.lang.String,double[][][]> coeffs)`
`(package private) PyWavelets.ContinuousWavelet`	`continuous_wavelet(PyWavelets.WAVELET_NAME name, int order)`
`private double[]`	`convolve(double[] a, double[] b)`
`(package private) PyWavelets.DiscreteWavelet`	`copy_discrete_wavelet(PyWavelets.DiscreteWavelet base)`
`private double[][][]`	`cwt(double[] data, double[] scales, PyWavelets.ContinuousWavelet w, double sampling_period, java.lang.String method)`
`private double[][]`	`cwt_psi_single(double[] data_t, PyWavelets.ContinuousWavelet wavelet, int output_len)`
`private int`	`dec_a(double[] input, int input_len, PyWavelets.DiscreteWavelet wavelet, double[] output, int output_len, PyWavelets.MODE mode)`
`private int`	`dec_d(double[] input, int input_len, PyWavelets.DiscreteWavelet wavelet, double[] output, int output_len, PyWavelets.MODE mode)`
`int`	`decompose1DSignal()`
`PyWavelets.DiscreteWavelet`	`discrete_wavelet(PyWavelets.WAVELET_NAME name, int order)`
`double[]`	`downcoef(boolean do_dec_a, double[] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int level)`
`double[]`	`downcoef(char part, double[] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int level)`
`private int`	`downcoef_axis(double[][][] input, PyWavelets.ArrayInfo input_info, double[][][] output, PyWavelets.ArrayInfo output_info, PyWavelets.DiscreteWavelet wavelet, int axis, PyWavelets.Coefficient coef, PyWavelets.MODE dwt_mode, int swt_level, PyWavelets.DiscreteTransformType transform)`
`private int`	`downcoef_axis(double[][] input, PyWavelets.ArrayInfo input_info, double[][] output, PyWavelets.ArrayInfo output_info, PyWavelets.DiscreteWavelet wavelet, int axis, PyWavelets.Coefficient coef, PyWavelets.MODE dwt_mode, int swt_level, PyWavelets.DiscreteTransformType transform)`
`private int`	`downsampling_convolution(double[] input, int N, double[] filter, int F, double[] output, int step, PyWavelets.MODE mode)`
`private int`	`downsampling_convolution_periodization(double[] input, int N, double[] filter, int F, double[] output, int step, int fstep)`
`private double[][][][]`	`dwt(double[][][] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int axis)`
`private double[][][]`	`dwt(double[][] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int axis)`
`private double[][]`	`dwt(double[] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode)`
`private double[][][][]`	`dwt_axis(double[][][] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int axis)`
`private double[][][]`	`dwt_axis(double[][] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int axis)`
`private int`	`dwt_buffer_length(int input_len, int filter_len, PyWavelets.MODE mode)`
`private int`	`dwt_coeff_len(int data_len, int filter_len, PyWavelets.MODE mode)`
`short`	`dwt_max_level(int input_len, int filter_len)`
`short`	`dwt_max_level(int input_len, PyWavelets.DiscreteWavelet w)`
`private double[][]`	`dwt_single(double[] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode)`
`double[][][][]`	`dwt2(double[][][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`double[][][]`	`dwt2(double[][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`private double[][][][]`	`dwt3(double[][][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`java.util.HashMap<java.lang.String,double[][]>`	`dwtn(double[][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int[] axes)`
`java.util.HashMap<java.lang.String,double[][]>`	`dwtn2(double[][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int[] axes)`
`java.util.HashMap<java.lang.String,double[][][]>`	`dwtn23(double[][][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int[] axes)`
`java.util.HashMap<java.lang.String,double[][][]>`	`dwtn3(double[][][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int[] axes)`
`private void`	`fbsp(double[] input, double[] output_r, double[] output_i, int N, int M, double FB, double FC)`
`private void`	`filter(double[] data, int filterType, double filterVal1, double filterVal2)`
`int`	`fix_output_length(int output_length, int keep_length)`
`private void`	`free_discrete_wavelet(PyWavelets.DiscreteWavelet w)`
`private void`	`gaus(double[] input, double[] output, int N, int number)`
`int`	`get_keep_length(int output_length, int level, int filter_length)`
`int`	`get_right_extent_length(int output_length, int keep_length)`
`double[][]`	`greater(double[][] data, double value, double substitute)`
`double[]`	`greater(double[] data, double value, double substitute)`
`double[][][]`	`hard(double[][] dataReal, double[][] dataImag, double value, double substituteReal, double substituteImag)`
`double[][]`	`hard(double[][] data, double value, double substitute)`
`double[][]`	`hard(double[] dataReal, double[] dataImag, double value, double substituteReal, double substituteImag)`
`double[]`	`hard(double[] data, double value, double substitute)`
`private int`	`idwt(double[] coeffs_a, int coeffs_a_len, double[] coeffs_d, int coeffs_d_len, double[] output, int output_len, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode)`
`private double[][][]`	`idwt_axis(double[][][] coefs_a, double[][][] coefs_d, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int axis)`
`private double[][]`	`idwt_axis(double[][] coefs_a, double[][] coefs_d, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int axis)`
`private int`	`idwt_axis(double[] coefs_a, PyWavelets.ArrayInfo a_info, double[] coefs_d, PyWavelets.ArrayInfo d_info, double[] output, PyWavelets.ArrayInfo output_info, PyWavelets.DiscreteWavelet wavelet, int axis, PyWavelets.MODE mode)`
`private int`	`idwt_buffer_length(int coeffs_len, int filter_len, PyWavelets.MODE mode)`
`private double[]`	`idwt_single(double[] cA, double[] cD, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode)`
`private double[][][]`	`idwt13(double[][][][] coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`double[][]`	`idwt2(double[][][] coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`double[][][]`	`idwt23(double[][][][] coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`double[][][]`	`idwt3(double[][][][] coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`private double[][][]`	`idwtn13(java.util.HashMap<java.lang.String,double[][][]> coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int[] axes)`
`private double[][]`	`idwtn2(java.util.HashMap<java.lang.String,double[][]> coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int[] axes)`
`private double[][][]`	`idwtn23(java.util.HashMap<java.lang.String,double[][][]> coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int[] axes)`
`private double[][][]`	`idwtn3(java.util.HashMap<java.lang.String,double[][][]> coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int[] axes)`
`private double[][]`	`integrate_wavelet(PyWavelets.ContinuousWavelet wavelet, int precision)`
`private double[][]`	`integrate_wavelet(PyWavelets.DiscreteWavelet wavelet, int precision)`
`private double[][]`	`inverse_filter_bank(PyWavelets.DiscreteWavelet w)`
`private int`	`is_discrete_wavelet(PyWavelets.WAVELET_NAME name)`
`private double[]`	`iswt(double[][] coeffs, PyWavelets.DiscreteWavelet wavelet)`
`private double[][]`	`iswt2(double[][][] coeffs, PyWavelets.DiscreteWavelet[] wavelet)`
`private double[][][]`	`iswtn(java.util.HashMap<java.lang.String,double[][][]>[] coeffs, PyWavelets.DiscreteWavelet[] wavelet, int[] axes)`
`private double[][]`	`iswtn2(java.util.HashMap<java.lang.String,double[][]>[] coeffs, PyWavelets.DiscreteWavelet[] wavelet, int[] axes)`
`double[]`	`keep(double[] arr, int keep_length)`
`double[][]`	`less(double[][] data, double value, double substitute)`
`double[]`	`less(double[] data, double value, double substitute)`
`private double[]`	`linspace(double LB, double UB, int N)`
`private void`	`mexh(double[] input, double[] output, int N)`
`private void`	`morl(double[] input, double[] output, int N)`
`double[][]`	`nn_garrote(double[] dataReal, double[] dataImag, double value, double substituteReal, double substituteImag)`
`double[]`	`nn_garrote(double[] data, double value, double substitute)`
`private int`	`rec_a(double[] coeffs_a, int coeffs_len, PyWavelets.DiscreteWavelet wavelet, double[] output, int output_len)`
`private int`	`rec_d(double[] coeffs_d, int coeffs_len, PyWavelets.DiscreteWavelet wavelet, double[] output, int output_len)`
`private int`	`reconstruction_buffer_length(int coeffs_len, int filter_len)`
`double[][]`	`ref_cgau(double LB, double UB, int N, int num)`
`double[][]`	`ref_cmor(double LB, double UB, int N, double Fb, double Fc)`
`double[][]`	`ref_fbsp(double LB, double UB, int N, double m, double Fb, double Fc)`
`private double[][]`	`ref_gaus(double LB, double UB, int N, int num)`
`double[][]`	`ref_mexh(double LB, double UB, int N)`
`double[][]`	`ref_morl(double LB, double UB, int N)`
`double[][]`	`ref_shan(double LB, double UB, int N, double Fb, double Fc)`
`(package private) PyWavelets.DiscreteWavelet`	`rescale_wavelet_filterbank(PyWavelets.DiscreteWavelet wavelet, double sf)`
`void`	`runAlgorithm()`	Actually runs the algorithm.
`private double[]`	`scale2frequency(PyWavelets.ContinuousWavelet wavelet, double[] scale, int precision)`
`private double[]`	`scale2frequency(PyWavelets.DiscreteWavelet wavelet, double[] scale, int precision)`
`private void`	`shan(double[] input, double[] output_r, double[] output_i, int N, double FB, double FC)`
`double[]`	`sinc2(double[] x)`
`private short`	`size_log2(int x)`
`double[][][]`	`soft(double[][] dataReal, double[][] dataImag, double value, double substituteReal, double substituteImag)`
`double[][]`	`soft(double[][] data, double value, double substitute)`
`double[][]`	`soft(double[] dataReal, double[] dataImag, double value, double substituteReal, double substituteImag)`
`double[]`	`soft(double[] data, double value, double substitute)`
`private void`	`SWAP_DOUBLE_ARRAY(double[] x, double[] y)`
`private int`	`swt(double[] input, int input_len, double[] filter, int filter_len, double[] output, int output_len, int level)`
`double[][]`	`swt(double[] data, PyWavelets.DiscreteWavelet wavelet, int level, int start_level, boolean trim_approx)`
`private int`	`swt_a(double[] input, int input_len, PyWavelets.DiscreteWavelet wavelet, double[] output, int output_len, int level)`
`private double[][][][]`	`swt_axis(double[][][] data, PyWavelets.DiscreteWavelet wavelet, int level, int start_level, int axis, boolean trim_approx)`
`private double[][][]`	`swt_axis(double[][] data, PyWavelets.DiscreteWavelet wavelet, int level, int start_level, int axis, boolean trim_approx)`
`private int`	`swt_buffer_length(int input_len)`
`private int`	`swt_d(double[] input, int input_len, PyWavelets.DiscreteWavelet wavelet, double[] output, int output_len, int level)`
`private short`	`swt_max_level(int input_len)`
`private double[][][][]`	`swt1D(double[][][] data, PyWavelets.DiscreteWavelet wavelet, int level, int start_level, int axis, boolean trim_approx, boolean norm)`
`private double[][][]`	`swt1D(double[][] data, PyWavelets.DiscreteWavelet wavelet, int level, int start_level, int axis, boolean trim_approx, boolean norm)`
`private double[][]`	`swt1D(double[] data, PyWavelets.DiscreteWavelet wavelet, int level, int start_level, boolean trim_approx, boolean norm)`
`private double[][][]`	`swt2(double[][] data, PyWavelets.DiscreteWavelet[] wavelet, int level, int start_level, int[] axes, boolean trim_approx, boolean norm)`
`private java.util.HashMap<java.lang.String,double[][][]>[]`	`swtn(double[][][] datain, PyWavelets.DiscreteWavelet[] wavelet, int level, int start_level, int[] axes, boolean trim_approx, boolean norm)`
`private java.util.HashMap<java.lang.String,double[][]>[]`	`swtn(double[][] datain, PyWavelets.DiscreteWavelet[] wavelet, int level, int start_level, int[] axes, boolean trim_approx, boolean norm)`
`void`	`test_3D_reconstruct()`
`void`	`test_centrfreq()`
`void`	`test_cgau()`
`void`	`test_cmor()`
`void`	`test_compare_downcoef_coeffs()`
`void`	`test_cwt_method_fft()`
`void`	`test_cwt_small_scales()`
`void`	`test_downcoef_multilevel()`
`void`	`test_dwdtn_idwtn_allwavelets()`
`void`	`test_dwt_coeff_len()`
`void`	`test_dwt_idwt_allmodes()`
`void`	`test_dwt_idwt_basic()`
`void`	`test_dwt_idwt_basic_complex()`
`void`	`test_dwt_idwt_partial_complex()`
`void`	`test_dwt_max_level()`
`void`	`test_dwt_short_input_allmodes()`
`void`	`test_dwt_wavelet_kwd()`
`void`	`test_dwt2()`
`void`	`test_fbsp()`
`void`	`test_gaus()`
`void`	`test_idwt_none_input()`
`void`	`test_idwt2()`
`void`	`test_intwave_orthogonal()`
`void`	`test_mexh()`
`void`	`test_morl()`
`void`	`test_nonnegative_garotte()`
`void`	`test_per_axis_wavelets()`
`void`	`test_perfect_reconstruction()`
`void`	`test_scal2frq_scale()`
`void`	`test_shan()`
`void`	`test_swt_axis()`
`void`	`test_swt_decomposition()`
`void`	`test_swt_default_level_by_axis()`
`void`	`test_swt_iswt_integration()`
`void`	`test_swt_max_level()`
`void`	`test_swt_variance_and_energy_preservation()`
`void`	`test_swt2_axes()`
`void`	`test_swt2_iswt2_integration()`
`void`	`test_swt2_iswt2_non_square()`
`void`	`test_swt2_variance_and_energy_preservation()`
`void`	`test_swtn_axes()`
`void`	`test_swtn_decomposition()`
`void`	`test_swtn_iswtn_integration()`
`void`	`test_swtn_iswtn2_integration()`
`void`	`test_swtn_variance_and_energy_preservation()`
`void`	`test_threshold()`
`void`	`test_threshold_firm()`
`void`	`test_upcoef_multilevel()`
`void`	`test_upcoef_reconstruct()`
`void`	`test_wavedec()`
`void`	`test_wavedec2_many_levels()`
`void`	`test_wavefun_bior13()`
`void`	`test_wavefun_sym3()`
`void`	`test_wavelet_coefficients()`
`void`	`test_wavelet_properties()`
`void`	`test_waverec_accuracies()`
`void`	`test_waverec_all_wavelets_modes()`
`void`	`test_waverec_axes_subsets()`
`void`	`test_waverec_axis_db2()`
`void`	`test_waverec_odd_length()`
`void`	`test_waverec2_accuracies()`
`void`	`test_waverec2_all_wavelets_modes()`
`void`	`test_waverec2_axes_subsets()`
`void`	`test_waverec2_odd_length()`
`void`	`test_waverec3_accuracies()`
`void`	`test_waverecn2()`
`void`	`test_waverecn3()`
`double[][]`	`threshold_firm(double[] dataReal, double[] dataImag, double value_low, double value_high)`
`double[]`	`threshold_firm(double[] data, double value_low, double value_high)`
`double[]`	`upcoef(boolean do_rec_a, double[] coeffs, PyWavelets.DiscreteWavelet wavelet, int level, int take)`
`private double[]`	`upcoef(char part, double[] coeffs, PyWavelets.DiscreteWavelet wavelet, int level, int take)`
`private int`	`upsampling_convolution_full(double[] input, int N, double[] filter, int F, double[] output, int O)`
`private int`	`upsampling_convolution_valid_sf(double[] input, int N, double[] filter, int F, double[] output, int O, PyWavelets.MODE mode)`
`private int`	`upsampling_convolution_valid_sf_periodization(double[] input, int N, double[] filter, int F, double[] output, int O)`
`double[][][][]`	`wavedec(double[][][] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int level, int axis)`
`double[][][]`	`wavedec(double[][] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int level, int axis)`
`double[][]`	`wavedec(double[] data, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int level)`
`private double[][][][]`	`wavedec2(double[][][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int level, int[] axes)`
`double[][][]`	`wavedec2(double[][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int level, int[] axes)`
`private double[][][][]`	`wavedec3(double[][][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int level, int[] axes)`
`private java.util.Vector<java.util.HashMap<java.lang.String,double[][][]>>`	`wavedecn(double[][][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int level, int[] axes)`
`private java.util.Vector<java.util.HashMap<java.lang.String,double[][]>>`	`wavedecn(double[][] data, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] modein, int level, int[] axes)`
`private double[][]`	`wavefun(PyWavelets.ContinuousWavelet w, int level, int length)`
`double[][]`	`wavefun(PyWavelets.DiscreteWavelet w, int level)`
`private PyWavelets.DiscreteWavelet`	`Wavelet(double[][] filter_bank)`
`private double[][][]`	`waverec(double[][][][] coeffs, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int axis)`
`private double[][]`	`waverec(double[][][] coeffs, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode, int axis)`
`private double[]`	`waverec(double[][] coeffs, PyWavelets.DiscreteWavelet wavelet, PyWavelets.MODE mode)`
`private double[][][]`	`waverec2(double[][][][] coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`double[][]`	`waverec2(double[][][] coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`private double[][][]`	`waverec3(double[][][][] coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`private double[][]`	`waverecn2(java.util.Vector<java.util.HashMap<java.lang.String,double[][]>> coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`private double[][][]`	`waverecn3(java.util.Vector<java.util.HashMap<java.lang.String,double[][][]>> coeffs, PyWavelets.DiscreteWavelet[] wavelet, PyWavelets.MODE[] mode, int[] axes)`
`private double`	`zabs(double zr, double zi)`	zabs computes the absolute value or magnitude of a double precision complex variable zr + j*zi.

Methods inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase
actionPerformed, addListener, addProgressChangeListener, calculateImageSize, calculatePrincipleAxis, computeElapsedTime, computeElapsedTime, convertIntoFloat, delinkProgressToAlgorithm, delinkProgressToAlgorithmMulti, displayError, errorCleanUp, finalize, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, generateProgressValues, getDestImage, getElapsedTime, getMask, getMaxProgressValue, getMinProgressValue, getNumberOfThreads, getProgress, getProgressChangeListener, getProgressChangeListeners, getProgressModulus, getProgressStep, getProgressValues, getSrcImage, isCompleted, isImage25D, isMultiThreadingEnabled, isRunningInSeparateThread, isThreadStopped, linkProgressToAlgorithm, linkProgressToAlgorithm, makeProgress, notifyListeners, removeListener, removeProgressChangeListener, run, setCompleted, setImage25D, setMask, setMaxProgressValue, setMinProgressValue, setMultiThreadingEnabled, setNumberOfThreads, setProgress, setProgressModulus, setProgressStep, setProgressValues, setProgressValues, setRunningInSeparateThread, setSrcImage, setStartTime, setThreadStopped, startMethod, windowActivated, windowClosed, windowClosing, windowDeactivated, windowDeiconified, windowIconified, windowOpened

Methods inherited from class java.lang.Thread
activeCount, checkAccess, clone, countStackFrames, currentThread, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, onSpinWait, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, suspend, toString, yield

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

tType
```
private int tType
```

wavelets

private PyWavelets.DiscreteWavelet[] wavelets

modes
```
private PyWavelets.MODE[] modes
```

axes
```
private int[] axes
```

filterType
```
int[] filterType
```

filterVal1
```
double[] filterVal1
```

filterVal2
```
double[] filterVal2
```

showTransform
```
private boolean showTransform
```

showFilteredTransform
```
private boolean showFilteredTransform
```

levels
```
private int levels
```

start_level
```
private int start_level
```

FILTER_NONE
```
public static final int FILTER_NONE
```
See Also:

Constant Field Values

FILTER_SOFT
```
public static final int FILTER_SOFT
```
See Also:

Constant Field Values

FILTER_NN_GARROTE
```
public static final int FILTER_NN_GARROTE
```
See Also:

Constant Field Values

FILTER_HARD
```
public static final int FILTER_HARD
```
See Also:

Constant Field Values

FILTER_GREATER
```
public static final int FILTER_GREATER
```
See Also:

Constant Field Values

FILTER_LESS
```
public static final int FILTER_LESS
```
See Also:

Constant Field Values

FILTER_THRESHOLD_FIRM
```
public static final int FILTER_THRESHOLD_FIRM
```
See Also:

Constant Field Values

imageA
```
private ModelImage imageA
```

imageH
```
private ModelImage imageH
```

imageV
```
private ModelImage imageV
```

imageD
```
private ModelImage imageD
```

imageA_filter
```
private ModelImage imageA_filter
```

imageH_filter
```
private ModelImage imageH_filter
```

imageV_filter
```
private ModelImage imageV_filter
```

imageD_filter
```
private ModelImage imageD_filter
```

imageLLL
```
private ModelImage imageLLL
```

imageHLL
```
private ModelImage imageHLL
```

imageLHL
```
private ModelImage imageLHL
```

imageHHL
```
private ModelImage imageHHL
```

imageLLH
```
private ModelImage imageLLH
```

imageHLH
```
private ModelImage imageHLH
```

imageLHH
```
private ModelImage imageLHH
```

imageHHH
```
private ModelImage imageHHH
```

imageLL
```
private ModelImage imageLL
```

imageHL
```
private ModelImage imageHL
```

imageLH
```
private ModelImage imageLH
```

imageHH
```
private ModelImage imageHH
```

imageL
```
private ModelImage imageL
```

imageLLL_filter
```
private ModelImage imageLLL_filter
```

imageHLL_filter
```
private ModelImage imageHLL_filter
```

imageLHL_filter
```
private ModelImage imageLHL_filter
```

imageHHL_filter
```
private ModelImage imageHHL_filter
```

imageLLH_filter
```
private ModelImage imageLLH_filter
```

imageHLH_filter
```
private ModelImage imageHLH_filter
```

imageLHH_filter
```
private ModelImage imageLHH_filter
```

imageHHH_filter
```
private ModelImage imageHHH_filter
```

imageLL_filter
```
private ModelImage imageLL_filter
```

imageHL_filter
```
private ModelImage imageHL_filter
```

imageLH_filter
```
private ModelImage imageLH_filter
```

imageHH_filter
```
private ModelImage imageHH_filter
```

imageL_filter
```
private ModelImage imageL_filter
```

imageAn
```
private ModelImage imageAn
```

imageHn
```
private ModelImage[] imageHn
```

imageVn
```
private ModelImage[] imageVn
```

imageDn
```
private ModelImage[] imageDn
```

imageAn_filter
```
private ModelImage imageAn_filter
```

imageHn_filter
```
private ModelImage[] imageHn_filter
```

imageVn_filter
```
private ModelImage[] imageVn_filter
```

imageDn_filter
```
private ModelImage[] imageDn_filter
```

imageLLLn
```
private ModelImage imageLLLn
```

imageHLLn
```
private ModelImage[] imageHLLn
```

imageLHLn
```
private ModelImage[] imageLHLn
```

imageHHLn
```
private ModelImage[] imageHHLn
```

imageLLHn
```
private ModelImage[] imageLLHn
```

imageHLHn
```
private ModelImage[] imageHLHn
```

imageLHHn
```
private ModelImage[] imageLHHn
```

imageHHHn
```
private ModelImage[] imageHHHn
```

imageLLLn_filter
```
private ModelImage imageLLLn_filter
```

imageHLLn_filter
```
private ModelImage[] imageHLLn_filter
```

imageLHLn_filter
```
private ModelImage[] imageLHLn_filter
```

imageHHLn_filter
```
private ModelImage[] imageHHLn_filter
```

imageLLHn_filter
```
private ModelImage[] imageLLHn_filter
```

imageHLHn_filter
```
private ModelImage[] imageHLHn_filter
```

imageLHHn_filter
```
private ModelImage[] imageLHHn_filter
```

imageHHHn_filter
```
private ModelImage[] imageHHHn_filter
```

imageAnSWT
```
private ModelImage[] imageAnSWT
```

imageAnSWT_filter
```
private ModelImage[] imageAnSWT_filter
```

imageLLLnSWT
```
private ModelImage[] imageLLLnSWT
```

imageLLLnSWT_filter

private ModelImage[] imageLLLnSWT_filter

imageLLn
```
private ModelImage[] imageLLn
```

imageHLn
```
private ModelImage[] imageHLn
```

imageLHn
```
private ModelImage[] imageLHn
```

imageHHn
```
private ModelImage[] imageHHn
```

imageLn
```
private ModelImage[] imageLn
```

imageLLn_filter
```
private ModelImage[] imageLLn_filter
```

imageHLn_filter
```
private ModelImage[] imageHLn_filter
```

imageLHn_filter
```
private ModelImage[] imageLHn_filter
```

imageHHn_filter
```
private ModelImage[] imageHHn_filter
```

imageLn_filter
```
private ModelImage[] imageLn_filter
```

SINGLE_LEVEL_DWT
```
public static int SINGLE_LEVEL_DWT
```

MULTILEVEL_DWT
```
public static int MULTILEVEL_DWT
```

SWT
```
public static int SWT
```

noiseStandardDeviation

private double[] noiseStandardDeviation

useNoiseStdConstructor
```
private boolean useNoiseStdConstructor
```

doBayesShrinkThresholdComputation

private boolean doBayesShrinkThresholdComputation

db1_double
```
static final double[] db1_double
```

db2_double
```
static final double[] db2_double
```

db3_double
```
static final double[] db3_double
```

db4_double
```
static final double[] db4_double
```

db5_double
```
static final double[] db5_double
```

db6_double
```
static final double[] db6_double
```

db7_double
```
static final double[] db7_double
```

db8_double
```
static final double[] db8_double
```

db9_double
```
static final double[] db9_double
```

db10_double
```
static final double[] db10_double
```

db11_double
```
static final double[] db11_double
```

db12_double
```
static final double[] db12_double
```

db13_double
```
static final double[] db13_double
```

db14_double
```
static final double[] db14_double
```

db15_double
```
static final double[] db15_double
```

db16_double
```
static final double[] db16_double
```

db17_double
```
static final double[] db17_double
```

db18_double
```
static final double[] db18_double
```

db19_double
```
static final double[] db19_double
```

db20_double
```
static final double[] db20_double
```

db21_double
```
static final double[] db21_double
```

db22_double
```
static final double[] db22_double
```

db23_double
```
static final double[] db23_double
```

db24_double
```
static final double[] db24_double
```

db25_double
```
static final double[] db25_double
```

db26_double
```
static final double[] db26_double
```

db27_double
```
static final double[] db27_double
```

db28_double
```
static final double[] db28_double
```

db29_double
```
static final double[] db29_double
```

db30_double
```
static final double[] db30_double
```

db31_double
```
static final double[] db31_double
```

db32_double
```
static final double[] db32_double
```

db33_double
```
static final double[] db33_double
```

db34_double
```
static final double[] db34_double
```

db35_double
```
static final double[] db35_double
```

db36_double
```
static final double[] db36_double
```

db37_double
```
static final double[] db37_double
```

db38_double
```
static final double[] db38_double
```

sym2_double
```
static final double[] sym2_double
```

sym3_double
```
static final double[] sym3_double
```

sym4_double
```
static final double[] sym4_double
```

sym5_double
```
static final double[] sym5_double
```

sym6_double
```
static final double[] sym6_double
```

sym7_double
```
static final double[] sym7_double
```

sym8_double
```
static final double[] sym8_double
```

sym9_double
```
static final double[] sym9_double
```

sym10_double
```
static final double[] sym10_double
```

sym11_double
```
static final double[] sym11_double
```

sym12_double
```
static final double[] sym12_double
```

sym13_double
```
static final double[] sym13_double
```

sym14_double
```
static final double[] sym14_double
```

sym15_double
```
static final double[] sym15_double
```

sym16_double
```
static final double[] sym16_double
```

sym17_double
```
static final double[] sym17_double
```

sym18_double
```
static final double[] sym18_double
```

sym19_double
```
static final double[] sym19_double
```

sym20_double
```
static final double[] sym20_double
```

sqrt2_double
```
static final double sqrt2_double
```
See Also:

Constant Field Values

coif1_double
```
static final double[] coif1_double
```

coif2_double
```
static final double[] coif2_double
```

coif3_double
```
static final double[] coif3_double
```

coif4_double
```
static final double[] coif4_double
```

coif5_double
```
static final double[] coif5_double
```

coif6_double
```
static final double[] coif6_double
```

coif7_double
```
static final double[] coif7_double
```

coif8_double
```
static final double[] coif8_double
```

coif9_double
```
static final double[] coif9_double
```

coif10_double
```
static final double[] coif10_double
```

coif11_double
```
static final double[] coif11_double
```

coif12_double
```
static final double[] coif12_double
```

coif13_double
```
static final double[] coif13_double
```

coif14_double
```
static final double[] coif14_double
```

coif15_double
```
static final double[] coif15_double
```

coif16_double
```
static final double[] coif16_double
```

coif17_double
```
static final double[] coif17_double
```

bior1_0_double
```
static final double[] bior1_0_double
```

bior1_1_double
```
static final double[] bior1_1_double
```

bior1_3_double
```
static final double[] bior1_3_double
```

bior1_5_double
```
static final double[] bior1_5_double
```

bior2_0_double
```
static final double[] bior2_0_double
```

bior2_2_double
```
static final double[] bior2_2_double
```

bior2_4_double
```
static final double[] bior2_4_double
```

bior2_6_double
```
static final double[] bior2_6_double
```

bior2_8_double
```
static final double[] bior2_8_double
```

bior3_0_double
```
static final double[] bior3_0_double
```

bior3_1_double
```
static final double[] bior3_1_double
```

bior3_3_double
```
static final double[] bior3_3_double
```

bior3_5_double
```
static final double[] bior3_5_double
```

bior3_7_double
```
static final double[] bior3_7_double
```

bior3_9_double
```
static final double[] bior3_9_double
```

bior4_0_double
```
static final double[] bior4_0_double
```

bior4_4_double
```
static final double[] bior4_4_double
```

bior5_0_double
```
static final double[] bior5_0_double
```

bior5_5_double
```
static final double[] bior5_5_double
```

bior6_0_double
```
static final double[] bior6_0_double
```

bior6_8_double
```
static final double[] bior6_8_double
```

dmey_double
```
static final double[] dmey_double
```

db_double
```
static final double[][] db_double
```

sym_double
```
static final double[][] sym_double
```

coif_double
```
static final double[][] coif_double
```

bior1_double
```
static final double[][] bior1_double
```

bior2_double
```
static final double[][] bior2_double
```

bior3_double
```
static final double[][] bior3_double
```

bior4_double
```
static final double[][] bior4_double
```

bior5_double
```
static final double[][] bior5_double
```

bior6_double
```
static final double[][] bior6_double
```

bior_double
```
static final double[][][] bior_double
```

Constructor Detail

PyWavelets
```
public PyWavelets()
```

PyWavelets

public PyWavelets(ModelImage dstImg,
                  ModelImage srcImg,
                  int tType,
                  PyWavelets.WAVELET_NAME[] names,
                  int[] orders,
                  PyWavelets.MODE[] modes,
                  int[] axes,
                  int[] filterType,
                  double[] filterVal1,
                  double[] filterVal2,
                  boolean showTransform,
                  boolean showFilteredTransform,
                  int levels,
                  int start_level,
                  boolean doBayesShrinkThresholdComputation)

PyWavelets

public PyWavelets(ModelImage srcImg,
                  double[] noiseStandardDeviation)

Method Detail

is_discrete_wavelet

private int is_discrete_wavelet(PyWavelets.WAVELET_NAME name)

SWAP_DOUBLE_ARRAY

private void SWAP_DOUBLE_ARRAY(double[] x,
                               double[] y)

free_discrete_wavelet

private void free_discrete_wavelet(PyWavelets.DiscreteWavelet w)

blank_discrete_wavelet

private PyWavelets.DiscreteWavelet blank_discrete_wavelet(int filters_length)

discrete_wavelet

public PyWavelets.DiscreteWavelet discrete_wavelet(PyWavelets.WAVELET_NAME name,
                                                   int order)

blank_continuous_wavelet

PyWavelets.ContinuousWavelet blank_continuous_wavelet()

continuous_wavelet

PyWavelets.ContinuousWavelet continuous_wavelet(PyWavelets.WAVELET_NAME name,
                                                int order)

copy_discrete_wavelet

PyWavelets.DiscreteWavelet copy_discrete_wavelet(PyWavelets.DiscreteWavelet base)

dwt_max_level

public short dwt_max_level(int input_len,
                           PyWavelets.DiscreteWavelet w)

size_log2
```
private short size_log2(int x)
```

dwt_buffer_length

private int dwt_buffer_length(int input_len,
                              int filter_len,
                              PyWavelets.MODE mode)

reconstruction_buffer_length

private int reconstruction_buffer_length(int coeffs_len,
                                         int filter_len)

idwt_buffer_length

private int idwt_buffer_length(int coeffs_len,
                               int filter_len,
                               PyWavelets.MODE mode)

swt_buffer_length

private int swt_buffer_length(int input_len)

dwt_max_level

public short dwt_max_level(int input_len,
                           int filter_len)

swt_max_level

private short swt_max_level(int input_len)

runAlgorithm
```
public void runAlgorithm()
```
Description copied from class: AlgorithmBase

Actually runs the algorithm. Implemented by inheriting algorithms.

Specified by:

runAlgorithm in class AlgorithmBase

BayesShrinkThresholdComputation

private double BayesShrinkThresholdComputation(double[] data,
                                               double noise_var)

filter

private void filter(double[] data,
                    int filterType,
                    double filterVal1,
                    double filterVal2)

downsampling_convolution_periodization

private int downsampling_convolution_periodization(double[] input,
                                                   int N,
                                                   double[] filter,
                                                   int F,
                                                   double[] output,
                                                   int step,
                                                   int fstep)

downsampling_convolution

private int downsampling_convolution(double[] input,
                                     int N,
                                     double[] filter,
                                     int F,
                                     double[] output,
                                     int step,
                                     PyWavelets.MODE mode)

upsampling_convolution_full

private int upsampling_convolution_full(double[] input,
                                        int N,
                                        double[] filter,
                                        int F,
                                        double[] output,
                                        int O)

upsampling_convolution_valid_sf_periodization

private int upsampling_convolution_valid_sf_periodization(double[] input,
                                                          int N,
                                                          double[] filter,
                                                          int F,
                                                          double[] output,
                                                          int O)

upsampling_convolution_valid_sf

private int upsampling_convolution_valid_sf(double[] input,
                                            int N,
                                            double[] filter,
                                            int F,
                                            double[] output,
                                            int O,
                                            PyWavelets.MODE mode)

gaus

private void gaus(double[] input,
                  double[] output,
                  int N,
                  int number)

mexh

private void mexh(double[] input,
                  double[] output,
                  int N)

morl

private void morl(double[] input,
                  double[] output,
                  int N)

cgau

private void cgau(double[] input,
                  double[] output_r,
                  double[] output_i,
                  int N,
                  int number)

shan

private void shan(double[] input,
                  double[] output_r,
                  double[] output_i,
                  int N,
                  double FB,
                  double FC)

fbsp

private void fbsp(double[] input,
                  double[] output_r,
                  double[] output_i,
                  int N,
                  int M,
                  double FB,
                  double FC)

cmor

private void cmor(double[] input,
                  double[] output_r,
                  double[] output_i,
                  int N,
                  double FB,
                  double FC)

idwt_axis

private int idwt_axis(double[] coefs_a,
                      PyWavelets.ArrayInfo a_info,
                      double[] coefs_d,
                      PyWavelets.ArrayInfo d_info,
                      double[] output,
                      PyWavelets.ArrayInfo output_info,
                      PyWavelets.DiscreteWavelet wavelet,
                      int axis,
                      PyWavelets.MODE mode)

dec_a

private int dec_a(double[] input,
                  int input_len,
                  PyWavelets.DiscreteWavelet wavelet,
                  double[] output,
                  int output_len,
                  PyWavelets.MODE mode)

dec_d

private int dec_d(double[] input,
                  int input_len,
                  PyWavelets.DiscreteWavelet wavelet,
                  double[] output,
                  int output_len,
                  PyWavelets.MODE mode)

rec_a

private int rec_a(double[] coeffs_a,
                  int coeffs_len,
                  PyWavelets.DiscreteWavelet wavelet,
                  double[] output,
                  int output_len)

rec_d

private int rec_d(double[] coeffs_d,
                  int coeffs_len,
                  PyWavelets.DiscreteWavelet wavelet,
                  double[] output,
                  int output_len)

dwt

private double[][] dwt(double[] data,
                       PyWavelets.DiscreteWavelet wavelet,
                       PyWavelets.MODE mode)

dwt

private double[][][] dwt(double[][] data,
                         PyWavelets.DiscreteWavelet wavelet,
                         PyWavelets.MODE mode,
                         int axis)

dwt

private double[][][][] dwt(double[][][] data,
                           PyWavelets.DiscreteWavelet wavelet,
                           PyWavelets.MODE mode,
                           int axis)

dwt_single

private double[][] dwt_single(double[] data,
                              PyWavelets.DiscreteWavelet wavelet,
                              PyWavelets.MODE mode)

idwt_single

private double[] idwt_single(double[] cA,
                             double[] cD,
                             PyWavelets.DiscreteWavelet wavelet,
                             PyWavelets.MODE mode)

dwt_coeff_len

private int dwt_coeff_len(int data_len,
                          int filter_len,
                          PyWavelets.MODE mode)

idwt

private int idwt(double[] coeffs_a,
                 int coeffs_a_len,
                 double[] coeffs_d,
                 int coeffs_d_len,
                 double[] output,
                 int output_len,
                 PyWavelets.DiscreteWavelet wavelet,
                 PyWavelets.MODE mode)

swt

private int swt(double[] input,
                int input_len,
                double[] filter,
                int filter_len,
                double[] output,
                int output_len,
                int level)

swt_a

private int swt_a(double[] input,
                  int input_len,
                  PyWavelets.DiscreteWavelet wavelet,
                  double[] output,
                  int output_len,
                  int level)

swt_d

private int swt_d(double[] input,
                  int input_len,
                  PyWavelets.DiscreteWavelet wavelet,
                  double[] output,
                  int output_len,
                  int level)

decompose1DSignal
```
public int decompose1DSignal()
```

test_dwt_idwt_basic
```
public void test_dwt_idwt_basic()
```

test_dwt_idwt_basic_complex

public void test_dwt_idwt_basic_complex()

test_dwt_idwt_partial_complex

public void test_dwt_idwt_partial_complex()

test_dwt_wavelet_kwd
```
public void test_dwt_wavelet_kwd()
```

test_dwt_coeff_len
```
public void test_dwt_coeff_len()
```

test_idwt_none_input
```
public void test_idwt_none_input()
```

linspace

private double[] linspace(double LB,
                          double UB,
                          int N)

ref_gaus

private double[][] ref_gaus(double LB,
                            double UB,
                            int N,
                            int num)

ref_cgau

public double[][] ref_cgau(double LB,
                           double UB,
                           int N,
                           int num)

sinc2
```
public double[] sinc2(double[] x)
```

ref_shan

public double[][] ref_shan(double LB,
                           double UB,
                           int N,
                           double Fb,
                           double Fc)

ref_fbsp

public double[][] ref_fbsp(double LB,
                           double UB,
                           int N,
                           double m,
                           double Fb,
                           double Fc)

ref_cmor

public double[][] ref_cmor(double LB,
                           double UB,
                           int N,
                           double Fb,
                           double Fc)

ref_morl

public double[][] ref_morl(double LB,
                           double UB,
                           int N)

ref_mexh

public double[][] ref_mexh(double LB,
                           double UB,
                           int N)

test_gaus
```
public void test_gaus()
```

test_cgau
```
public void test_cgau()
```

test_shan
```
public void test_shan()
```

test_cmor
```
public void test_cmor()
```

test_fbsp
```
public void test_fbsp()
```

test_morl
```
public void test_morl()
```

test_mexh
```
public void test_mexh()
```

test_cwt_small_scales
```
public void test_cwt_small_scales()
```

test_cwt_method_fft
```
public void test_cwt_method_fft()
```

test_wavelet_properties
```
public void test_wavelet_properties()
```

test_wavefun_sym3
```
public void test_wavefun_sym3()
```

test_wavefun_bior13
```
public void test_wavefun_bior13()
```

test_centrfreq
```
public void test_centrfreq()
```

test_scal2frq_scale
```
public void test_scal2frq_scale()
```

test_intwave_orthogonal
```
public void test_intwave_orthogonal()
```

test_threshold
```
public void test_threshold()
```

test_nonnegative_garotte

public void test_nonnegative_garotte()

test_threshold_firm
```
public void test_threshold_firm()
```

test_upcoef_reconstruct
```
public void test_upcoef_reconstruct()
```

test_downcoef_multilevel

public void test_downcoef_multilevel()

test_compare_downcoef_coeffs

public void test_compare_downcoef_coeffs()

test_upcoef_multilevel
```
public void test_upcoef_multilevel()
```

test_dwt_max_level
```
public void test_dwt_max_level()
```

test_perfect_reconstruction

public void test_perfect_reconstruction()

check_reconstruction

private boolean check_reconstruction(PyWavelets.MODE mode,
                                     PyWavelets.DiscreteWavelet wavelet)

test_dwt_idwt_allmodes
```
public void test_dwt_idwt_allmodes()
```

test_dwt_short_input_allmodes

public void test_dwt_short_input_allmodes()

test_dwt2
```
public void test_dwt2()
```

test_idwt2
```
public void test_idwt2()
```

test_3D_reconstruct
```
public void test_3D_reconstruct()
```

test_dwdtn_idwtn_allwavelets

public void test_dwdtn_idwtn_allwavelets()

test_wavedec
```
public void test_wavedec()
```

test_waverec_accuracies
```
public void test_waverec_accuracies()
```

test_waverec_odd_length
```
public void test_waverec_odd_length()
```

test_waverec_all_wavelets_modes

public void test_waverec_all_wavelets_modes()

BM3Dwavedec2

public double[][][] BM3Dwavedec2(double[][] patch,
                                 int level)

BM3Dwaverec2

public double[][] BM3Dwaverec2(double[][] bior_img,
                               int level)

test_waverec2_accuracies

public void test_waverec2_accuracies()

test_waverec2_all_wavelets_modes

public void test_waverec2_all_wavelets_modes()

test_waverec2_odd_length

public void test_waverec2_odd_length()

test_wavedec2_many_levels

public void test_wavedec2_many_levels()

test_waverec3_accuracies

public void test_waverec3_accuracies()

test_waverec_axes_subsets

public void test_waverec_axes_subsets()

test_waverec_axis_db2
```
public void test_waverec_axis_db2()
```

test_waverec2_axes_subsets

public void test_waverec2_axes_subsets()

test_waverecn2
```
public void test_waverecn2()
```

test_waverecn3
```
public void test_waverecn3()
```

test_swt_decomposition
```
public void test_swt_decomposition()
```

test_swtn_decomposition
```
public void test_swtn_decomposition()
```

test_swt_max_level
```
public void test_swt_max_level()
```

test_swt_axis
```
public void test_swt_axis()
```

test_swt_iswt_integration

public void test_swt_iswt_integration()

test_swt_default_level_by_axis

public void test_swt_default_level_by_axis()

test_swt2_iswt2_integration

public void test_swt2_iswt2_integration()

test_swt2_iswt2_non_square

public void test_swt2_iswt2_non_square()

test_swt2_axes
```
public void test_swt2_axes()
```

test_swtn_axes
```
public void test_swtn_axes()
```

test_swtn_iswtn2_integration

public void test_swtn_iswtn2_integration()

test_swtn_iswtn_integration

public void test_swtn_iswtn_integration()

test_swt_variance_and_energy_preservation

public void test_swt_variance_and_energy_preservation()

test_swt2_variance_and_energy_preservation

public void test_swt2_variance_and_energy_preservation()

test_swtn_variance_and_energy_preservation

public void test_swtn_variance_and_energy_preservation()

test_per_axis_wavelets
```
public void test_per_axis_wavelets()
```

wavefun

public double[][] wavefun(PyWavelets.DiscreteWavelet w,
                          int level)

wavefun

private double[][] wavefun(PyWavelets.ContinuousWavelet w,
                           int level,
                           int length)

cwt_psi_single

private double[][] cwt_psi_single(double[] data_t,
                                  PyWavelets.ContinuousWavelet wavelet,
                                  int output_len)

get_keep_length

public int get_keep_length(int output_length,
                           int level,
                           int filter_length)

fix_output_length

public int fix_output_length(int output_length,
                             int keep_length)

get_right_extent_length

public int get_right_extent_length(int output_length,
                                   int keep_length)

keep

public double[] keep(double[] arr,
                     int keep_length)

downcoef

public double[] downcoef(char part,
                         double[] data,
                         PyWavelets.DiscreteWavelet wavelet,
                         PyWavelets.MODE mode,
                         int level)

downcoef

public double[] downcoef(boolean do_dec_a,
                         double[] data,
                         PyWavelets.DiscreteWavelet wavelet,
                         PyWavelets.MODE mode,
                         int level)

upcoef

private double[] upcoef(char part,
                        double[] coeffs,
                        PyWavelets.DiscreteWavelet wavelet,
                        int level,
                        int take)

upcoef

public double[] upcoef(boolean do_rec_a,
                       double[] coeffs,
                       PyWavelets.DiscreteWavelet wavelet,
                       int level,
                       int take)

Wavelet

private PyWavelets.DiscreteWavelet Wavelet(double[][] filter_bank)

inverse_filter_bank

private double[][] inverse_filter_bank(PyWavelets.DiscreteWavelet w)

test_wavelet_coefficients

public void test_wavelet_coefficients()

check_coefficients_orthogonal

boolean check_coefficients_orthogonal(PyWavelets.DiscreteWavelet w)

check_coefficients_biorthogonal

private boolean check_coefficients_biorthogonal(PyWavelets.DiscreteWavelet w)

check_coefficients

private boolean check_coefficients(PyWavelets.DiscreteWavelet w)

cwt

private double[][][] cwt(double[] data,
                         double[] scales,
                         PyWavelets.ContinuousWavelet w,
                         double sampling_period,
                         java.lang.String method)

central_frequency

private double central_frequency(PyWavelets.ContinuousWavelet wavelet,
                                 int precision)

central_frequency

private double central_frequency(PyWavelets.DiscreteWavelet wavelet,
                                 int precision)

scale2frequency

private double[] scale2frequency(PyWavelets.ContinuousWavelet wavelet,
                                 double[] scale,
                                 int precision)

scale2frequency

private double[] scale2frequency(PyWavelets.DiscreteWavelet wavelet,
                                 double[] scale,
                                 int precision)

convolve

private double[] convolve(double[] a,
                          double[] b)

_integrate

private double[] _integrate(double[] arr,
                            double step)

integrate_wavelet

private double[][] integrate_wavelet(PyWavelets.DiscreteWavelet wavelet,
                                     int precision)

integrate_wavelet

private double[][] integrate_wavelet(PyWavelets.ContinuousWavelet wavelet,
                                     int precision)

soft

public double[][] soft(double[] dataReal,
                       double[] dataImag,
                       double value,
                       double substituteReal,
                       double substituteImag)

soft

public double[][][] soft(double[][] dataReal,
                         double[][] dataImag,
                         double value,
                         double substituteReal,
                         double substituteImag)

soft

public double[] soft(double[] data,
                     double value,
                     double substitute)

soft

public double[][] soft(double[][] data,
                       double value,
                       double substitute)

nn_garrote

public double[][] nn_garrote(double[] dataReal,
                             double[] dataImag,
                             double value,
                             double substituteReal,
                             double substituteImag)

nn_garrote

public double[] nn_garrote(double[] data,
                           double value,
                           double substitute)

hard

public double[][] hard(double[] dataReal,
                       double[] dataImag,
                       double value,
                       double substituteReal,
                       double substituteImag)

hard

public double[][][] hard(double[][] dataReal,
                         double[][] dataImag,
                         double value,
                         double substituteReal,
                         double substituteImag)

zabs
```
private double zabs(double zr,
                    double zi)
```
zabs computes the absolute value or magnitude of a double precision complex variable zr + j*zi.

Parameters:

zr - double

zi - double

Returns:

double

hard

public double[] hard(double[] data,
                     double value,
                     double substitute)

hard

public double[][] hard(double[][] data,
                       double value,
                       double substitute)

greater

public double[] greater(double[] data,
                        double value,
                        double substitute)

greater

public double[][] greater(double[][] data,
                          double value,
                          double substitute)

less

public double[] less(double[] data,
                     double value,
                     double substitute)

less

public double[][] less(double[][] data,
                       double value,
                       double substitute)

threshold_firm

public double[] threshold_firm(double[] data,
                               double value_low,
                               double value_high)

threshold_firm

public double[][] threshold_firm(double[] dataReal,
                                 double[] dataImag,
                                 double value_low,
                                 double value_high)

_sign

private double[][][] _sign(double[][] xReal,
                           double[][] xImag)

_soft

private double[][][] _soft(double[][] xReal,
                           double[][] xImag,
                           double thresh)

wavedec

public double[][] wavedec(double[] data,
                          PyWavelets.DiscreteWavelet wavelet,
                          PyWavelets.MODE mode,
                          int level)

wavedec

public double[][][] wavedec(double[][] data,
                            PyWavelets.DiscreteWavelet wavelet,
                            PyWavelets.MODE mode,
                            int level,
                            int axis)

wavedec

public double[][][][] wavedec(double[][][] data,
                              PyWavelets.DiscreteWavelet wavelet,
                              PyWavelets.MODE mode,
                              int level,
                              int axis)

check_level

private int check_level(int sizes,
                        int dec_lens,
                        int level)

waverec

private double[] waverec(double[][] coeffs,
                         PyWavelets.DiscreteWavelet wavelet,
                         PyWavelets.MODE mode)

waverec

private double[][] waverec(double[][][] coeffs,
                           PyWavelets.DiscreteWavelet wavelet,
                           PyWavelets.MODE mode,
                           int axis)

waverec

private double[][][] waverec(double[][][][] coeffs,
                             PyWavelets.DiscreteWavelet wavelet,
                             PyWavelets.MODE mode,
                             int axis)

dwt2

public double[][][] dwt2(double[][] data,
                         PyWavelets.DiscreteWavelet[] wavelet,
                         PyWavelets.MODE[] mode,
                         int[] axes)

dwt2

public double[][][][] dwt2(double[][][] data,
                           PyWavelets.DiscreteWavelet[] wavelet,
                           PyWavelets.MODE[] mode,
                           int[] axes)

dwtn

public java.util.HashMap<java.lang.String,double[][]> dwtn(double[][] data,
                                                                 PyWavelets.DiscreteWavelet[] wavelet,
                                                                 PyWavelets.MODE[] modein,
                                                                 int[] axes)

dwt_axis

private double[][][] dwt_axis(double[][] data,
                              PyWavelets.DiscreteWavelet wavelet,
                              PyWavelets.MODE mode,
                              int axis)

downcoef_axis

private int downcoef_axis(double[][] input,
                          PyWavelets.ArrayInfo input_info,
                          double[][] output,
                          PyWavelets.ArrayInfo output_info,
                          PyWavelets.DiscreteWavelet wavelet,
                          int axis,
                          PyWavelets.Coefficient coef,
                          PyWavelets.MODE dwt_mode,
                          int swt_level,
                          PyWavelets.DiscreteTransformType transform)

idwt2

public double[][] idwt2(double[][][] coeffs,
                        PyWavelets.DiscreteWavelet[] wavelet,
                        PyWavelets.MODE[] mode,
                        int[] axes)

idwt23

public double[][][] idwt23(double[][][][] coeffs,
                           PyWavelets.DiscreteWavelet[] wavelet,
                           PyWavelets.MODE[] mode,
                           int[] axes)

idwt13

private double[][][] idwt13(double[][][][] coeffs,
                            PyWavelets.DiscreteWavelet[] wavelet,
                            PyWavelets.MODE[] mode,
                            int[] axes)

idwtn2

private double[][] idwtn2(java.util.HashMap<java.lang.String,double[][]> coeffs,
                          PyWavelets.DiscreteWavelet[] wavelet,
                          PyWavelets.MODE[] modein,
                          int[] axes)

idwtn23

private double[][][] idwtn23(java.util.HashMap<java.lang.String,double[][][]> coeffs,
                             PyWavelets.DiscreteWavelet[] wavelet,
                             PyWavelets.MODE[] modein,
                             int[] axes)

idwtn13

private double[][][] idwtn13(java.util.HashMap<java.lang.String,double[][][]> coeffs,
                             PyWavelets.DiscreteWavelet[] wavelet,
                             PyWavelets.MODE[] modein,
                             int[] axes)

coeffs_ok2

private boolean coeffs_ok2(java.util.HashMap<java.lang.String,double[][]> coeffs)

coeffs_ok13or23

private boolean coeffs_ok13or23(java.util.HashMap<java.lang.String,double[][][]> coeffs)

idwt_axis

private double[][] idwt_axis(double[][] coefs_a,
                             double[][] coefs_d,
                             PyWavelets.DiscreteWavelet wavelet,
                             PyWavelets.MODE mode,
                             int axis)

dwt3

private double[][][][] dwt3(double[][][] data,
                            PyWavelets.DiscreteWavelet[] wavelet,
                            PyWavelets.MODE[] mode,
                            int[] axes)

dwtn2

public java.util.HashMap<java.lang.String,double[][]> dwtn2(double[][] data,
                                                                  PyWavelets.DiscreteWavelet[] wavelet,
                                                                  PyWavelets.MODE[] modein,
                                                                  int[] axes)

dwtn3

public java.util.HashMap<java.lang.String,double[][][]> dwtn3(double[][][] data,
                                                                    PyWavelets.DiscreteWavelet[] wavelet,
                                                                    PyWavelets.MODE[] modein,
                                                                    int[] axes)

dwtn23

public java.util.HashMap<java.lang.String,double[][][]> dwtn23(double[][][] data,
                                                                     PyWavelets.DiscreteWavelet[] wavelet,
                                                                     PyWavelets.MODE[] modein,
                                                                     int[] axes)

dwt_axis

private double[][][][] dwt_axis(double[][][] data,
                                PyWavelets.DiscreteWavelet wavelet,
                                PyWavelets.MODE mode,
                                int axis)

downcoef_axis

private int downcoef_axis(double[][][] input,
                          PyWavelets.ArrayInfo input_info,
                          double[][][] output,
                          PyWavelets.ArrayInfo output_info,
                          PyWavelets.DiscreteWavelet wavelet,
                          int axis,
                          PyWavelets.Coefficient coef,
                          PyWavelets.MODE dwt_mode,
                          int swt_level,
                          PyWavelets.DiscreteTransformType transform)

idwt3

public double[][][] idwt3(double[][][][] coeffs,
                          PyWavelets.DiscreteWavelet[] wavelet,
                          PyWavelets.MODE[] mode,
                          int[] axes)

idwtn3

private double[][][] idwtn3(java.util.HashMap<java.lang.String,double[][][]> coeffs,
                            PyWavelets.DiscreteWavelet[] wavelet,
                            PyWavelets.MODE[] modein,
                            int[] axes)

coeffs_ok3

private boolean coeffs_ok3(java.util.HashMap<java.lang.String,double[][][]> coeffs)

idwt_axis

private double[][][] idwt_axis(double[][][] coefs_a,
                               double[][][] coefs_d,
                               PyWavelets.DiscreteWavelet wavelet,
                               PyWavelets.MODE mode,
                               int axis)

wavedec2

public double[][][] wavedec2(double[][] data,
                             PyWavelets.DiscreteWavelet[] wavelet,
                             PyWavelets.MODE[] mode,
                             int level,
                             int[] axes)

wavedec2

private double[][][][] wavedec2(double[][][] data,
                                PyWavelets.DiscreteWavelet[] wavelet,
                                PyWavelets.MODE[] mode,
                                int level,
                                int[] axes)

waverec2

public double[][] waverec2(double[][][] coeffs,
                           PyWavelets.DiscreteWavelet[] wavelet,
                           PyWavelets.MODE[] mode,
                           int[] axes)

waverec2

private double[][][] waverec2(double[][][][] coeffs,
                              PyWavelets.DiscreteWavelet[] wavelet,
                              PyWavelets.MODE[] mode,
                              int[] axes)

wavedec3

private double[][][][] wavedec3(double[][][] data,
                                PyWavelets.DiscreteWavelet[] wavelet,
                                PyWavelets.MODE[] mode,
                                int level,
                                int[] axes)

waverec3

private double[][][] waverec3(double[][][][] coeffs,
                              PyWavelets.DiscreteWavelet[] wavelet,
                              PyWavelets.MODE[] mode,
                              int[] axes)

wavedecn

private java.util.Vector<java.util.HashMap<java.lang.String,double[][]>> wavedecn(double[][] data,
                                                                                        PyWavelets.DiscreteWavelet[] wavelet,
                                                                                        PyWavelets.MODE[] modein,
                                                                                        int level,
                                                                                        int[] axes)

wavedecn

private java.util.Vector<java.util.HashMap<java.lang.String,double[][][]>> wavedecn(double[][][] data,
                                                                                          PyWavelets.DiscreteWavelet[] wavelet,
                                                                                          PyWavelets.MODE[] modein,
                                                                                          int level,
                                                                                          int[] axes)

waverecn2

private double[][] waverecn2(java.util.Vector<java.util.HashMap<java.lang.String,double[][]>> coeffs,
                             PyWavelets.DiscreteWavelet[] wavelet,
                             PyWavelets.MODE[] mode,
                             int[] axes)

waverecn3

private double[][][] waverecn3(java.util.Vector<java.util.HashMap<java.lang.String,double[][][]>> coeffs,
                               PyWavelets.DiscreteWavelet[] wavelet,
                               PyWavelets.MODE[] mode,
                               int[] axes)

swt1D

private double[][] swt1D(double[] data,
                         PyWavelets.DiscreteWavelet wavelet,
                         int level,
                         int start_level,
                         boolean trim_approx,
                         boolean norm)

swt1D

private double[][][] swt1D(double[][] data,
                           PyWavelets.DiscreteWavelet wavelet,
                           int level,
                           int start_level,
                           int axis,
                           boolean trim_approx,
                           boolean norm)

swt1D

private double[][][][] swt1D(double[][][] data,
                             PyWavelets.DiscreteWavelet wavelet,
                             int level,
                             int start_level,
                             int axis,
                             boolean trim_approx,
                             boolean norm)

rescale_wavelet_filterbank

PyWavelets.DiscreteWavelet rescale_wavelet_filterbank(PyWavelets.DiscreteWavelet wavelet,
                                                      double sf)

swt

public double[][] swt(double[] data,
                      PyWavelets.DiscreteWavelet wavelet,
                      int level,
                      int start_level,
                      boolean trim_approx)

swt_axis

private double[][][] swt_axis(double[][] data,
                              PyWavelets.DiscreteWavelet wavelet,
                              int level,
                              int start_level,
                              int axis,
                              boolean trim_approx)

swt_axis

private double[][][][] swt_axis(double[][][] data,
                                PyWavelets.DiscreteWavelet wavelet,
                                int level,
                                int start_level,
                                int axis,
                                boolean trim_approx)

iswt

private double[] iswt(double[][] coeffs,
                      PyWavelets.DiscreteWavelet wavelet)

swt2

private double[][][] swt2(double[][] data,
                          PyWavelets.DiscreteWavelet[] wavelet,
                          int level,
                          int start_level,
                          int[] axes,
                          boolean trim_approx,
                          boolean norm)

swtn

private java.util.HashMap<java.lang.String,double[][]>[] swtn(double[][] datain,
                                                                    PyWavelets.DiscreteWavelet[] wavelet,
                                                                    int level,
                                                                    int start_level,
                                                                    int[] axes,
                                                                    boolean trim_approx,
                                                                    boolean norm)

swtn

private java.util.HashMap<java.lang.String,double[][][]>[] swtn(double[][][] datain,
                                                                      PyWavelets.DiscreteWavelet[] wavelet,
                                                                      int level,
                                                                      int start_level,
                                                                      int[] axes,
                                                                      boolean trim_approx,
                                                                      boolean norm)

iswt2

private double[][] iswt2(double[][][] coeffs,
                         PyWavelets.DiscreteWavelet[] wavelet)

iswtn2

private double[][] iswtn2(java.util.HashMap<java.lang.String,double[][]>[] coeffs,
                          PyWavelets.DiscreteWavelet[] wavelet,
                          int[] axes)

iswtn

private double[][][] iswtn(java.util.HashMap<java.lang.String,double[][][]>[] coeffs,
                           PyWavelets.DiscreteWavelet[] wavelet,
                           int[] axes)

Class PyWavelets

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Thread

Field Summary

Fields inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase

Fields inherited from class java.lang.Thread

Constructor Summary

Method Summary

Methods inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase

Methods inherited from class java.lang.Thread

Methods inherited from class java.lang.Object

Field Detail

tType

wavelets

modes

axes

filterType

filterVal1

filterVal2

showTransform

showFilteredTransform

levels

start_level

FILTER_NONE

FILTER_SOFT

FILTER_NN_GARROTE

FILTER_HARD

FILTER_GREATER

FILTER_LESS

FILTER_THRESHOLD_FIRM

imageA

imageH

imageV

imageD

imageA_filter

imageH_filter

imageV_filter

imageD_filter

imageLLL

imageHLL

imageLHL

imageHHL

imageLLH

imageHLH

imageLHH

imageHHH

imageLL

imageHL

imageLH

imageHH

imageL

imageLLL_filter

imageHLL_filter

imageLHL_filter

imageHHL_filter

imageLLH_filter

imageHLH_filter

imageLHH_filter

imageHHH_filter

imageLL_filter

imageHL_filter

imageLH_filter

imageHH_filter

imageL_filter

imageAn

imageHn

imageVn

imageDn

imageAn_filter

imageHn_filter

imageVn_filter

imageDn_filter

imageLLLn

imageHLLn

imageLHLn

imageHHLn

imageLLHn

imageHLHn

imageLHHn

imageHHHn