GradientWatershed (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- mpicbg.imglib.algorithm.labeling.GradientWatershed<T,L>

Type Parameters:

T - The type of the image.

L - The type of the labeling, typically Integer

All Implemented Interfaces:

Algorithm, OutputAlgorithm<LabelingType<L>>
```
public class GradientWatershed<T extends RealType<T>,L extends Comparable<L>>
extends Object
implements OutputAlgorithm<LabelingType<L>>
```
This class labels an image where the objects in question have edges that are defined by sharp intensity gradients and have centers of high intensity and a low intensity background. The algorithm: Smooth the image by convolving with a Gaussian of sigma = sigma2. Find and label local minima and maxima of the given scale (in pixels). Label the minima with a single label. Take the difference of Gaussians (DoG) - convolve the original image with the kernel, G(sigma2) - G(sigma1). The original method uses the Sobel transform of a smoothed image which is much the same. Perform a seeded watershed using the minima/maxima labels on the DoG image. Remove the labeling from the pixels labeled as background. The method is adapted from Wahlby & Bengtsson, Segmentation of Cell Nuclei in Tissue by Combining Seeded Watersheds with Gradient Information, Image Analysis: 13th Scandinavian Conference Proceedings, pp 408-414, 2003

Field Summary

Fields
Modifier and Type	Field and Description
`protected String`	`error_message`
`protected ImageFactory<FloatType>`	`floatFactory`
`protected Image<FloatType>`	`floatImage`
`protected Image<T>`	`input`
`protected ImageFactory<LabelingType<L>>`	`labelingFactory`
`protected double`	`minBackgroundPeakHeight`
`protected double`	`minForegroundPeakHeight`
`protected Iterator<L>`	`names`
`protected int`	`numQuanta`
`protected Labeling<L>`	`output`
`protected double[]`	`scale`
`protected double[]`	`sigma1`
`protected double[]`	`sigma2`
`protected int[][]`	`structuringElement`
`protected boolean`	`wantsToQuantize`

Constructor Summary

Constructors
Constructor and Description
`GradientWatershed(Image<T> input, double[] scale, double[] sigma1, double[] sigma2, Iterator<L> names)` Constructor

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`checkDimensions(double[] array)`
`protected boolean`	`checkDimensions(int[] array)`
`boolean`	`checkInput()`
`protected static int[][]`	`cloneStructuringElement(int[][] structuringElement)`
`void`	`enableQuantization(boolean enable)` The watershed repetitively evaluates the lowest intensity unlabeled pixel starting from the seeds.
`protected boolean`	`filterPeak(LocalizableByDimCursor<FloatType> imageCursor, int[] peak, int[] dimensions, boolean find_minimum)`
`String`	`getErrorMessage()`
`protected ImageFactory<FloatType>`	`getFloatFactory()`
`protected Image<FloatType>`	`getFloatImage()`
`Image<FloatType>`	`getGradientImage()` Return a difference of gaussian image that measures the gradient at a scale defined by the two sigmas of the gaussians.
`double`	`getMinBackgroundPeakHeight()` See setMinBackgroundPeakHeight
`double`	`getMinForegroundPeakHeight()` See setMinForegroundPeakHeight
`int`	`getNumQuanta()` See setNumQuanta
`ImageFactory<LabelingType<L>>`	`getOutputImageFactory()`
`Image<LabelingType<L>>`	`getResult()`
`double[]`	`getScale()` Return the scale of the objects to be found.
`int[][]`	`getStructuringElement()` Get the current structuring element.
`boolean`	`isQuantized()` see enableQuantization
`boolean`	`process()`
`void`	`setMinBackgroundPeakHeight(double height)` The algorithm finds both foreground (local maxima) and background peaks (local minima) to act as seeds for the watershed.
`void`	`setMinForegroundPeakHeight(double height)` The algorithm finds both foreground (local maxima) and background peaks (local minima) to act as seeds for the watershed.
`void`	`setNumQuanta(int numQuanta)` See enableQuantization You must enableQuantization as well as set the number of quanta.
`void`	`setOutputImageFactory(ImageFactory<LabelingType<L>> factory)` Set the image factory to use when creating the Labeling.
`void`	`setOutputLabeling(Labeling<L> labeling)` Supply a labeling that will be filled with labelings by the image.
`void`	`setScale(double[] scale)` Set the scale of the objects to be found.
`void`	`setStructuringElement(int[][] structuringElement)` Set the current structuring element.

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

- Field Detail
  - input
```
protected Image<T extends RealType<T>> input
```
  - output
```
protected Labeling<L extends Comparable<L>> output
```
  - scale
```
protected double[] scale
```
  - sigma1
```
protected double[] sigma1
```
  - sigma2
```
protected double[] sigma2
```
  - names
```
protected Iterator<L extends Comparable<L>> names
```
  - minBackgroundPeakHeight
```
protected double minBackgroundPeakHeight
```
  - minForegroundPeakHeight
```
protected double minForegroundPeakHeight
```
  - wantsToQuantize
```
protected boolean wantsToQuantize
```
  - numQuanta
```
protected int numQuanta
```
  - structuringElement
```
protected int[][] structuringElement
```
  - error_message
```
protected String error_message
```
  - labelingFactory
```
protected ImageFactory<LabelingType<L extends Comparable<L>>> labelingFactory
```
  - floatImage
```
protected Image<FloatType> floatImage
```
  - floatFactory
```
protected ImageFactory<FloatType> floatFactory
```
- Constructor Detail
  - GradientWatershed
```
public GradientWatershed(Image<T> input,
                         double[] scale,
                         double[] sigma1,
                         double[] sigma2,
                         Iterator<L> names)
```
    Constructor
    
    Parameters:
    
    image - The intensity image to be labeled
    
    scale - the minimum distance between maxima of objects. Less technically, this should be the diameter of the smallest object.
    
    sigma1 - the standard deviation for the larger smoothing. The difference between sigma1 and sigma2 should be roughly the width of the desired edge in the DoG image. A larger difference will obscure small, faint edges.
    
    sigma2 - the standard deviation for the smaller smoothing. This should be on the order of the largest insignificant feature in the image.
    
    names - - an iterator that generates names of type L for the labels. The iterator will waste the last name taken on the background label. You can use AllConnectedComponents.getIntegerNames() as your name generator if you don't care about names.
- Method Detail
  - getStructuringElement
```
public int[][] getStructuringElement()
```
    Get the current structuring element. The structuring element is an array of coordinate tuple arrays where each coordinate is the offset to a component to connect using the watershed algorithm.
    
    Returns:
    
    the structuring element that defines connectivity
  - cloneStructuringElement
```
protected static int[][] cloneStructuringElement(int[][] structuringElement)
```
  - setStructuringElement
```
public void setStructuringElement(int[][] structuringElement)
```
    Set the current structuring element. See AllConnectedComponents.getStructuringElement for a discussion of the structuring element format. The structuring element determines which pixels are considered neighbors of a newly-added pixel in the watershed algorithm. By default, an 8-connected (neighbors + diagonals) or its N-dimensional analog structuring element is used.
    
    Parameters:
    
    structuringElement - - the new structuring element.
  - getScale
```
public double[] getScale()
```
    Return the scale of the objects to be found. This should be the diameter of a typical object. The scale is a N-dimensional vector to take into account possible differences in axis scaling.
    
    Returns:
    
    - the scale
  - setScale
```
public void setScale(double[] scale)
```
    Set the scale of the objects to be found. This should be the diameter of a typical object.
    
    Parameters:
    
    scale -
  - setMinBackgroundPeakHeight
```
public void setMinBackgroundPeakHeight(double height)
```
    The algorithm finds both foreground (local maxima) and background peaks (local minima) to act as seeds for the watershed. This can result in false peaks in areas where there is little difference in intensity. The MinBackgroundPeakHeight is the minimum difference in intensity between the intensity at the peak and the intensity of the strongest signal within 1/2 of the scale of the peak. The algorithm will ignore peaks if the intensity difference is less than this minimum value.
    
    Parameters:
    
    height - - the minimum intensity difference between the peak and the highest intensity pixel in its neighborhood
  - getMinBackgroundPeakHeight
```
public double getMinBackgroundPeakHeight()
```
    See setMinBackgroundPeakHeight
    
    Returns:
    
    the current minimum background peak height.
  - setMinForegroundPeakHeight
```
public void setMinForegroundPeakHeight(double height)
```
    The algorithm finds both foreground (local maxima) and background peaks (local minima) to act as seeds for the watershed. This can result in false peaks in areas where there is little difference in intensity. The MinForegroundPeakHeight is the minimum difference in intensity between the intensity at the peak and the intensity of the weakest signal within 1/2 of the scale of the peak. The algorithm will ignore peaks if the intensity difference is less than this minimum value.
    
    Parameters:
    
    height - - the minimum intensity difference between the peak and the lowest intensity pixel in its neighborhood
  - getMinForegroundPeakHeight
```
public double getMinForegroundPeakHeight()
```
    See setMinForegroundPeakHeight
    
    Returns:
    
    the current minimum background peak height.
  - enableQuantization
```
public void enableQuantization(boolean enable)
```
    The watershed repetitively evaluates the lowest intensity unlabeled pixel starting from the seeds. If two pixels have identical intensities, it picks the first one that was put on the list of pixels to process. The effect of this is to propagate out from the seeds in a consistent and predictable manner in regions that have identical intensities. This setting enables or disables quantizing of the gradient image. Quantizing divides the intensities in the image into a fixed number of levels so that pixels of roughly the same intensity generally have the same value and the algorithm will propagate the seeds in those regions rather than rely on small and insignificant gradient differences to direct the watershed operation.
    
    Parameters:
    
    enable - - true to enable quantization, false to disable.
  - isQuantized
```
public boolean isQuantized()
```
    see enableQuantization
    
    Returns:
  - setNumQuanta
```
public void setNumQuanta(int numQuanta)
```
    See enableQuantization You must enableQuantization as well as set the number of quanta.
    
    Parameters:
    
    numQuanta - - the number of quanta in the quantization
  - setOutputImageFactory
```
public void setOutputImageFactory(ImageFactory<LabelingType<L>> factory)
```
    Set the image factory to use when creating the Labeling. By default, we use an image factory that has the same container factory as the input image, but you can customize by supplying an alternate factory.
    
    Parameters:
    
    factory - - a customized factory for generating the labeling containers.
  - getOutputImageFactory
```
public ImageFactory<LabelingType<L>> getOutputImageFactory()
```
  - setOutputLabeling
```
public void setOutputLabeling(Labeling<L> labeling)
```
    Supply a labeling that will be filled with labelings by the image. This method allows the caller to reuse a labeling container rather than create one from scratch for each use.
    
    Parameters:
    
    labeling - - a labeling container that will hold the labeling of the image after process() is called.
  - getNumQuanta
```
public int getNumQuanta()
```
    See setNumQuanta
    
    Returns:
  - checkInput
```
public boolean checkInput()
```
    Specified by:
    
    checkInput in interface Algorithm
  - checkDimensions
```
protected boolean checkDimensions(int[] array)
```
  - checkDimensions
```
protected boolean checkDimensions(double[] array)
```
  - process
```
public boolean process()
```
    Specified by:
    
    process in interface Algorithm
  - getFloatFactory
```
protected ImageFactory<FloatType> getFloatFactory()
```
  - getFloatImage
```
protected Image<FloatType> getFloatImage()
```
  - getErrorMessage
```
public String getErrorMessage()
```
    Specified by:
    
    getErrorMessage in interface Algorithm
  - getResult
```
public Image<LabelingType<L>> getResult()
```
    Specified by:
    
    getResult in interface OutputAlgorithm<LabelingType<L extends Comparable<L>>>
  - filterPeak
```
protected boolean filterPeak(LocalizableByDimCursor<FloatType> imageCursor,
                             int[] peak,
                             int[] dimensions,
                             boolean find_minimum)
```
  - getGradientImage
```
public Image<FloatType> getGradientImage()
```
    Return a difference of gaussian image that measures the gradient at a scale defined by the two sigmas of the gaussians.
    
    Parameters:
    
    image -
    
    sigma1 -
    
    sigma2 -
    
    Returns:

Class GradientWatershed<T extends RealType<T>,L extends Comparable<L>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

input

output

scale

sigma1

sigma2

names

minBackgroundPeakHeight

minForegroundPeakHeight

wantsToQuantize

numQuanta

structuringElement

error_message

labelingFactory

floatImage

floatFactory

Constructor Detail

GradientWatershed

Method Detail

getStructuringElement

cloneStructuringElement

setStructuringElement

getScale

setScale

setMinBackgroundPeakHeight

getMinBackgroundPeakHeight

setMinForegroundPeakHeight

getMinForegroundPeakHeight

enableQuantization

isQuantized

setNumQuanta

setOutputImageFactory

getOutputImageFactory

setOutputLabeling

getNumQuanta

checkInput

checkDimensions

checkDimensions

process

getFloatFactory

getFloatImage

getErrorMessage

getResult

filterPeak

getGradientImage