net.imglib2.algorithm.morphology

Class Opening

java.lang.Object

net.imglib2.algorithm.morphology.Opening

public class Opening
extends Object

Morphological opening for ImgLib2. See Opening_( morphology).

Author:

Jean-Yves Tinevez - 2014

Method Summary

Modifier and Type	Method and Description
static <T extends RealType<T>> Img<T>	open(Img<T> source, List<? extends Shape> strels, int numThreads) Performs the morphological opening operation on a RealType Img, using a list of Shapes as a structuring element.
static <T extends Type<T> & Comparable<T>> Img<T>	open(Img<T> source, List<? extends Shape> strels, T minVal, T maxVal, int numThreads) Performs the morphological opening operation on an Img of Comparable , using a list of Shapes as a structuring element.
static <T extends RealType<T>> Img<T>	open(Img<T> source, Shape strel, int numThreads) Performs the morphological opening operation on a RealType Img, using a Shape as a structuring element.
static <T extends Type<T> & Comparable<T>> Img<T>	open(Img<T> source, Shape strel, T minVal, T maxVal, int numThreads) Performs the morphological opening operation on an Img of Comparable , using a Shape as a structuring element.
static <T extends RealType<T>> void	open(RandomAccessible<T> source, IterableInterval<T> target, List<? extends Shape> strels, int numThreads) Performs the morphological opening operation on a RealType source RandomAccessible, using a list of Shapes as a structuring element, and writes the result on a specified target which must be an IterableInterval.
static <T extends Type<T> & Comparable<T>> void	open(RandomAccessible<T> source, IterableInterval<T> target, List<? extends Shape> strels, T minVal, T maxVal, int numThreads) Performs the morphological opening operation on a source RandomAccessible, using a list of Shapes as a structuring element, and writes the result on a specified target which must be an IterableInterval.
static <T extends RealType<T>> void	open(RandomAccessible<T> source, IterableInterval<T> target, Shape strel, int numThreads) Performs the morphological opening operation on a RealType source RandomAccessible, using a Shape as a structuring element, and writes the result on a specified target which must be an IterableInterval.
static <T extends Type<T> & Comparable<T>> void	open(RandomAccessible<T> source, IterableInterval<T> target, Shape strel, T minVal, T maxVal, int numThreads) Performs the morphological opening operation on a source RandomAccessible, using a Shape as a structuring element, and writes the result on a specified target which must be an IterableInterval.
static <T extends RealType<T>> void	openInPlace(RandomAccessibleInterval<T> source, Interval interval, List<? extends Shape> strels, int numThreads) Performs the opening morphological operation, on a source RandomAccessibleInterval using a list of Shapes as a flat structuring element.
static <T extends Type<T> & Comparable<T>> void	openInPlace(RandomAccessibleInterval<T> source, Interval interval, List<? extends Shape> strels, T minVal, T maxVal, int numThreads) Performs the opening morphological operation, on a RandomAccessibleInterval using a list of Shapes as a flat structuring element.
static <T extends RealType<T>> void	openInPlace(RandomAccessibleInterval<T> source, Interval interval, Shape strel, int numThreads) Performs the opening morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element.
static <T extends Type<T> & Comparable<T>> void	openInPlace(RandomAccessibleInterval<T> source, Interval interval, Shape strel, T minVal, T maxVal, int numThreads) Performs the opening morphological operation, on a RandomAccessibleInterval using a Shape as a flat structuring element.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

open

public static final <T extends RealType<T>> Img<T> open(Img<T> source,
                                                        List<? extends Shape> strels,
                                                        int numThreads)

Performs the morphological opening operation on a RealType Img, using a list of Shapes as a structuring element. See Opening_( morphology).

The opening operation is simply an erosion followed by a dilation.

The structuring element is specified through a list of Shapes, to allow for performance optimization through structuring element decomposition. Each shape is processed in order as given in the list. If the list is empty, the source image is returned.

Type Parameters:

T - the type of the source image and the result image. Must extends RealType.

Parameters:

source - the Img to operate on.

strels - the list of Shapes that serves as a structuring element.

numThreads - the number of threads to use for calculation.

Returns:

an Img of the same type and same dimensions that of the source.

open

public static final <T extends Type<T> & Comparable<T>> Img<T> open(Img<T> source,
                                                                    List<? extends Shape> strels,
                                                                    T minVal,
                                                                    T maxVal,
                                                                    int numThreads)

Performs the morphological opening operation on an Img of Comparable , using a list of Shapes as a structuring element. See Opening_(morphology).

The opening operation is simply an erosion followed by a dilation.

The structuring element is specified through a list of Shapes, to allow for performance optimization through structuring element decomposition. Each shape is processed in order as given in the list. If the list is empty, the source image is returned.

This method relies on a specified minimal and maximal value to start comparing to other pixels in the neighborhood. For this code to perform properly, it is sufficient that the specified min value is smaller (against Comparable) than any of the value found in the source image, and the converse for the max value. These normally unseen parameters are required to operate on T extends Comparable & Type.

Type Parameters:

T - the type of the source image and the result. Must be a sub-type of T extends Comparable & Type.

Parameters:

source - the Img to operate on.

strels - the list of Shapes that serves as a structuring element.

minVal - a T containing set to a value smaller than any of the values in the source Img (against Comparable).

maxVal - a T containing set to a value larger than any of the values in the source Img (against Comparable).

numThreads - the number of threads to use for calculation.

Returns:

an Img of the same type and same dimensions that of the source.

open

public static final <T extends RealType<T>> Img<T> open(Img<T> source,
                                                        Shape strel,
                                                        int numThreads)

Performs the morphological opening operation on a RealType Img, using a Shape as a structuring element. See Opening_(morphology).

The opening operation is simply an erosion followed by a dilation.

Type Parameters:

T - the type of the source image and the result image. Must extends RealType.

Parameters:

source - the Img to operate on.

strel - the Shape that serves as a structuring element.

numThreads - the number of threads to use for calculation.

Returns:

an Img of the same type and same dimensions that of the source.

open

public static final <T extends Type<T> & Comparable<T>> Img<T> open(Img<T> source,
                                                                    Shape strel,
                                                                    T minVal,
                                                                    T maxVal,
                                                                    int numThreads)

Performs the morphological opening operation on an Img of Comparable , using a Shape as a structuring element. See Opening_(morphology).

The opening operation is simply an erosion followed by a dilation.

This method relies on a specified minimal and maximal value to start comparing to other pixels in the neighborhood. For this code to perform properly, it is sufficient that the specified min value is smaller (against Comparable) than any of the value found in the source image, and the converse for the max value. These normally unseen parameters are required to operate on T extends Comparable & Type.

Type Parameters:

T - the type of the source image and the result. Must be a sub-type of T extends Comparable & Type.

Parameters:

source - the Img to operate on.

strel - the Shape that serves as a structuring element.

minVal - a T containing set to a value smaller than any of the values in the source Img (against Comparable).

maxVal - a T containing set to a value larger than any of the values in the source Img (against Comparable).

numThreads - the number of threads to use for calculation.

Returns:

an Img of the same type and same dimensions that of the source.

open

public static <T extends RealType<T>> void open(RandomAccessible<T> source,
                                                IterableInterval<T> target,
                                                List<? extends Shape> strels,
                                                int numThreads)

Performs the morphological opening operation on a RealType source RandomAccessible, using a list of Shapes as a structuring element, and writes the result on a specified target which must be an IterableInterval. See Opening_(morphology).

The opening operation is simply an erosion followed by a dilation.

Careful: Target must point to a different structure than source. In place operation will not work but will not generate an error.

It is the caller responsibility to ensure that the source is sufficiently padded to properly cover the target range plus the shape size. See e.g. Views.extendValue(RandomAccessibleInterval, Type)

It is limited to flat structuring elements, only having on/off pixels, contrary to grayscale structuring elements. This allows to simply use a Shape as a type for these structuring elements.

The structuring element is specified through a list of Shapes, to allow for performance optimization through structuring element decomposition. Each shape is processed in order as given in the list. If the list is empty, the target is left untouched.

Type Parameters:

T - the type of the source and the result. Must extends RealType.

Parameters:

source - the RandomAccessible to operate on.

target - the IterableInterval to write the results on.

strels - the structuring element, as a list of Shapes.

numThreads - the number of threads to use for calculation.

open

public static <T extends Type<T> & Comparable<T>> void open(RandomAccessible<T> source,
                                                            IterableInterval<T> target,
                                                            List<? extends Shape> strels,
                                                            T minVal,
                                                            T maxVal,
                                                            int numThreads)

Performs the morphological opening operation on a source RandomAccessible, using a list of Shapes as a structuring element, and writes the result on a specified target which must be an IterableInterval. See Opening_(morphology).

The opening operation is simply an erosion followed by a dilation.

Careful: Target must point to a different structure than source. In place operation will not work but will not generate an error.

It is the caller responsibility to ensure that the source is sufficiently padded to properly cover the target range plus the shape size. See e.g. Views.extendValue(RandomAccessibleInterval, Type)

It is limited to flat structuring elements, only having on/off pixels, contrary to grayscale structuring elements. This allows to simply use a Shape as a type for these structuring elements.

The structuring element is specified through a list of Shapes, to allow for performance optimization through structuring element decomposition. Each shape is processed in order as given in the list. If the list is empty, the target is left untouched.

This method relies on specified minimal and maximal values to start comparing to other pixels in the neighborhood. For this code to properly perform opening, it is sufficient that the specified max value is larger (against Comparable) than any of the value found in the source image, and conversely for the min value. These normally unseen parameters are required to operate on T extends Comparable & Type.

Type Parameters:

T - the type of the source and the result. Must extends Compparable.

Parameters:

source - the RandomAccessible to operate on.

target - the IterableInterval to write the results on.

strels - the structuring element, as a list of Shapes.

minVal - a T containing set to a value smaller than any of the values in the source (against Comparable).

maxVal - a T containing set to a value larger than any of the values in the source (against Comparable).

numThreads - the number of threads to use for calculation.

open

public static <T extends RealType<T>> void open(RandomAccessible<T> source,
                                                IterableInterval<T> target,
                                                Shape strel,
                                                int numThreads)

Performs the morphological opening operation on a RealType source RandomAccessible, using a Shape as a structuring element, and writes the result on a specified target which must be an IterableInterval. See Opening_(morphology).

The opening operation is simply an erosion followed by a dilation.

Careful: Target must point to a different structure than source. In place operation will not work but will not generate an error.

It is the caller responsibility to ensure that the source is sufficiently padded to properly cover the target range plus the shape size. See e.g. Views.extendValue(RandomAccessibleInterval, Type)

It is limited to flat structuring elements, only having on/off pixels, contrary to grayscale structuring elements. This allows to simply use a Shape as a type for these structuring elements.

Type Parameters:

T - the type of the source and the result. Must extends RealType.

Parameters:

source - the RandomAccessible to operate on.

target - the IterableInterval to write the results on.

strel - the Shape that serves as a structuring element.

numThreads - the number of threads to use for calculation.

open

public static <T extends Type<T> & Comparable<T>> void open(RandomAccessible<T> source,
                                                            IterableInterval<T> target,
                                                            Shape strel,
                                                            T minVal,
                                                            T maxVal,
                                                            int numThreads)

Performs the morphological opening operation on a source RandomAccessible, using a Shape as a structuring element, and writes the result on a specified target which must be an IterableInterval. See Opening_(morphology).

The opening operation is simply an erosion followed by a dilation.

Careful: Target must point to a different structure than source. In place operation will not work but will not generate an error.

It is the caller responsibility to ensure that the source is sufficiently padded to properly cover the target range plus the shape size. See e.g. Views.extendValue(RandomAccessibleInterval, Type)

It is limited to flat structuring elements, only having on/off pixels, contrary to grayscale structuring elements. This allows to simply use a Shape as a type for these structuring elements.

This method relies on specified minimal and maximal values to start comparing to other pixels in the neighborhood. For this code to properly perform opening, it is sufficient that the specified max value is larger (against Comparable) than any of the value found in the source image, and conversely for the min value. These normally unseen parameters are required to operate on T extends Comparable & Type.

Type Parameters:

T - the type of the source and the result. Must extends Comparable.

Parameters:

source - the RandomAccessible to operate on.

target - the IterableInterval to write the results on.

strel - the Shape that serves as a structuring element.

minVal - a T containing set to a value smaller than any of the values in the source (against Comparable).

maxVal - a T containing set to a value larger than any of the values in the source (against Comparable).

numThreads - the number of threads to use for calculation.

openInPlace

public static <T extends RealType<T>> void openInPlace(RandomAccessibleInterval<T> source,
                                                       Interval interval,
                                                       List<? extends Shape> strels,
                                                       int numThreads)

Performs the opening morphological operation, on a source RandomAccessibleInterval using a list of Shapes as a flat structuring element. See Opening_(morphology).

The result is written in the source image. This method is limited to flat structuring elements, only having on/off pixels, contrary to grayscale structuring elements. This allows to simply use a Shape as a type for these structuring elements.

It is the caller responsibility to ensure that the source is sufficiently padded to properly cover the target range plus the shape size. See e.g. Views.extendValue(RandomAccessibleInterval, Type) *

The structuring element is specified through a list of Shapes, to allow for performance optimization through structuring element decomposition. Each shape is processed in order as given in the list. If the list is empty, the source image is left untouched.

Type Parameters:

T - the type of the source image. Must be a sub-type of T extends RealType.

Parameters:

source - the source image.

interval - an interval in the source image to process.

strels - the structuring element as a list of Shapes.

numThreads - the number of threads to use for the calculation.

openInPlace

public static <T extends Type<T> & Comparable<T>> void openInPlace(RandomAccessibleInterval<T> source,
                                                                   Interval interval,
                                                                   List<? extends Shape> strels,
                                                                   T minVal,
                                                                   T maxVal,
                                                                   int numThreads)

Performs the opening morphological operation, on a RandomAccessibleInterval using a list of Shapes as a flat structuring element. See Opening_(morphology).

The result is written in the source image. This method is limited to flat structuring elements, only having on/off pixels, contrary to grayscale structuring elements. This allows to simply use a Shape as a type for these structuring elements.

It is the caller responsibility to ensure that the source is sufficiently padded to properly cover the target range plus the shape size. See e.g. Views.extendValue(RandomAccessibleInterval, Type)

The structuring element is specified through a list of Shapes, to allow for performance optimization through structuring element decomposition. Each shape is processed in order as given in the list. If the list is empty, the source image is left untouched.

This method relies on specified minimal and maximal values to start comparing to other pixels in the neighborhood. For this code to properly perform opening, it is sufficient that the specified max value is larger (against Comparable) than any of the value found in the source image, and conversely for the min value. These normally unseen parameters are required to operate on T extends Comparable & Type.

Type Parameters:

T - the type of the source image. Must be a sub-type of T extends Comparable.

Parameters:

source - the source image.

interval - an interval in the source image to process.

strels - the structuring element as a list of Shapes.

minVal - a T containing set to a value smaller than any of the values in the source (against Comparable).

maxVal - a T containing set to a value larger than any of the values in the source (against Comparable).

numThreads - the number of threads to use for the calculation.

openInPlace

public static <T extends RealType<T>> void openInPlace(RandomAccessibleInterval<T> source,
                                                       Interval interval,
                                                       Shape strel,
                                                       int numThreads)

Performs the opening morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element. See Opening_(morphology).

The result is written in the source image. This method is limited to flat structuring elements, only having on/off pixels, contrary to grayscale structuring elements. This allows to simply use a Shape as a type for these structuring elements.

It is the caller responsibility to ensure that the source is sufficiently padded to properly cover the target range plus the shape size. See e.g. Views.extendValue(RandomAccessibleInterval, Type).

Type Parameters:

T - the type of the source image. Must be a sub-type of T extends RealType.

Parameters:

source - the source image.

interval - an interval in the source image to process.

strel - the structuring element as a Shape.

numThreads - the number of threads to use for the calculation.

openInPlace

public static <T extends Type<T> & Comparable<T>> void openInPlace(RandomAccessibleInterval<T> source,
                                                                   Interval interval,
                                                                   Shape strel,
                                                                   T minVal,
                                                                   T maxVal,
                                                                   int numThreads)

Performs the opening morphological operation, on a RandomAccessibleInterval using a Shape as a flat structuring element. See Opening_(morphology).

The result is written in the source image. This method is limited to flat structuring elements, only having on/off pixels, contrary to grayscale structuring elements. This allows to simply use a Shape as a type for these structuring elements.

It is the caller responsibility to ensure that the source is sufficiently padded to properly cover the target range plus the shape size. See e.g. Views.extendValue(RandomAccessibleInterval, Type)

This method relies on specified minimal and maximal values to start comparing to other pixels in the neighborhood. For this code to properly perform opening, it is sufficient that the specified max value is larger (against Comparable) than any of the value found in the source image, and conversely for the min value. These normally unseen parameters are required to operate on T extends Comparable & Type.

Type Parameters:

T - the type of the source image. Must be a sub-type of T extends Comparable.

Parameters:

source - the source image.

interval - an interval in the source image to process.

strel - the structuring element as a Shape.

minVal - a T containing set to a value smaller than any of the values in the source (against Comparable).

maxVal - a T containing set to a value larger than any of the values in the source (against Comparable).

numThreads - the number of threads to use for the calculation.