net.imglib2.algorithm.morphology

Class Dilation

java.lang.Object

net.imglib2.algorithm.morphology.Dilation

public class Dilation
extends Object

Method Summary

Modifier and Type	Method and Description
static <T extends net.imglib2.type.numeric.RealType<T>> net.imglib2.img.Img<T>	dilate(net.imglib2.img.Img<T> source, List<? extends Shape> strels, int numThreads) Performs the dilation morphological operation, on a RealType Img using a list of Shapes as a flat structuring element.
static <T extends net.imglib2.type.Type<T> & Comparable<T>> net.imglib2.img.Img<T>	dilate(net.imglib2.img.Img<T> source, List<? extends Shape> strels, T minVal, int numThreads) Performs the dilation morphological operation, on an Img using a list of Shapes as a flat structuring element.
static <T extends net.imglib2.type.numeric.RealType<T>> net.imglib2.img.Img<T>	dilate(net.imglib2.img.Img<T> source, Shape strel, int numThreads) Performs the dilation morphological operation, on a RealType Img using a Shape as a flat structuring element.
static <T extends net.imglib2.type.Type<T> & Comparable<T>> net.imglib2.img.Img<T>	dilate(net.imglib2.img.Img<T> source, Shape strel, T minVal, int numThreads) Performs the dilation morphological operation, on an Img using a Shape as a flat structuring element.
static <T extends net.imglib2.type.numeric.RealType<T>> void	dilate(net.imglib2.RandomAccessible<T> source, net.imglib2.IterableInterval<T> target, List<? extends Shape> strels, int numThreads) Performs the dilation morphological operation, on a RealType RandomAccessible as a source and writing results in an IterableInterval.
static <T extends net.imglib2.type.Type<T> & Comparable<T>> void	dilate(net.imglib2.RandomAccessible<T> source, net.imglib2.IterableInterval<T> target, List<? extends Shape> strels, T minVal, int numThreads) Performs the dilation morphological operation, using a RandomAccessible as a source and writing results in an IterableInterval.
static <T extends net.imglib2.type.numeric.RealType<T>> void	dilate(net.imglib2.RandomAccessible<T> source, net.imglib2.IterableInterval<T> target, Shape strel, int numThreads) Performs the dilation morphological operation, on a RealType RandomAccessible as a source and writing results in an IterableInterval.
static <T extends net.imglib2.type.Type<T> & Comparable<T>> void	dilate(net.imglib2.RandomAccessible<T> source, net.imglib2.IterableInterval<T> target, Shape strel, T minVal, int numThreads) Performs the dilation morphological operation, using a RandomAccessible as a source and writing results in an IterableInterval.
static <T extends net.imglib2.type.numeric.RealType<T>> net.imglib2.img.Img<T>	dilateFull(net.imglib2.img.Img<T> source, List<? extends Shape> strels, int numThreads) Performs the dilation morphological operation, on a RealType Img using a list of Shapes as a flat structuring element.
static <T extends net.imglib2.type.Type<T> & Comparable<T>> net.imglib2.img.Img<T>	dilateFull(net.imglib2.img.Img<T> source, List<? extends Shape> strels, T minVal, int numThreads) Performs the dilation morphological operation, on an Img using a list of Shapes as a flat structuring element.
static <T extends net.imglib2.type.numeric.RealType<T>> net.imglib2.img.Img<T>	dilateFull(net.imglib2.img.Img<T> source, Shape strel, int numThreads) Performs the dilation morphological operation, on a RealType Img using a list of Shapes as a flat structuring element.
static <T extends net.imglib2.type.Type<T> & Comparable<T>> net.imglib2.img.Img<T>	dilateFull(net.imglib2.img.Img<T> source, Shape strel, T minVal, int numThreads) Performs the dilation morphological operation, on an Img using a list of Shapes as a flat structuring element.
static <T extends net.imglib2.type.numeric.RealType<T>> void	dilateInPlace(net.imglib2.RandomAccessibleInterval<T> source, net.imglib2.Interval interval, List<? extends Shape> strels, int numThreads) Performs the dilation morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element.
static <T extends net.imglib2.type.Type<T> & Comparable<T>> void	dilateInPlace(net.imglib2.RandomAccessibleInterval<T> source, net.imglib2.Interval interval, List<? extends Shape> strels, T minVal, int numThreads) Performs the dilation morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element.
static <T extends net.imglib2.type.numeric.RealType<T>> void	dilateInPlace(net.imglib2.RandomAccessibleInterval<T> source, net.imglib2.Interval interval, Shape strel, int numThreads) Performs the dilation morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element.
static <T extends net.imglib2.type.Type<T> & Comparable<T>> void	dilateInPlace(net.imglib2.RandomAccessibleInterval<T> source, net.imglib2.Interval interval, Shape strel, T minVal, int numThreads) Performs the dilation morphological operation, on a RealType 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

dilate

public static <T extends net.imglib2.type.numeric.RealType<T>> net.imglib2.img.Img<T> dilate(net.imglib2.img.Img<T> source,
                                                                                             List<? extends Shape> strels,
                                                                                             int numThreads)

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

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.

The result image has the same dimensions that of the source image. 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 image and the dilation result. Must be a sub-type of T extends RealType.

Parameters:

source - the source image.

strels - the structuring element as a list of Shapes.

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

Returns:

a new Img, of same dimensions than the source.

dilate

public static <T extends net.imglib2.type.Type<T> & Comparable<T>> net.imglib2.img.Img<T> dilate(net.imglib2.img.Img<T> source,
                                                                                                 List<? extends Shape> strels,
                                                                                                 T minVal,
                                                                                                 int numThreads)

Performs the dilation morphological operation, on an Img using a list of Shapes as a flat structuring element. See Dilation_(morphology).

The result image has the same dimensions that of the source image. 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 source image is returned.

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

Type Parameters:

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

Parameters:

source - the source image.

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 Img (against Comparable. This is required to perform a proper mathematical dilation. Because we operate on a generic Type, it has to be provided manually.

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

Returns:

a new Img, of same dimensions than the source.

dilate

public static <T extends net.imglib2.type.numeric.RealType<T>> net.imglib2.img.Img<T> dilate(net.imglib2.img.Img<T> source,
                                                                                             Shape strel,
                                                                                             int numThreads)

Performs the dilation morphological operation, on a RealType Img using a Shape as a flat structuring element. See Dilation_(morphology).

The result image has the same dimensions that of the source image. 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 image and the dilation result. Must be a sub-type of T extends RealType.

Parameters:

source - the source image.

strel - the structuring element as a Shape.

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

Returns:

a new Img, of same dimensions than the source.

dilate

public static <T extends net.imglib2.type.Type<T> & Comparable<T>> net.imglib2.img.Img<T> dilate(net.imglib2.img.Img<T> source,
                                                                                                 Shape strel,
                                                                                                 T minVal,
                                                                                                 int numThreads)

Performs the dilation morphological operation, on an Img using a Shape as a flat structuring element. See Dilation_(morphology).

The result image has the same dimensions that of the source image. 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 a specified minimal value to start comparing to other pixels in the neighborhood. For this code to properly perform dilation, it is sufficient that the specified min value is smaller (against Comparable) than any of the value found in the source image. This normally unseen parameter is required to operate on T extends Comparable & Type.

Type Parameters:

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

Parameters:

source - the source image.

strel - the structuring element as a Shape.

minVal - a T containing set to a value smaller than any of the values in the source Img (against Comparable. This is required to perform a proper mathematical dilation. Because we operate on a generic Type, it has to be provided manually.

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

Returns:

a new Img, of same dimensions than the source.

dilate

public static <T extends net.imglib2.type.numeric.RealType<T>> void dilate(net.imglib2.RandomAccessible<T> source,
                                                                           net.imglib2.IterableInterval<T> target,
                                                                           List<? extends Shape> strels,
                                                                           int numThreads)

Performs the dilation morphological operation, on a RealType RandomAccessible as a source and writing results in an IterableInterval. See Dilation_(morphology).

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.

Parameters:

source - the source RandomAccessible, must be sufficiently padded.

target - the target image.

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

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

dilate

public static <T extends net.imglib2.type.Type<T> & Comparable<T>> void dilate(net.imglib2.RandomAccessible<T> source,
                                                                               net.imglib2.IterableInterval<T> target,
                                                                               List<? extends Shape> strels,
                                                                               T minVal,
                                                                               int numThreads)

Performs the dilation morphological operation, using a RandomAccessible as a source and writing results in an IterableInterval. See Dilation_(morphology).

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 a specified minimal value to start comparing to other pixels in the neighborhood. For this code to properly perform dilation, it is sufficient that the specified min value is smaller (against Comparable) than any of the value found in the source image. This normally unseen parameter is required to operate on T extends Comparable & Type.

Type Parameters:

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

Parameters:

source - the source RandomAccessible, must be sufficiently padded.

target - the target image.

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. This is required to perform a proper mathematical dilation. Because we operate on a generic Type, it has to be provided manually.

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

dilate

public static <T extends net.imglib2.type.numeric.RealType<T>> void dilate(net.imglib2.RandomAccessible<T> source,
                                                                           net.imglib2.IterableInterval<T> target,
                                                                           Shape strel,
                                                                           int numThreads)

Performs the dilation morphological operation, on a RealType RandomAccessible as a source and writing results in an IterableInterval. See Dilation_(morphology).

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.

Parameters:

source - the source RandomAccessible, must be sufficiently padded.

target - the target image.

strel - the structuring element, as a Shape.

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

dilate

public static <T extends net.imglib2.type.Type<T> & Comparable<T>> void dilate(net.imglib2.RandomAccessible<T> source,
                                                                               net.imglib2.IterableInterval<T> target,
                                                                               Shape strel,
                                                                               T minVal,
                                                                               int numThreads)

Performs the dilation morphological operation, using a RandomAccessible as a source and writing results in an IterableInterval. See Dilation_(morphology).

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 a specified minimal value to start comparing to other pixels in the neighborhood. For this code to properly perform dilation, it is sufficient that the specified min value is smaller (against Comparable) than any of the value found in the source image. This normally unseen parameter is required to operate on T extends Comparable & Type.

Type Parameters:

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

Parameters:

source - the source RandomAccessible, must be sufficiently padded.

target - the target image.

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. This is required to perform a proper mathematical dilation. Because we operate on a generic Type, it has to be provided manually.

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

dilateFull

public static <T extends net.imglib2.type.numeric.RealType<T>> net.imglib2.img.Img<T> dilateFull(net.imglib2.img.Img<T> source,
                                                                                                 List<? extends Shape> strels,
                                                                                                 int numThreads)

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

This method performs what is called the 'full' dilation. That is: the result image has its dimension enlarged by the structuring element, with respect to the source image. 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 source image is returned.

Warning: Current implementation does not do stricto sensu the full dilation. Indeed, if the structuring element has more dimensions than the source Img, they are ignored, and the returned Img has the same number of dimensions that of the source (but dilated). This is due to the fact that we use a Shape for structuring elements, and that it does not return a number of dimensions. The neighborhood created have therefore at most as many dimensions as the source image. The real, full dilation results should have a number of dimensions equals to the maximum of the number of dimension of both source and structuring element.

Type Parameters:

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

Parameters:

source - the source image.

strels - the structuring element as a list of Shapes.

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

Returns:

a new Img, possibly of larger dimensions than the source.

dilateFull

public static <T extends net.imglib2.type.Type<T> & Comparable<T>> net.imglib2.img.Img<T> dilateFull(net.imglib2.img.Img<T> source,
                                                                                                     List<? extends Shape> strels,
                                                                                                     T minVal,
                                                                                                     int numThreads)

Performs the dilation morphological operation, on an Img using a list of Shapes as a flat structuring element. See Dilation_(morphology).

This method performs what is called the 'full' dilation. That is: the result image has its dimension enlarged by the structuring element, with respect to the source image. 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 source image is returned.

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

Warning: Current implementation does not do stricto sensu the full dilation. Indeed, if the structuring element has more dimensions than the source Img, they are ignored, and the returned Img has the same number of dimensions that of the source (but dilated). This is due to the fact that we use a Shape for structuring elements, and that it does not return a number of dimensions. The neighborhood created have therefore at most as many dimensions as the source image. The real, full dilation results should have a number of dimensions equals to the maximum of the number of dimension of both source and structuring element.

Type Parameters:

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

Parameters:

source - the source image.

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 Img (against Comparable. This is required to perform a proper mathematical dilation. Because we operate on a generic Type, it has to be provided manually.

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

Returns:

a new Img, possibly of larger dimensions than the source.

dilateFull

public static <T extends net.imglib2.type.numeric.RealType<T>> net.imglib2.img.Img<T> dilateFull(net.imglib2.img.Img<T> source,
                                                                                                 Shape strel,
                                                                                                 int numThreads)

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

This method performs what is called the 'full' dilation. That is: the result image has its dimension enlarged by the structuring element, with respect to the source image. 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.

Warning: Current implementation does not do stricto sensu the full dilation. Indeed, if the structuring element has more dimensions than the source Img, they are ignored, and the returned Img has the same number of dimensions that of the source (but dilated). This is due to the fact that we use a Shape for structuring elements, and that it does not return a number of dimensions. The neighborhood created have therefore at most as many dimensions as the source image. The real, full dilation results should have a number of dimensions equals to the maximum of the number of dimension of both source and structuring element.

Type Parameters:

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

Parameters:

source - the source image.

strel - the structuring element as Shape.

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

Returns:

a new Img, possibly of larger dimensions than the source.

dilateFull

public static <T extends net.imglib2.type.Type<T> & Comparable<T>> net.imglib2.img.Img<T> dilateFull(net.imglib2.img.Img<T> source,
                                                                                                     Shape strel,
                                                                                                     T minVal,
                                                                                                     int numThreads)

Performs the dilation morphological operation, on an Img using a list of Shapes as a flat structuring element. See Dilation_(morphology).

This method performs what is called the 'full' dilation. That is: the result image has its dimension enlarged by the structuring element, with respect to the source image. 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 a specified minimal value to start comparing to other pixels in the neighborhood. For this code to properly perform dilation, it is sufficient that the specified min value is smaller (against Comparable) than any of the value found in the source image. This normally unseen parameter is required to operate on T extends Comparable & Type.

Warning: Current implementation does not do stricto sensu the full dilation. Indeed, if the structuring element has more dimensions than the source Img, they are ignored, and the returned Img has the same number of dimensions that of the source (but dilated). This is due to the fact that we use a Shape for structuring elements, and that it does not return a number of dimensions. The neighborhood created have therefore at most as many dimensions as the source image. The real, full dilation results should have a number of dimensions equals to the maximum of the number of dimension of both source and structuring element.

Type Parameters:

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

Parameters:

source - the source image.

strel - the structuring element as a Shape.

minVal - a T containing set to a value smaller than any of the values in the source Img (against Comparable. This is required to perform a proper mathematical dilation. Because we operate on a generic Type, it has to be provided manually.

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

Returns:

a new Img, possibly of larger dimensions than the source.

dilateInPlace

public static <T extends net.imglib2.type.numeric.RealType<T>> void dilateInPlace(net.imglib2.RandomAccessibleInterval<T> source,
                                                                                  net.imglib2.Interval interval,
                                                                                  List<? extends Shape> strels,
                                                                                  int numThreads)

Performs the dilation morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element. See Dilation_(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 returned.

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.

dilateInPlace

public static <T extends net.imglib2.type.Type<T> & Comparable<T>> void dilateInPlace(net.imglib2.RandomAccessibleInterval<T> source,
                                                                                      net.imglib2.Interval interval,
                                                                                      List<? extends Shape> strels,
                                                                                      T minVal,
                                                                                      int numThreads)

Performs the dilation morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element. See Dilation_(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 returned. *

This method relies on a specified minimal value to start comparing to other pixels in the neighborhood. For this code to properly perform dilation, it is sufficient that the specified min value is smaller (against Comparable) than any of the value found in the source image. This normally unseen parameter is 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 & Type.

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. This is required to perform a proper mathematical dilation. Because we operate on a generic Type, it has to be provided manually.

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

dilateInPlace

public static <T extends net.imglib2.type.numeric.RealType<T>> void dilateInPlace(net.imglib2.RandomAccessibleInterval<T> source,
                                                                                  net.imglib2.Interval interval,
                                                                                  Shape strel,
                                                                                  int numThreads)

Performs the dilation morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element. See Dilation_(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.

dilateInPlace

public static <T extends net.imglib2.type.Type<T> & Comparable<T>> void dilateInPlace(net.imglib2.RandomAccessibleInterval<T> source,
                                                                                      net.imglib2.Interval interval,
                                                                                      Shape strel,
                                                                                      T minVal,
                                                                                      int numThreads)

Performs the dilation morphological operation, on a RealType RandomAccessibleInterval using a Shape as a flat structuring element. See Dilation_(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 a specified minimal value to start comparing to other pixels in the neighborhood. For this code to properly perform dilation, it is sufficient that the specified min value is smaller (against Comparable) than any of the value found in the source image. This normally unseen parameter is 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 & Type.

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. This is required to perform a proper mathematical dilation. Because we operate on a generic Type, it has to be provided manually.

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