FeatureStack (Trainable Segmentation 4.0.0 API)

java.lang.Object
- trainableSegmentation.FeatureStack

```
public class FeatureStack
extends Object
```
This class stores the stacks of features that will be used during the trainable/weka segmentations.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ANISOTROPIC_DIFFUSION` Anisotropic diffusion filter flag index
`static String[]`	`availableFeatures` names of available filters
`static int`	`BILATERAL` Bilateral flag index
`static int`	`DERIVATIVES` Derivatives filter flag index
`static int`	`DOG` Difference of Gaussians filter flag index
`static int`	`ENTROPY` entropy filter flag index
`static int`	`GABOR` Gabor filter flag index
`static int`	`GAUSSIAN` Gaussian filter flag index
`static int`	`HESSIAN` Hessian filter flag index
`static boolean[]`	`IMAGESCIENCE_FEATURES` Features only available if the ImageScience library is present.
`static int`	`KUWAHARA` Kuwahara filter flag index
`static int`	`LAPLACIAN` Laplacian filter flag index
`static int`	`LIPSCHITZ` Lipschitz filter flag index
`static int`	`MAXIMUM` Maximum filter flag index
`static int`	`MEAN` Mean filter flag index
`static int`	`MEDIAN` Median filter flag index
`static int`	`MEMBRANE` Membrane filter flag index
`static int`	`MINIMUM` Minimum filter flag index
`static int`	`NEIGHBORS` neighbors feature flag index
`static int`	`SOBEL` Sobel filter flag index
`static int`	`STRUCTURE` structure tensor filter flag index
`static int`	`VARIANCE` Variance filter flag index

Constructor Summary

Constructors
Constructor and Description
`FeatureStack(ij.ImagePlus image)` Construct object to store stack of image features.
`FeatureStack(ij.process.ImageProcessor ip)` Construct object to store stack of image features.
`FeatureStack(int width, int height, boolean colorFeatures)` Initialize empty feature stack.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addAnisotropicDiffusion(ij.ImagePlus originalImage, int nb_iter, int saveSteps, int nb_smoothings, float a1, float a2, float edgeThreshold)` Add anisotropic diffusion filtering images to current stack
`void`	`addBilateralFilter(ij.ImagePlus originalImage, double spatialRadius, double rangeRadius)` Add bilateral filter image to current stack
`void`	`addDefaultFeatures()` Add the default features to the feature stack
`void`	`addDerivatives(double sigma, int xOrder, int yOrder)` Add derivatives features to current stack
`void`	`addDoG(float sigma1, float sigma2)` Add difference of Gaussians to feature stack (single thread version)
`void`	`addEntropy(int radius, int numBins)` Add entropy filter to current stack
`void`	`addFeaturesMT(ij.ImagePlus filterList)` Add features based on a list of filters in a multi-thread fashion
`void`	`addGabor(ij.ImagePlus originalImage, double sigma, double gamma, double psi, double frequency, int nAngles)` Add Gabor features to current stack
`void`	`addGaussianBlur(float sigma)` Add Gaussian blur slice to current stack
`void`	`addGradient(float sigma)` Add Sobel filter version of the original image
`void`	`addHessian(float sigma)` Add Hessian features from original image (single thread version).
`void`	`addHSB()` Add HSB features
`void`	`addKuwaharaFeatures(ij.ImagePlus originalImage, int kernelSize, int nAngles, int criterion)` Add Kuwahara filter features to the current stack
`void`	`addLaplacian(double sigma)` Add Laplacian features to current stack
`void`	`addLipschitzFilter(ij.ImagePlus originalImage, boolean downHat, boolean topHat, double slope)` Add Lipschitz filter image to current stack
`void`	`addMax(float radius)` Add maximum filter to current feature stack.
`void`	`addMean(float radius)` Add mean filter to current stack
`void`	`addMedian(float radius)` Add median filter to the current feature stack.
`void`	`addMembraneFeatures(int patchSize, int membraneSize)` Add membrane features to the stack (single thread version)
`void`	`addMin(float radius)` Add minimum filter to current feature stack.
`void`	`addNeighbors(int minSigma, int maxSigma)` Add 8 neighbors of the original image as features
`void`	`addStructure(double sigma, double integrationScale)` Add structure tensor features to current stack It computes, for all pixels in the input image, the eigenvalues of the so-called structure tensor.
`void`	`addVariance(float radius)` Add variance-filtered image to the stack (single thread version)
`weka.core.DenseInstance`	`createInstance(int x, int y)` Create instance (feature vector) of a specific coordinate without a class, to be used on unsupervised clustering.
`weka.core.DenseInstance`	`createInstance(int x, int y, int classValue)` Create instance (feature vector) of a specific coordinate
`void`	`createInstanceInPlace(int x, int y, int classValue, weka.core.DenseInstance ins)` Create instance (feature vector) of a specific coordinate in place.
`weka.core.Instances`	`createInstances(ArrayList<String> classes)` Create the instances for the whole stack
`Callable<ij.ImagePlus>`	`getAnisotropicDiffusion(ij.ImagePlus originalImage, int nb_iter, int saveSteps, int nb_smoothings, float a1, float a2, float edgeThreshold)` Apply anisotropic diffusion in a concurrent way (to be submitted in an ExecutorService)
`Callable<ij.ImagePlus>`	`getBilateralFilter(ij.ImagePlus originalImage, double spatialRadius, double rangeRadius)` Apply bilateral filter in a concurrent way (to be submitted in an ExecutorService)
`Callable<ij.ImagePlus>`	`getDerivatives(ij.ImagePlus originalImage, double sigma, int xOrder, int yOrder)` Get derivatives features (to be submitted in an ExecutorService)
`Callable<ij.ImagePlus>`	`getDoG(ij.ImagePlus originalImage, float sigma1, float sigma2)` Get difference of Gaussians (to be submitted to an ExecutorService)
`boolean[]`	`getEnabledFeatures()` Get the list of enabled features flags
`Callable<ij.ImagePlus>`	`getEntropy(ij.ImagePlus originalImage, int radius, int numBins)` Calculate entropy filter filter concurrently
`Callable<ij.ImagePlus>`	`getFilter(ij.ImagePlus originalImage, ij.process.ImageProcessor filter, String title)` Apply a filter to the original image (to be submitted to an ExecutorService)
`Callable<ij.ImagePlus>`	`getGabor(ij.ImagePlus originalImage, double sigma, double gamma, double psi, double frequency, int nAngles, ExecutorService exec)` Get Gabor features (to be submitted in an ExecutorService)
`Callable<ij.ImagePlus>`	`getGaussianBlur(ij.ImagePlus originalImage, float sigma)` Calculate Gaussian filter concurrently
`Callable<ij.ImagePlus>`	`getGradient(ij.ImagePlus originalImage, float sigma)` Get Sobel filter version of the original image (to be called from an ExecutorService)
`int`	`getHeight()` Get stack height
`Callable<ij.ImagePlus>`	`getHessian(ij.ImagePlus originalImage, float sigma)` Get Hessian features from original image (to be submitted in an ExecutorService).
`Callable<ij.ImagePlus>`	`getHSB(ij.ImagePlus originalImage)` Calculate HSB out of the RGB channels (to be submitted to an ExecutorService)
`Callable<ij.ImagePlus>`	`getKuwaharaFeatures(ij.ImagePlus originalImage, int kernelSize, int nAngles, int criterion)` Get Kuwahara filter features (to be submitted in an ExecutorService)
`Callable<ij.ImagePlus>`	`getLaplacian(ij.ImagePlus originalImage, double sigma)` Get Laplacian features (to be submitted in an ExecutorService)
`Callable<ij.ImagePlus>`	`getLipschitzFilter(ij.ImagePlus originalImage, boolean downHat, boolean topHat, double slope)` Apply Lipschitz filter in a concurrent way (to be submitted in an ExecutorService)
`Callable<ij.ImagePlus>`	`getMax(ij.ImagePlus originalImage, float radius)` Get original image after maximum filtering (to be called from an ExecutorService)
`Callable<ij.ImagePlus>`	`getMean(ij.ImagePlus originalImage, float radius)` Get original image after mean filtering (to be called from an ExecutorService)
`Callable<ij.ImagePlus>`	`getMedian(ij.ImagePlus originalImage, float radius)` Get original image after median filtering (to be called from an ExecutorService)
`Callable<ij.ImagePlus>`	`getMembraneFeatures(ij.ImagePlus originalImage, int patchSize, int membraneSize)` Get membrane features (to be submitted in an ExecutorService)
`int`	`getMembraneSize()` Get the current membrane thickness
`Callable<ij.ImagePlus>`	`getMin(ij.ImagePlus originalImage, float radius)` Get original image after minimum filtering (to be called from an ExecutorService)
`Callable<ij.ImagePlus>`	`getNeighbors(ij.ImagePlus originalImage, int minSigma, int maxSigma)` Calculate 8 neighbors concurrently
`ij.process.ImageProcessor`	`getProcessor(int index)` Get slice image processor.
`int`	`getSize()` Get stack size
`String`	`getSliceLabel(int index)` Get slice label
`ij.ImageStack`	`getStack()` Get current stack of image features.
`Callable<ij.ImagePlus>`	`getStructure(ij.ImagePlus originalImage, double sigma, double integrationScale)` Get structure tensor features (to be submitted in an ExecutorService).
`Callable<ij.ImagePlus>`	`getVariance(ij.ImagePlus originalImage, float radius)` Calculate variance filter concurrently
`int`	`getWidth()` Get stack width
`boolean`	`isEmpty()` Check if the stack has been initialized or not
`boolean`	`isOldColorFormat()` Check if the feature stack is using the old Hessian format (previous to TWS 3.2.25).
`boolean`	`isOldHessianFormat()` Check if the feature stack is using the old Hessian format (previous to TWS version 3.2.25).
`void`	`removeFeature(String featureName)` Remove feature from stack
`boolean`	`reorderFeatures(weka.core.Instances data)` Reorder the feature stack to match the order given by a set of instances.
`boolean`	`saveStackAsTiff(String filename)` Save current whole stack as TIFF
`boolean`	`setEnabledFeature(String featureName, boolean enable)` Enable/disable feature by name
`void`	`setEnabledFeatures(boolean[] enableFeatures)` Set list of boolean flags for enabled features
`void`	`setInstance(int x, int y, int classValue, ReusableDenseInstance ins, double[] auxArray)` Set values to an instance (feature vector) of a specific coordinate.
`void`	`setInstance(int x, int y, ReusableDenseInstance ins, double[] auxArray)` without class parameter
`void`	`setMaximumSigma(float maxSigma)` Set the maximum sigma to use in the filters
`void`	`setMembranePatchSize(int patchSize)` Set the membrane patch size (it must be an odd number)
`void`	`setMembraneSize(int membraneSize)` Set the expected membrane thickness
`void`	`setMinimumSigma(float minSigma)` Set the minimum sigma to use in the filters
`void`	`setOldColorFormat(boolean b)` Set the use of old color format.
`void`	`setOldHessianFormat(boolean b)` Set the use of old Hessian format.
`void`	`setStack(ij.ImageStack stack)` Set an arbitrary stack as feature stack.
`void`	`setUseNeighbors(boolean useNeighbors)` Set the use of the neighbors as features
`void`	`show()` Display feature stack
`void`	`shutDownNow()` Shut down the executor service
`void`	`updateFeatures()` Deprecated.
`boolean`	`updateFeaturesMT()` Update features with current list in a multi-thread fashion.
`boolean`	`updateFeaturesMT(int numThreads)` Update features with current list in a multi-thread fashion.
`boolean`	`updateFeaturesST()` Update features with current list in a single-thread fashion
`boolean`	`useNeighborhood()` Check the use of the neighbors as features
`void`	`writeConfigurationToFile(String filename)` Write feature names in a file

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

- Field Detail
  - GAUSSIAN
```
public static final int GAUSSIAN
```
    Gaussian filter flag index
    
    See Also:
    
    Constant Field Values
  - SOBEL
```
public static final int SOBEL
```
    Sobel filter flag index
    
    See Also:
    
    Constant Field Values
  - HESSIAN
```
public static final int HESSIAN
```
    Hessian filter flag index
    
    See Also:
    
    Constant Field Values
  - DOG
```
public static final int DOG
```
    Difference of Gaussians filter flag index
    
    See Also:
    
    Constant Field Values
  - MEMBRANE
```
public static final int MEMBRANE
```
    Membrane filter flag index
    
    See Also:
    
    Constant Field Values
  - VARIANCE
```
public static final int VARIANCE
```
    Variance filter flag index
    
    See Also:
    
    Constant Field Values
  - MEAN
```
public static final int MEAN
```
    Mean filter flag index
    
    See Also:
    
    Constant Field Values
  - MINIMUM
```
public static final int MINIMUM
```
    Minimum filter flag index
    
    See Also:
    
    Constant Field Values
  - MAXIMUM
```
public static final int MAXIMUM
```
    Maximum filter flag index
    
    See Also:
    
    Constant Field Values
  - MEDIAN
```
public static final int MEDIAN
```
    Median filter flag index
    
    See Also:
    
    Constant Field Values
  - ANISOTROPIC_DIFFUSION
```
public static final int ANISOTROPIC_DIFFUSION
```
    Anisotropic diffusion filter flag index
    
    See Also:
    
    Constant Field Values
  - BILATERAL
```
public static final int BILATERAL
```
    Bilateral flag index
    
    See Also:
    
    Constant Field Values
  - LIPSCHITZ
```
public static final int LIPSCHITZ
```
    Lipschitz filter flag index
    
    See Also:
    
    Constant Field Values
  - KUWAHARA
```
public static final int KUWAHARA
```
    Kuwahara filter flag index
    
    See Also:
    
    Constant Field Values
  - GABOR
```
public static final int GABOR
```
    Gabor filter flag index
    
    See Also:
    
    Constant Field Values
  - DERIVATIVES
```
public static final int DERIVATIVES
```
    Derivatives filter flag index
    
    See Also:
    
    Constant Field Values
  - LAPLACIAN
```
public static final int LAPLACIAN
```
    Laplacian filter flag index
    
    See Also:
    
    Constant Field Values
  - STRUCTURE
```
public static final int STRUCTURE
```
    structure tensor filter flag index
    
    See Also:
    
    Constant Field Values
  - ENTROPY
```
public static final int ENTROPY
```
    entropy filter flag index
    
    See Also:
    
    Constant Field Values
  - NEIGHBORS
```
public static final int NEIGHBORS
```
    neighbors feature flag index
    
    See Also:
    
    Constant Field Values
  - availableFeatures
```
public static final String[] availableFeatures
```
    names of available filters
  - IMAGESCIENCE_FEATURES
```
public static final boolean[] IMAGESCIENCE_FEATURES
```
    Features only available if the ImageScience library is present.
- Constructor Detail
  - FeatureStack
```
public FeatureStack(ij.ImagePlus image)
```
    Construct object to store stack of image features. The input image will be used as one of the features.
    
    Parameters:
    
    image - original 2D image (grayscale or RGB)
  - FeatureStack
```
public FeatureStack(int width,
                    int height,
                    boolean colorFeatures)
```
    Initialize empty feature stack. Features can be added later using the setStack method. Use this method if you want to use your own features (not compatible with the Weka_Segmentation GUI).
    
    Parameters:
    
    width - image width
    
    height - image height
    
    colorFeatures - color image flag
  - FeatureStack
```
public FeatureStack(ij.process.ImageProcessor ip)
```
    Construct object to store stack of image features. The input image will be used as one of the features.
    
    Parameters:
    
    ip - original 2D image (grayscale or RGB)
- Method Detail
  - shutDownNow
```
public void shutDownNow()
```
    Shut down the executor service
  - show
```
public void show()
```
    Display feature stack
  - getSize
```
public int getSize()
```
    Get stack size
    
    Returns:
    
    number of slices in the stack
  - getSliceLabel
```
public String getSliceLabel(int index)
```
    Get slice label
    
    Parameters:
    
    index - slice index (from 1 to max size)
    
    Returns:
    
    slice label
  - getHeight
```
public int getHeight()
```
    Get stack height
    
    Returns:
    
    stack height
  - getWidth
```
public int getWidth()
```
    Get stack width
    
    Returns:
    
    stack width
  - useNeighborhood
```
public boolean useNeighborhood()
```
    Check the use of the neighbors as features
    
    Returns:
    
    true if the neighbors are being used
  - setUseNeighbors
```
public void setUseNeighbors(boolean useNeighbors)
```
    Set the use of the neighbors as features
    
    Parameters:
    
    useNeighbors - flag to decide the use of neighbors
  - setMembranePatchSize
```
public void setMembranePatchSize(int patchSize)
```
    Set the membrane patch size (it must be an odd number)
    
    Parameters:
    
    patchSize - membrane patch size
  - addGaussianBlur
```
public void addGaussianBlur(float sigma)
```
    Add Gaussian blur slice to current stack
    
    Parameters:
    
    sigma - Gaussian radius
  - getGaussianBlur
```
public Callable<ij.ImagePlus> getGaussianBlur(ij.ImagePlus originalImage,
                                              float sigma)
```
    Calculate Gaussian filter concurrently
    
    Parameters:
    
    originalImage - original input image
    
    sigma - Gaussian sigma
    
    Returns:
    
    result image
  - addEntropy
```
public void addEntropy(int radius,
                       int numBins)
```
    Add entropy filter to current stack
    
    Parameters:
    
    radius - radius to use (in pixels)
    
    numBins - number of bins to use in the histogram
  - getEntropy
```
public Callable<ij.ImagePlus> getEntropy(ij.ImagePlus originalImage,
                                         int radius,
                                         int numBins)
```
    Calculate entropy filter filter concurrently
    
    Parameters:
    
    originalImage - original input image
    
    radius - radius to use (in pixels)
    
    numBins - number of bins to use in the histogram
    
    Returns:
    
    result image
  - addNeighbors
```
public void addNeighbors(int minSigma,
                         int maxSigma)
```
    Add 8 neighbors of the original image as features
    
    Parameters:
    
    minSigma - minimum sigma
    
    maxSigma - maximum sigma
  - getNeighbors
```
public Callable<ij.ImagePlus> getNeighbors(ij.ImagePlus originalImage,
                                           int minSigma,
                                           int maxSigma)
```
    Calculate 8 neighbors concurrently
    
    Parameters:
    
    originalImage - original input image
    
    minSigma - minimum sigma
    
    maxSigma - minimum sigma
    
    Returns:
    
    result image
  - addVariance
```
public void addVariance(float radius)
```
    Add variance-filtered image to the stack (single thread version)
    
    Parameters:
    
    radius - variance filter radius
  - getVariance
```
public Callable<ij.ImagePlus> getVariance(ij.ImagePlus originalImage,
                                          float radius)
```
    Calculate variance filter concurrently
    
    Parameters:
    
    originalImage - original input image
    
    radius - for variance filter
    
    Returns:
    
    result image
  - addMean
```
public void addMean(float radius)
```
    Add mean filter to current stack
    
    Parameters:
    
    radius - radius to use
  - getMean
```
public Callable<ij.ImagePlus> getMean(ij.ImagePlus originalImage,
                                      float radius)
```
    Get original image after mean filtering (to be called from an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    radius - filter radius
    
    Returns:
    
    filtered image
  - addMin
```
public void addMin(float radius)
```
    Add minimum filter to current feature stack.
    
    Parameters:
    
    radius - radius of the minimum filter in pixels
  - getMin
```
public Callable<ij.ImagePlus> getMin(ij.ImagePlus originalImage,
                                     float radius)
```
    Get original image after minimum filtering (to be called from an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    radius - filter radius
    
    Returns:
    
    filtered image
  - addMax
```
public void addMax(float radius)
```
    Add maximum filter to current feature stack.
    
    Parameters:
    
    radius - radius of the maximum filter in pixels
  - getMax
```
public Callable<ij.ImagePlus> getMax(ij.ImagePlus originalImage,
                                     float radius)
```
    Get original image after maximum filtering (to be called from an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    radius - filter radius
    
    Returns:
    
    filtered image
  - addMedian
```
public void addMedian(float radius)
```
    Add median filter to the current feature stack.
    
    Parameters:
    
    radius - radius of the median filter in pixels
  - getMedian
```
public Callable<ij.ImagePlus> getMedian(ij.ImagePlus originalImage,
                                        float radius)
```
    Get original image after median filtering (to be called from an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    radius - filter radius
    
    Returns:
    
    filtered image
  - writeConfigurationToFile
```
public void writeConfigurationToFile(String filename)
```
    Write feature names in a file
    
    Parameters:
    
    filename - output file name
  - addGradient
```
public void addGradient(float sigma)
```
    Add Sobel filter version of the original image
    
    Parameters:
    
    sigma - radius of the Gaussian blue applied previous to the Sobel filtering
  - getGradient
```
public Callable<ij.ImagePlus> getGradient(ij.ImagePlus originalImage,
                                          float sigma)
```
    Get Sobel filter version of the original image (to be called from an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    sigma - radius of the Gaussian blur applied previous to the Sobel filtering
    
    Returns:
    
    filtered image
  - addHessian
```
public void addHessian(float sigma)
```
    Add Hessian features from original image (single thread version). The features include a scalar representing the Hessian, the trace, determinant, 1st eigenvalue, 2nd eigenvalue, orientation, gamma-normalized square eigenvalue difference and the square of Gamma-normalized eigenvalue difference
    
    Parameters:
    
    sigma - radius of the Gaussian filter to use
  - getHessian
```
public Callable<ij.ImagePlus> getHessian(ij.ImagePlus originalImage,
                                         float sigma)
```
    Get Hessian features from original image (to be submitted in an ExecutorService). The features include a scalar representing the Hessian, the trace, determinant, 1st eigenvalue, 2nd eigenvalue, orientation, gamma-normalized square eigenvalue difference and the square of Gamma-normalized eigenvalue difference
    
    Parameters:
    
    originalImage - input image
    
    sigma - radius of the Gaussian filter to use
    
    Returns:
    
    filtered image (stack: hessian, trace, determinant, 1st eigenvalue and 2nd eigenvalue)
  - addDoG
```
public void addDoG(float sigma1,
                   float sigma2)
```
    Add difference of Gaussians to feature stack (single thread version)
    
    Parameters:
    
    sigma1 - first Gaussian sigma
    
    sigma2 - second Gaussian sigma
  - getDoG
```
public Callable<ij.ImagePlus> getDoG(ij.ImagePlus originalImage,
                                     float sigma1,
                                     float sigma2)
```
    Get difference of Gaussians (to be submitted to an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    sigma1 - first Gaussian sigma
    
    sigma2 - second Gaussian sigma
    
    Returns:
    
    difference of Gaussians image
  - addMembraneFeatures
```
public void addMembraneFeatures(int patchSize,
                                int membraneSize)
```
    Add membrane features to the stack (single thread version)
    
    Parameters:
    
    patchSize - size of the filter to be used
    
    membraneSize - expected membrane thickness
  - getMembraneFeatures
```
public Callable<ij.ImagePlus> getMembraneFeatures(ij.ImagePlus originalImage,
                                                  int patchSize,
                                                  int membraneSize)
```
    Get membrane features (to be submitted in an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    patchSize - orientation kernel size
    
    membraneSize - expected membrane thickness
    
    Returns:
    
    image stack with elongated membrane projections using all methods ("Average Intensity", "Max Intensity", "Min Intensity", "Sum Slices", "Standard Deviation", "Median")
  - getFilter
```
public Callable<ij.ImagePlus> getFilter(ij.ImagePlus originalImage,
                                        ij.process.ImageProcessor filter,
                                        String title)
```
    Apply a filter to the original image (to be submitted to an ExecutorService)
    
    Parameters:
    
    originalImage - original image
    
    filter - filter kernel
    
    title - filter name
    
    Returns:
    
    filtered image
  - getDerivatives
```
public Callable<ij.ImagePlus> getDerivatives(ij.ImagePlus originalImage,
                                             double sigma,
                                             int xOrder,
                                             int yOrder)
```
    Get derivatives features (to be submitted in an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    sigma - smoothing scale
    
    xOrder - x-order of differentiation
    
    yOrder - y-order of differentiation
    
    Returns:
    
    filter image after specific order derivatives
  - addDerivatives
```
public void addDerivatives(double sigma,
                           int xOrder,
                           int yOrder)
```
    Add derivatives features to current stack
    
    Parameters:
    
    sigma - smoothing scale
    
    xOrder - x-order of differentiation
    
    yOrder - y-order of differentiation
  - getLaplacian
```
public Callable<ij.ImagePlus> getLaplacian(ij.ImagePlus originalImage,
                                           double sigma)
```
    Get Laplacian features (to be submitted in an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    sigma - smoothing scale
    
    Returns:
    
    filter Laplacian filter image
  - addLaplacian
```
public void addLaplacian(double sigma)
```
    Add Laplacian features to current stack
    
    Parameters:
    
    sigma - smoothing scale
  - getStructure
```
public Callable<ij.ImagePlus> getStructure(ij.ImagePlus originalImage,
                                           double sigma,
                                           double integrationScale)
```
    Get structure tensor features (to be submitted in an ExecutorService). It computes, for all pixels in the input image, the eigenvalues of the so-called structure tensor.
    
    Parameters:
    
    originalImage - input image
    
    sigma - smoothing scale
    
    integrationScale - integration scale (standard deviation of the Gaussian kernel used for smoothing the elements of the structure tensor, must be larger than zero)
    
    Returns:
    
    filter structure tensor filter image
  - addStructure
```
public void addStructure(double sigma,
                         double integrationScale)
```
    Add structure tensor features to current stack It computes, for all pixels in the input image, the eigenvalues of the so-called structure tensor.
    
    Parameters:
    
    sigma - smoothing scale
    
    integrationScale - integration scale (standard deviation of the Gaussian kernel used for smoothing the elements of the structure tensor, must be larger than zero)
  - getGabor
```
public Callable<ij.ImagePlus> getGabor(ij.ImagePlus originalImage,
                                       double sigma,
                                       double gamma,
                                       double psi,
                                       double frequency,
                                       int nAngles,
                                       ExecutorService exec)
```
    Get Gabor features (to be submitted in an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    sigma - size of the Gaussian envelope
    
    gamma - spatial aspect ratio, it specifies the ellipticity of the support of the Gabor function
    
    psi - phase offset
    
    frequency - frequency of the sinusoidal component
    
    nAngles - number of filter orientations
    
    exec - executor service to use on FFT convolutions
    
    Returns:
    
    image stack with Gabor filter projections using "Max Intensity" and "Min Intensity"
  - addGabor
```
public void addGabor(ij.ImagePlus originalImage,
                     double sigma,
                     double gamma,
                     double psi,
                     double frequency,
                     int nAngles)
```
    Add Gabor features to current stack
    
    Parameters:
    
    originalImage - input image
    
    sigma - size of the Gaussian envelope
    
    gamma - spatial aspect ratio, it specifies the ellipticity of the support of the Gabor function
    
    psi - phase offset
    
    frequency - frequency of the sinusoidal component
    
    nAngles - number of filter orientations
  - getKuwaharaFeatures
```
public Callable<ij.ImagePlus> getKuwaharaFeatures(ij.ImagePlus originalImage,
                                                  int kernelSize,
                                                  int nAngles,
                                                  int criterion)
```
    Get Kuwahara filter features (to be submitted in an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    kernelSize - orientation kernel size
    
    nAngles - number of angles
    
    criterion -
    
    Returns:
    
    image stack with Kuwahara filter results using all the available criteria
  - addKuwaharaFeatures
```
public void addKuwaharaFeatures(ij.ImagePlus originalImage,
                                int kernelSize,
                                int nAngles,
                                int criterion)
```
    Add Kuwahara filter features to the current stack
    
    Parameters:
    
    originalImage - input image
    
    kernelSize - orientation kernel size
    
    nAngles - number of angles
    
    criterion -
  - getAnisotropicDiffusion
```
public Callable<ij.ImagePlus> getAnisotropicDiffusion(ij.ImagePlus originalImage,
                                                      int nb_iter,
                                                      int saveSteps,
                                                      int nb_smoothings,
                                                      float a1,
                                                      float a2,
                                                      float edgeThreshold)
```
    Apply anisotropic diffusion in a concurrent way (to be submitted in an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    nb_iter - number of iterations
    
    saveSteps - number of steps after which we save the intermediate results
    
    nb_smoothings - number of smoothings per iteration
    
    a1 - diffusion limiter along minimal variations
    
    a2 - diffusion limiter along maximal variations
    
    edgeThreshold - edge threshold
    
    Returns:
    
    result image
  - addAnisotropicDiffusion
```
public void addAnisotropicDiffusion(ij.ImagePlus originalImage,
                                    int nb_iter,
                                    int saveSteps,
                                    int nb_smoothings,
                                    float a1,
                                    float a2,
                                    float edgeThreshold)
```
    Add anisotropic diffusion filtering images to current stack
    
    Parameters:
    
    originalImage - input image
    
    nb_iter - number of iterations
    
    saveSteps - number of steps after which we save the intermediate results
    
    nb_smoothings - number of smoothings per iteration
    
    a1 - diffusion limiter along minimal variations
    
    a2 - diffusion limiter along maximal variations
    
    edgeThreshold - edge threshold
  - getBilateralFilter
```
public Callable<ij.ImagePlus> getBilateralFilter(ij.ImagePlus originalImage,
                                                 double spatialRadius,
                                                 double rangeRadius)
```
    Apply bilateral filter in a concurrent way (to be submitted in an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    spatialRadius - spatial radius
    
    rangeRadius - range radius
    
    Returns:
    
    result image
  - addBilateralFilter
```
public void addBilateralFilter(ij.ImagePlus originalImage,
                               double spatialRadius,
                               double rangeRadius)
```
    Add bilateral filter image to current stack
    
    Parameters:
    
    originalImage - input image
    
    spatialRadius - spatial radius
    
    rangeRadius - range radius
  - getLipschitzFilter
```
public Callable<ij.ImagePlus> getLipschitzFilter(ij.ImagePlus originalImage,
                                                 boolean downHat,
                                                 boolean topHat,
                                                 double slope)
```
    Apply Lipschitz filter in a concurrent way (to be submitted in an ExecutorService)
    
    Parameters:
    
    originalImage - input image
    
    downHat - flag to indicate covering from top to bottom
    
    topHat - flat to indicate computing lower (upper) Lipschitz cover
    
    slope - maximum allowed difference between two neighboring pixels
    
    Returns:
    
    result image
  - addLipschitzFilter
```
public void addLipschitzFilter(ij.ImagePlus originalImage,
                               boolean downHat,
                               boolean topHat,
                               double slope)
```
    Add Lipschitz filter image to current stack
    
    Parameters:
    
    originalImage - input image
    
    downHat - flag to indicate covering from top to bottom
    
    topHat - flat to indicate computing lower (upper) Lipschitz cover
    
    slope - maximum allowed difference between two neighboring pixels
  - getProcessor
```
public ij.process.ImageProcessor getProcessor(int index)
```
    Get slice image processor. Warning: every time this method is called, ImageStack creates a new processor.
    
    Parameters:
    
    index - selected slice
    
    Returns:
    
    slice image processor
  - createInstances
```
public weka.core.Instances createInstances(ArrayList<String> classes)
```
    Create the instances for the whole stack
    
    Parameters:
    
    classes - list of classes names
    
    Returns:
    
    whole stack set of instances
  - addDefaultFeatures
```
public void addDefaultFeatures()
```
    Add the default features to the feature stack
  - updateFeatures
```
public void updateFeatures()
```
    Deprecated.
    
    Update features with current list
  - addFeaturesMT
```
public void addFeaturesMT(ij.ImagePlus filterList)
```
    Add features based on a list of filters in a multi-thread fashion
    
    Parameters:
    
    filterList - list of filters
  - updateFeaturesST
```
public boolean updateFeaturesST()
```
    Update features with current list in a single-thread fashion
    
    Returns:
    
    true if the features are correctly updated
  - addHSB
```
public void addHSB()
```
    Add HSB features
  - getHSB
```
public Callable<ij.ImagePlus> getHSB(ij.ImagePlus originalImage)
```
    Calculate HSB out of the RGB channels (to be submitted to an ExecutorService)
    
    Parameters:
    
    originalImage - original input image
    
    Returns:
    
    HSB image
  - updateFeaturesMT
```
public boolean updateFeaturesMT()
```
    Update features with current list in a multi-thread fashion.
    
    Returns:
    
    true if the features are correctly updated
  - updateFeaturesMT
```
public boolean updateFeaturesMT(int numThreads)
```
    Update features with current list in a multi-thread fashion.
    
    Parameters:
    
    numThreads - number of threads to use
    
    Returns:
    
    true if the features are correctly updated
  - setEnabledFeatures
```
public void setEnabledFeatures(boolean[] enableFeatures)
```
    Set list of boolean flags for enabled features
    
    Parameters:
    
    enableFeatures - list of boolean flags to enable features
  - setEnabledFeature
```
public boolean setEnabledFeature(String featureName,
                                 boolean enable)
```
    Enable/disable feature by name
    
    Parameters:
    
    featureName - feature name
    
    enable - flag to enable/disable feature
    
    Returns:
    
    false if feature is not in the current list of features
  - getEnabledFeatures
```
public boolean[] getEnabledFeatures()
```
    Get the list of enabled features flags
    
    Returns:
    
    list of boolean flags (true means the feature is selected)
  - getMembraneSize
```
public int getMembraneSize()
```
    Get the current membrane thickness
    
    Returns:
    
    expected membrane thickness
  - setMembraneSize
```
public void setMembraneSize(int membraneSize)
```
    Set the expected membrane thickness
    
    Parameters:
    
    membraneSize - membrane thickness
  - isEmpty
```
public boolean isEmpty()
```
    Check if the stack has been initialized or not
    
    Returns:
    
    true if the features have not been calculated yet
  - saveStackAsTiff
```
public boolean saveStackAsTiff(String filename)
```
    Save current whole stack as TIFF
    
    Parameters:
    
    filename - destination path and file name
    
    Returns:
    
    false if fails
  - removeFeature
```
public void removeFeature(String featureName)
```
    Remove feature from stack
    
    Parameters:
    
    featureName - complete name of the feature to remove
  - setMinimumSigma
```
public void setMinimumSigma(float minSigma)
```
    Set the minimum sigma to use in the filters
    
    Parameters:
    
    minSigma - sigma value
  - setMaximumSigma
```
public void setMaximumSigma(float maxSigma)
```
    Set the maximum sigma to use in the filters
    
    Parameters:
    
    maxSigma - sigma value
  - createInstance
```
public weka.core.DenseInstance createInstance(int x,
                                              int y,
                                              int classValue)
```
    Create instance (feature vector) of a specific coordinate
    
    Parameters:
    
    x - x- axis coordinate
    
    y - y- axis coordinate
    
    classValue - class value to be assigned
    
    Returns:
    
    corresponding instance
  - createInstance
```
public weka.core.DenseInstance createInstance(int x,
                                              int y)
```
    Create instance (feature vector) of a specific coordinate without a class, to be used on unsupervised clustering.
    
    Parameters:
    
    x - x- axis coordinate
    
    y - y- axis coordinate
    
    Returns:
    
    corresponding instance
  - createInstanceInPlace
```
public void createInstanceInPlace(int x,
                                  int y,
                                  int classValue,
                                  weka.core.DenseInstance ins)
```
    Create instance (feature vector) of a specific coordinate in place. The input instance needs to have a data set assigned.
    
    Parameters:
    
    x - x- axis coordinate
    
    y - y- axis coordinate
    
    classValue - class value to be assigned
    
    ins - instance to be filled
  - setInstance
```
public void setInstance(int x,
                        int y,
                        ReusableDenseInstance ins,
                        double[] auxArray)
```
    without class parameter
    
    Parameters:
    
    x -
    
    y -
    
    ins -
    
    auxArray -
  - setInstance
```
public void setInstance(int x,
                        int y,
                        int classValue,
                        ReusableDenseInstance ins,
                        double[] auxArray)
```
    Set values to an instance (feature vector) of a specific coordinate. The input instance needs to have a data set assigned.
    
    Parameters:
    
    x - x- axis coordinate
    
    y - y- axis coordinate
    
    classValue - class value to be assigned
    
    ins - instance to be filled
    
    auxArray - auxiliary array to store feature values
  - setStack
```
public void setStack(ij.ImageStack stack)
```
    Set an arbitrary stack as feature stack. Note: this method is not compatible with the plugin GUI use since the feature names will not match.
    
    Parameters:
    
    stack - new stack of image features
  - getStack
```
public ij.ImageStack getStack()
```
    Get current stack of image features.
    
    Returns:
    
    current stack of image features
  - setOldColorFormat
```
public void setOldColorFormat(boolean b)
```
    Set the use of old color format.
    
    Parameters:
    
    b - flag to set the use of old color format
  - isOldColorFormat
```
public boolean isOldColorFormat()
```
    Check if the feature stack is using the old Hessian format (previous to TWS 3.2.25).
    
    Returns:
    
    true if the feature stack is using the old color format
  - setOldHessianFormat
```
public void setOldHessianFormat(boolean b)
```
    Set the use of old Hessian format.
    
    Parameters:
    
    b - flag to set the use of old color format
  - isOldHessianFormat
```
public boolean isOldHessianFormat()
```
    Check if the feature stack is using the old Hessian format (previous to TWS version 3.2.25).
    
    Returns:
    
    true if the feature stack is using the old Hessian format
  - reorderFeatures
```
public boolean reorderFeatures(weka.core.Instances data)
```
    Reorder the feature stack to match the order given by a set of instances.
    
    Parameters:
    
    data - set of instances to get the right order of attributes from
    
    Returns:
    
    true if reordering was possibles

Class FeatureStack

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

GAUSSIAN

SOBEL

HESSIAN

DOG

MEMBRANE

VARIANCE

MEAN

MINIMUM

MAXIMUM

MEDIAN

ANISOTROPIC_DIFFUSION

BILATERAL

LIPSCHITZ

KUWAHARA

GABOR

DERIVATIVES

LAPLACIAN

STRUCTURE

ENTROPY

NEIGHBORS

availableFeatures

IMAGESCIENCE_FEATURES

Constructor Detail

FeatureStack

FeatureStack

FeatureStack

Method Detail

shutDownNow

show

getSize

getSliceLabel

getHeight

getWidth

useNeighborhood

setUseNeighbors

setMembranePatchSize

addGaussianBlur

getGaussianBlur

addEntropy

getEntropy

addNeighbors

getNeighbors

addVariance

getVariance

addMean

getMean

addMin

getMin

addMax

getMax

addMedian

getMedian

writeConfigurationToFile

addGradient

getGradient

addHessian

getHessian

addDoG

getDoG

addMembraneFeatures

getMembraneFeatures

getFilter

getDerivatives

addDerivatives

getLaplacian

addLaplacian

getStructure

addStructure

getGabor

addGabor

getKuwaharaFeatures

addKuwaharaFeatures

getAnisotropicDiffusion

addAnisotropicDiffusion