mpicbg.imglib.algorithm.labeling

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

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

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: