DistanceTransform (ImgLib2 Javadocs 0-SNAPSHOT API)

java.lang.Object
- net.imglib2.algorithm.morphology.distance.DistanceTransform

```
public class DistanceTransform
extends Object
```
ImgLib2 implementation of n-dimensional distance transform D of sampled functions f with distance measure d: Distance Transforms of Sampled Functions (DOI:ch 10.4086/toc.2012.v008a019).
D( p ) = min_q f(q) + d(p,q) where p,q are points on a grid/image.

The implemented algorithm has complexity O(dn) where d is the number of dimensions of the image, and n is the total number of pixels/voxels.

Author:

Philipp Hanslovsky

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class DistanceTransform.DISTANCE_TYPE
Switch for calling convenience method with pre-defined distances.

Nested Classes
Modifier and Type	Class and Description
`static class`	`DistanceTransform.DISTANCE_TYPE` Switch for calling convenience method with pre-defined distances.

Constructor Summary

Constructors
Constructor and Description

DistanceTransform()

Constructors
Constructor and Description
`DistanceTransform()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <B extends BooleanType<B>,U extends RealType<U>> void`	`binaryTransform(RandomAccessible<B> source, RandomAccessibleInterval<U> target, Distance d)` Create binary distance transform on `source` using arbitrary `Distance` d.
`static <B extends BooleanType<B>,U extends RealType<U>> void`	`binaryTransform(RandomAccessible<B> source, RandomAccessibleInterval<U> target, Distance d, ExecutorService es, int nTasks)` Create binary distance transform on `source` using arbitrary `Distance` d.
`static <B extends BooleanType<B>,U extends RealType<U>> void`	`binaryTransform(RandomAccessible<B> source, RandomAccessibleInterval<U> target, DistanceTransform.DISTANCE_TYPE distanceType, double... weights)` Create binary distance transform on `source` using squared Euclidian (L2) or L1 distance.
`static <B extends BooleanType<B>,U extends RealType<U>> void`	`binaryTransform(RandomAccessible<B> source, RandomAccessibleInterval<U> target, DistanceTransform.DISTANCE_TYPE distanceType, ExecutorService es, int nTasks, double... weights)` Create binary distance transform on `source` using squared Euclidian (L2) or L1 distance.
`static <B extends BooleanType<B>,U extends RealType<U>,V extends RealType<V>> void`	`binaryTransform(RandomAccessible<B> source, RandomAccessibleInterval<U> tmp, RandomAccessibleInterval<V> target, Distance d)` Create binary distance transform on `source` using arbitrary `Distance` d.
`static <B extends BooleanType<B>,U extends RealType<U>,V extends RealType<V>> void`	`binaryTransform(RandomAccessible<B> source, RandomAccessibleInterval<U> tmp, RandomAccessibleInterval<V> target, Distance d, ExecutorService es, int nTasks)` Create binary distance transform on `source` using arbitrary `Distance` d.
`static <B extends BooleanType<B>,U extends RealType<U>,V extends RealType<V>> void`	`binaryTransform(RandomAccessible<B> source, RandomAccessibleInterval<U> tmp, RandomAccessibleInterval<V> target, DistanceTransform.DISTANCE_TYPE distanceType, double... weights)` Create binary distance transform on `source` using squared Euclidian (L2) or L1 distance.
`static <B extends BooleanType<B>,U extends RealType<U>,V extends RealType<V>> void`	`binaryTransform(RandomAccessible<B> source, RandomAccessibleInterval<U> tmp, RandomAccessibleInterval<V> target, DistanceTransform.DISTANCE_TYPE distanceType, ExecutorService es, int nTasks, double... weights)` Create binary distance transform on `source` using squared Euclidian (L2) or L1 distance.
`static <B extends BooleanType<B>> void`	`binaryTransform(RandomAccessibleInterval<B> source, Distance d, ExecutorService es, int nTasks)` Create binary distance transform on `source` using arbitrary `Distance` d.
`static int`	`getLargestDimension(Interval interval)` Convenience method to find largest dimension of `Interval` interval.
`static <T extends RealType<T>,U extends RealType<U>> void`	`transform(RandomAccessible<T> source, RandomAccessibleInterval<U> target, Distance d)` Create distance transforms of sampled functions on `source` using arbitrary `Distance` d.
`static <T extends RealType<T>,U extends RealType<U>> void`	`transform(RandomAccessible<T> source, RandomAccessibleInterval<U> target, Distance d, ExecutorService es, int nTasks)` Create distance transforms of sampled functions on `source` using arbitrary `Distance` d.
`static <T extends RealType<T>,U extends RealType<U>> void`	`transform(RandomAccessible<T> source, RandomAccessibleInterval<U> target, DistanceTransform.DISTANCE_TYPE distanceType, double... weights)` Create distance transforms of sampled functions on `source` using squared Euclidian (L2) or L1 distance.
`static <T extends RealType<T>,U extends RealType<U>> void`	`transform(RandomAccessible<T> source, RandomAccessibleInterval<U> target, DistanceTransform.DISTANCE_TYPE distanceType, ExecutorService es, int nTasks, double... weights)` Create distance transforms of sampled functions on `source` using squared Euclidian (L2) or L1 distance.
`static <T extends RealType<T>,U extends RealType<U>,V extends RealType<V>> void`	`transform(RandomAccessible<T> source, RandomAccessibleInterval<U> tmp, RandomAccessibleInterval<V> target, Distance d)` Create distance transforms of sampled functions on `source` using arbitrary `Distance` d.
`static <T extends RealType<T>,U extends RealType<U>,V extends RealType<V>> void`	`transform(RandomAccessible<T> source, RandomAccessibleInterval<U> tmp, RandomAccessibleInterval<V> target, Distance d, ExecutorService es, int nTasks)` Create distance transforms of sampled functions on `source` using arbitrary `Distance` d.
`static <T extends RealType<T>,U extends RealType<U>,V extends RealType<V>> void`	`transform(RandomAccessible<T> source, RandomAccessibleInterval<U> tmp, RandomAccessibleInterval<V> target, DistanceTransform.DISTANCE_TYPE distanceType, double... weights)` Create distance transforms of sampled functions on `source` using squared Euclidian (L2) or L1 distance.
`static <T extends RealType<T>,U extends RealType<U>,V extends RealType<V>> void`	`transform(RandomAccessible<T> source, RandomAccessibleInterval<U> tmp, RandomAccessibleInterval<V> target, DistanceTransform.DISTANCE_TYPE distanceType, ExecutorService es, int nTasks, double... weights)` Create distance transforms of sampled functions on `source` using squared Euclidian (L2) or L1 distance.
`static <T extends RealType<T>> void`	`transform(RandomAccessibleInterval<T> source, Distance d)` Create distance transforms of sampled functions on `source` using arbitrary `Distance` d.
`static <T extends RealType<T>> void`	`transform(RandomAccessibleInterval<T> source, Distance d, ExecutorService es, int nTasks)` Create distance transforms of sampled functions on `source` using arbitrary `Distance` d.
`static <T extends RealType<T>> void`	`transform(RandomAccessibleInterval<T> source, DistanceTransform.DISTANCE_TYPE distanceType, double... weights)` Create distance transforms of sampled functions on `source` using squared Euclidian (L2) or L1 distance.
`static <T extends RealType<T>> void`	`transform(RandomAccessibleInterval<T> source, DistanceTransform.DISTANCE_TYPE distanceType, ExecutorService es, int nTasks, double... weights)` Create distance transforms of sampled functions on `source` using squared Euclidian (L2) or L1 distance.

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

Constructor Detail
- DistanceTransform
```
public DistanceTransform()
```

Method Detail

transform
```
public static <T extends RealType<T>> void transform(RandomAccessibleInterval<T> source,
 DistanceTransform.DISTANCE_TYPE distanceType,
 double... weights)
```
Create distance transforms of sampled functions on source using squared Euclidian (L2) or L1 distance. Intermediate and final results will be stored in source (DoubleType recommended). The distance can be weighted (individually for each dimension, if desired) against the image values via the weights parameter.

Type Parameters:

T - RealType input

Parameters:

source - Input function on which distance transform should be computed.

distanceType - Defines distance to be used: squared Euclidian or L1

weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).

transform
```
public static <T extends RealType<T>> void transform(RandomAccessibleInterval<T> source,
 DistanceTransform.DISTANCE_TYPE distanceType,
 ExecutorService es,
 int nTasks,
 double... weights)
 throws InterruptedException,
 ExecutionException
```
Create distance transforms of sampled functions on source using squared Euclidian (L2) or L1 distance. Intermediate and final results will be stored in source (DoubleType recommended). The distance can be weighted (individually for each dimension, if desired) against the image values via the weights parameter.

Type Parameters:

T - RealType input

Parameters:

source - Input function on which distance transform should be computed.

distanceType - Defines distance to be used: squared Euclidian or L1

es - ExecutorService for parallel execution.

nTasks - Number of tasks/parallelism

weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).

Throws:

InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially)

ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

transform
```
public static <T extends RealType<T>,U extends RealType> void transform(RandomAccessible<T> source,
 RandomAccessibleInterval target,
 DistanceTransform.DISTANCE_TYPE distanceType,
 double... weights)
```
Create distance transforms of sampled functions on source using squared Euclidian (L2) or L1 distance. Intermediate results will be stored in target (DoubleType recommended). The distance can be weighted (individually for each dimension, if desired) against the image values via the weights parameter.

Type Parameters:

T - RealType input

U - RealType intermediate results

Parameters:

source - Input function on which distance transform should be computed.

target - Intermediate and final results of distance transform.

distanceType - Defines distance to be used: squared Euclidian or L1

weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).

transform
```
public static <T extends RealType<T>,U extends RealType> void transform(RandomAccessible<T> source,
 RandomAccessibleInterval target,
 DistanceTransform.DISTANCE_TYPE distanceType,
 ExecutorService es,
 int nTasks,
 double... weights)
 throws InterruptedException,
 ExecutionException
```
Create distance transforms of sampled functions on source using squared Euclidian (L2) or L1 distance. Intermediate results will be stored in target (DoubleType recommended). The distance can be weighted (individually for each dimension, if desired) against the image values via the weights parameter.

Type Parameters:

T - RealType input

U - RealType intermediate results

Parameters:

source - Input function on which distance transform should be computed.

target - Intermediate and final results of distance transform.

distanceType - Defines distance to be used: squared Euclidian or L1

es - ExecutorService for parallel execution.

nTasks - Number of tasks/parallelism

weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).

Throws:

InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially)

ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

transform

public static <T extends RealType<T>,U extends RealType<U>,V extends RealType<V>> void transform(RandomAccessible<T> source,
                                                                                                 RandomAccessibleInterval<U> tmp,
                                                                                                 RandomAccessibleInterval<V> target,
                                                                                                 DistanceTransform.DISTANCE_TYPE distanceType,
                                                                                                 double... weights)

Create distance transforms of sampled functions on source using squared Euclidian (L2) or L1 distance. Intermediate results will be stored in tmp (DoubleType recommended). The output will be written into target. The distance can be weighted (individually for each dimension, if desired) against the image values via the weights parameter.

Type Parameters:: T - RealType input; U - RealType intermediate results; V - RealType output
Parameters:: source - Input function on which distance transform should be computed.; tmp - Storage for intermediate results.; target - Final result of distance transform.; distanceType - Defines distance to be used: squared Euclidian or L1; weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).

transform

public static <T extends RealType<T>,U extends RealType<U>,V extends RealType<V>> void transform(RandomAccessible<T> source,
                                                                                                 RandomAccessibleInterval<U> tmp,
                                                                                                 RandomAccessibleInterval<V> target,
                                                                                                 DistanceTransform.DISTANCE_TYPE distanceType,
                                                                                                 ExecutorService es,
                                                                                                 int nTasks,
                                                                                                 double... weights)
                                                                                          throws InterruptedException,
                                                                                                 ExecutionException

Type Parameters:: T - RealType input; U - RealType intermediate results; V - RealType output
Parameters:: source - Input function on which distance transform should be computed.; tmp - Storage for intermediate results.; target - Final result of distance transform.; distanceType - Defines distance to be used: squared Euclidian or L1; es - ExecutorService for parallel execution.; nTasks - Number of tasks/parallelism; weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).
Throws:: InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially); ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

transform
```
public static <T extends RealType<T>> void transform(RandomAccessibleInterval<T> source,
 Distance d)
```
Create distance transforms of sampled functions on source using arbitrary Distance d. Intermediate and final results will be stored in source (DoubleType recommended).

Type Parameters:

T - RealType input

Parameters:

source - Input function on which distance transform should be computed.

d - Distance between two points.

transform
```
public static <T extends RealType<T>> void transform(RandomAccessibleInterval<T> source,
 Distance d,
 ExecutorService es,
 int nTasks)
 throws InterruptedException,
 ExecutionException
```
Create distance transforms of sampled functions on source using arbitrary Distance d. Intermediate and final results will be stored in source (DoubleType recommended).

Type Parameters:

T - RealType input

Parameters:

source - Input function on which distance transform should be computed.

d - Distance between two points.

es - ExecutorService for parallel execution.

nTasks - Number of tasks/parallelism

Throws:

InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially)

ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

transform

public static <T extends RealType<T>,U extends RealType<U>> void transform(RandomAccessible<T> source,
                                                                           RandomAccessibleInterval<U> target,
                                                                           Distance d)

Create distance transforms of sampled functions on source using arbitrary Distance d. Intermediate and final results will be stored in target (DoubleType recommended).

Type Parameters:: T - RealType input; U - RealType intermediate results
Parameters:: source - Input function on which distance transform should be computed.; target - Final result of distance transform.; d - Distance between two points.

transform

public static <T extends RealType<T>,U extends RealType<U>> void transform(RandomAccessible<T> source,
                                                                           RandomAccessibleInterval<U> target,
                                                                           Distance d,
                                                                           ExecutorService es,
                                                                           int nTasks)
                                                                    throws InterruptedException,
                                                                           ExecutionException

Create distance transforms of sampled functions on source using arbitrary Distance d. Intermediate and final results will be stored in target (DoubleType recommended).

Type Parameters:: T - RealType input; U - RealType intermediate results
Parameters:: source - Input function on which distance transform should be computed.; target - Final result of distance transform.; d - Distance between two points.; es - ExecutorService for parallel execution.; nTasks - Number of tasks/parallelism
Throws:: InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially); ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

transform

public static <T extends RealType<T>,U extends RealType<U>,V extends RealType<V>> void transform(RandomAccessible<T> source,
                                                                                                 RandomAccessibleInterval<U> tmp,
                                                                                                 RandomAccessibleInterval<V> target,
                                                                                                 Distance d)

Create distance transforms of sampled functions on source using arbitrary Distance d. Intermediate results will be stored in tmp (DoubleType recommended). The output will be written into target.

Type Parameters:: T - RealType input; U - RealType intermediate results; V - RealType output
Parameters:: source - Input function on which distance transform should be computed.; tmp - Storage for intermediate results.; target - Final result of distance transform.; d - Distance between two points.

transform

public static <T extends RealType<T>,U extends RealType<U>,V extends RealType<V>> void transform(RandomAccessible<T> source,
                                                                                                 RandomAccessibleInterval<U> tmp,
                                                                                                 RandomAccessibleInterval<V> target,
                                                                                                 Distance d,
                                                                                                 ExecutorService es,
                                                                                                 int nTasks)
                                                                                          throws InterruptedException,
                                                                                                 ExecutionException

Type Parameters:: T - RealType input; U - RealType intermediate results; V - RealType output
Parameters:: source - Input function on which distance transform should be computed.; tmp - Storage for intermediate results.; target - Final result of distance transform.; d - Distance between two points.; es - ExecutorService for parallel execution.; nTasks - Number of tasks/parallelism
Throws:: InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially); ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

binaryTransform
```
public static ,U extends RealType> void binaryTransform(RandomAccessible source,
 RandomAccessibleInterval target,
 DistanceTransform.DISTANCE_TYPE distanceType,
 double... weights)
```
Create binary distance transform on source using squared Euclidian (L2) or L1 distance. Intermediate results will be stored in target (DoubleType recommended). The distance can be weighted (individually for each dimension, if desired) against the image values via the weights parameter.

Type Parameters:

B - BooleanType binary mask input

U - RealType intermediate results

Parameters:

source - Input function on which distance transform should be computed.

target - Intermediate and final results of distance transform.

distanceType - Defines distance to be used: squared Euclidian or L1

weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).

binaryTransform

public static <B extends BooleanType<B>,U extends RealType<U>> void binaryTransform(RandomAccessible<B> source,
                                                                                    RandomAccessibleInterval<U> target,
                                                                                    DistanceTransform.DISTANCE_TYPE distanceType,
                                                                                    ExecutorService es,
                                                                                    int nTasks,
                                                                                    double... weights)
                                                                             throws InterruptedException,
                                                                                    ExecutionException

Create binary distance transform on source using squared Euclidian (L2) or L1 distance. Intermediate results will be stored in target (DoubleType recommended). The distance can be weighted (individually for each dimension, if desired) against the image values via the weights parameter.

Type Parameters:: B - BooleanType binary mask input; U - RealType intermediate results
Parameters:: source - Input function on which distance transform should be computed.; target - Intermediate and final results of distance transform.; distanceType - Defines distance to be used: squared Euclidian or L1; es - ExecutorService for parallel execution.; nTasks - Number of tasks/parallelism; weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).
Throws:: InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially); ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

binaryTransform

public static <B extends BooleanType<B>,U extends RealType<U>,V extends RealType<V>> void binaryTransform(RandomAccessible<B> source,
                                                                                                          RandomAccessibleInterval<U> tmp,
                                                                                                          RandomAccessibleInterval<V> target,
                                                                                                          DistanceTransform.DISTANCE_TYPE distanceType,
                                                                                                          double... weights)

Create binary distance transform on source using squared Euclidian (L2) or L1 distance. Intermediate results will be stored in tmp (DoubleType recommended). The output will be written into target. The distance can be weighted (individually for each dimension, if desired) against the image values via the weights parameter.

Type Parameters:: B - BooleanType binary mask input; U - RealType intermediate results; V - RealType output
Parameters:: source - Input function on which distance transform should be computed.; tmp - Storage for intermediate results.; target - Final result of distance transform.; distanceType - Defines distance to be used: squared Euclidian or L1; weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).

binaryTransform

public static <B extends BooleanType<B>,U extends RealType<U>,V extends RealType<V>> void binaryTransform(RandomAccessible<B> source,
                                                                                                          RandomAccessibleInterval<U> tmp,
                                                                                                          RandomAccessibleInterval<V> target,
                                                                                                          DistanceTransform.DISTANCE_TYPE distanceType,
                                                                                                          ExecutorService es,
                                                                                                          int nTasks,
                                                                                                          double... weights)
                                                                                                   throws InterruptedException,
                                                                                                          ExecutionException

Type Parameters:: B - BooleanType binary mask input; U - RealType intermediate results; V - RealType output
Parameters:: source - Input function on which distance transform should be computed.; tmp - Storage for intermediate results.; target - Final result of distance transform.; distanceType - Defines distance to be used: squared Euclidian or L1; es - ExecutorService for parallel execution.; nTasks - Number of tasks/parallelism; weights - Individual weights for each dimension, balancing image values and distance (when using squared Euclidian distance, weights should be squared, too).
Throws:: InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially); ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

binaryTransform
```
public static > void binaryTransform(RandomAccessibleInterval source,
 Distance d,
 ExecutorService es,
 int nTasks)
 throws InterruptedException,
 ExecutionException
```
Create binary distance transform on source using arbitrary Distance d. Intermediate and final results will be stored in source (DoubleType recommended).

Type Parameters:

B - BooleanType binary mask input

Parameters:

source - Input function on which distance transform should be computed.

d - Distance between two points.

es - ExecutorService for parallel execution.

nTasks - Number of tasks/parallelism

Throws:

InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially)

ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

binaryTransform

public static <B extends BooleanType<B>,U extends RealType<U>> void binaryTransform(RandomAccessible<B> source,
                                                                                    RandomAccessibleInterval<U> target,
                                                                                    Distance d)

Create binary distance transform on source using arbitrary Distance d. Intermediate and final results will be stored in target (DoubleType recommended).

Type Parameters:: B - BooleanType binary mask input; U - RealType intermediate results
Parameters:: source - Input function on which distance transform should be computed.; target - Final result of distance transform.; d - Distance between two points.

binaryTransform

public static <B extends BooleanType<B>,U extends RealType<U>> void binaryTransform(RandomAccessible<B> source,
                                                                                    RandomAccessibleInterval<U> target,
                                                                                    Distance d,
                                                                                    ExecutorService es,
                                                                                    int nTasks)
                                                                             throws InterruptedException,
                                                                                    ExecutionException

Create binary distance transform on source using arbitrary Distance d. Intermediate and final results will be stored in target (DoubleType recommended).

Type Parameters:: B - BooleanType binary mask input; U - RealType intermediate results
Parameters:: source - Input function on which distance transform should be computed.; target - Final result of distance transform.; d - Distance between two points.; es - ExecutorService for parallel execution.; nTasks - Number of tasks/parallelism
Throws:: InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially); ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

binaryTransform

public static <B extends BooleanType<B>,U extends RealType<U>,V extends RealType<V>> void binaryTransform(RandomAccessible<B> source,
                                                                                                          RandomAccessibleInterval<U> tmp,
                                                                                                          RandomAccessibleInterval<V> target,
                                                                                                          Distance d)

Create binary distance transform on source using arbitrary Distance d. Intermediate results will be stored in tmp (DoubleType recommended). The output will be written into target.

Type Parameters:: B - BooleanType binary mask input; U - RealType intermediate results; V - RealType output
Parameters:: source - Input function on which distance transform should be computed.; tmp - Storage for intermediate results.; target - Final result of distance transform.; d - Distance between two points.

binaryTransform

public static <B extends BooleanType<B>,U extends RealType<U>,V extends RealType<V>> void binaryTransform(RandomAccessible<B> source,
                                                                                                          RandomAccessibleInterval<U> tmp,
                                                                                                          RandomAccessibleInterval<V> target,
                                                                                                          Distance d,
                                                                                                          ExecutorService es,
                                                                                                          int nTasks)
                                                                                                   throws InterruptedException,
                                                                                                          ExecutionException

Create binary distance transform on source using arbitrary Distance d. Intermediate results will be stored in tmp (DoubleType recommended). The output will be written into target.

Type Parameters:: B - BooleanType binary mask input; U - RealType intermediate results; V - RealType output
Parameters:: source - Input function on which distance transform should be computed.; tmp - Storage for intermediate results.; target - Final result of distance transform.; d - Distance between two points.; es - ExecutorService for parallel execution.; nTasks - Number of tasks/parallelism
Throws:: InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled (distance transform may be computed only partially); ExecutionException - if the computation threw an exception (distance transform may be computed only partially)

getLargestDimension
```
public static int getLargestDimension(Interval interval)
```
Convenience method to find largest dimension of Interval interval.

Parameters:

interval - input

Returns:

Return the largest dimension of interval (not the size of that dimension).

Class DistanceTransform

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DistanceTransform

Method Detail

transform

transform

transform

transform

transform

transform

transform

transform

transform

transform

transform

transform

binaryTransform

binaryTransform

binaryTransform

binaryTransform

binaryTransform

binaryTransform

binaryTransform

binaryTransform

binaryTransform

getLargestDimension