Compute (ImgLib2 Javadocs 0-SNAPSHOT API)

java.lang.Object
- net.imglib2.algorithm.math.Compute

```
public class Compute
extends Object
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Compute.Parameters

Nested Classes
Modifier and Type	Class and Description
`static class`	`Compute.Parameters`

Constructor Summary

Constructors
Constructor and Description

Compute(IFunction operation)
Validate the {code operation}.

Constructors
Constructor and Description
`Compute(IFunction operation)` Validate the {code operation}.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<O extends RealType<O>> Cursor<O>`	`cursor()` Returns a `Cursor` with the same type as the first input image found.
`<C extends RealType<C>,O extends RealType<O>> Cursor<O>`	`cursor(C computeType, O outputType)`
`<C extends RealType<C>,O extends RealType<O>> Cursor<O>`	`cursor(Converter<RealType<?>,C> inConverter, C computeType, O outputType, Converter<C,O> outConverter)`
`<O extends RealType<O>> Cursor<O>`	`cursor(O outputType)`
`<O extends RealType<O>> Cursor<O>`	`cursorDouble()` Returns a `Cursor` with the same type as the first input image found.
`<O extends RealType<O>> Cursor<O>`	`cursorDouble(O outputType)`
`<O extends RealType<O>> Cursor<O>`	`cursorDouble(O outputType, Converter<RealType<?>,O> converter)`
`<O extends RealType<O>> RandomAccessibleInterval<O>`	`into(RandomAccessibleInterval<O> target)` Execute the computation and store the result into the `target`.
`<O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`into(RandomAccessibleInterval<O> target, C computingType)`
`<O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`into(RandomAccessibleInterval<O> target, Converter<RealType<?>,C> inConverter, C computingType, Converter<C,O> outConverter)`
`<O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`into(RandomAccessibleInterval<O> target, Converter<RealType<?>,C> inConverter, C computingType, Converter<C,O> outConverter, boolean printHierarchy)` Execute the mathematical operations and store the result into the given `RandomAccessibleInterval`.
`<O extends RealType<O>> RandomAccessibleInterval<O>`	`into(RandomAccessibleInterval<O> target, Converter<RealType<?>,O> inConverter)` Execute the mathematical operations and store the result into the given `RandomAccessibleInterval`.
`<O extends RealType<O> & NativeType<O>> ArrayImg<O,?>`	`intoArrayImg()`
`<O extends RealType<O> & NativeType<O>,C extends RealType<C> & NativeType<C>> ArrayImg<O,?>`	`intoArrayImg(C computeType, O outputType)`
`<O extends RealType<O> & NativeType<O>,C extends RealType<C>> ArrayImg<O,?>`	`intoArrayImg(O outputType)`
`<O extends RealType<O> & NativeType<O>> RandomAccessibleInterval<O>`	`intoImg()` Execute the computation and store the result into a newly created `Img` of the same `Type` (and kind, by `ImgFactory`) as one of the input images, using as the computation `Type` the type of that picked input image.
`<O extends RealType<O> & NativeType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`intoImg(C computeType, O outputType)` Execute the computation and store the result into a newly created `Img` of the same kind, by `ImgFactory`, as one of the input images, but of type `outputType`, while using `computeType` for math operations, converting to the `outputType` to store the result.
`<O extends RealType<O> & NativeType<O>> RandomAccessibleInterval<O>`	`intoImg(O outputType)` Execute the computation and store the result into a newly created `Img` of the same kind, by `ImgFactory`, as one of the input images, but of type `outputType`, which is also used as the computation `Type`.
`<O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`parallelInto(Converter<RealType<?>,C> inConverter, C computeType, O outputType, Converter<C,O> outConverter, RandomAccessibleInterval<O> target)` Compute the result multithreaded into an `ArrayImg` of the given `Type`.
`<O extends RealType<O>> RandomAccessibleInterval<O>`	`parallelInto(RandomAccessibleInterval<O> target)` Compute the result multithreaded into an `ArrayImg` of the given `Type`.
`<O extends RealType<O> & NativeType<O>> RandomAccessibleInterval<O>`	`parallelIntoArrayImg()` Compute the result multithreaded into an `ArrayImg` of the same `Type` as the first image found, with mathematical operations using that same `Type`.
`<O extends RealType<O> & NativeType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`parallelIntoArrayImg(C computeType, O outputType)` Compute the result multithreaded into an `ArrayImg` of the given `Type`.
`<O extends RealType<O> & NativeType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`parallelIntoArrayImg(Converter<RealType<?>,C> inConverter, C computeType, O outputType, Converter<C,O> outConverter)` Compute the result multithreaded into an `ArrayImg` of the given `Type`.
`<O extends RealType<O> & NativeType<O>> RandomAccessibleInterval<O>`	`parallelIntoArrayImg(O outputType)` Compute the result multithreaded into an `ArrayImg` of the given `Type`.
`<O extends RealType<O>> RandomAccess<O>`	`randomAccess()` Returns a `RandomAccess` with the same type as the first input image found.
`<C extends RealType<C>,O extends RealType<O>> RandomAccess<O>`	`randomAccess(C computeType, O outputType, Converter<C,O> outConverter)`
`<C extends RealType<C>,O extends RealType<O>> RandomAccess<O>`	`randomAccess(Converter<RealType<?>,C> inConverter, C computeType, O outputType, Converter<C,O> outConverter)`
`<O extends RealType<O>> RandomAccess<O>`	`randomAccess(O outputType)`
`<O extends RealType<O>> RandomAccess<O>`	`randomAccessDouble()` Returns a `RandomAccess` with the same type as the first input image found.
`<O extends RealType<O>> RandomAccess<O>`	`randomAccessDouble(O outputType)`
`<O extends RealType<O>> RandomAccess<O>`	`randomAccessDouble(O outputType, Converter<RealType<?>,O> converter)`
`static Compute.Parameters`	`validate(IFunction f)`
`<O extends RealType<O>> RandomAccessibleInterval<O>`	`view()`
`<O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`view(C computingType, O outputType)` View the result of the computations as a `RandomAccessibleInterval`, i.e.
`<O extends RealType<O>> RandomAccessibleInterval<O>`	`view(Interval interval)`
`<O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O>`	`view(Interval interval, Converter<RealType<?>,C> inConverter, C computingType, O outputType, Converter<C,O> outConverter)`
`<O extends RealType<O>> RandomAccessibleInterval<O>`	`view(Interval interval, O outputType)`
`<O extends RealType<O>> RandomAccessibleInterval<O>`	`view(O outputType)`

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

Constructor Detail
- Compute
```
public Compute(IFunction operation)
```
  Validate the {code operation}.
  
  Parameters:
  
  operation -

Method Detail

intoArrayImg

public <O extends RealType<O> & NativeType<O>> ArrayImg<O,?> intoArrayImg()

intoArrayImg

public <O extends RealType<O> & NativeType<O>,C extends RealType<C> & NativeType<C>> ArrayImg<O,?> intoArrayImg(C computeType,
                                                                                                                O outputType)

intoArrayImg

public <O extends RealType<O> & NativeType<O>,C extends RealType<C>> ArrayImg<O,?> intoArrayImg(O outputType)

intoImg
```
public <O extends RealType<O> & NativeType<O>> RandomAccessibleInterval<O> intoImg()
```
Execute the computation and store the result into a newly created Img of the same Type (and kind, by ImgFactory) as one of the input images, using as the computation Type the type of that picked input image. This approach is appropriate when e.g. all input images are of the same type, and operations aren't expected to overflow the Type or it doesn't matter whether they do.

Returns:

A newly created Img with the result of the computation.

intoImg
```
public <O extends RealType<O> & NativeType<O>> RandomAccessibleInterval<O> intoImg(O outputType)
```
Execute the computation and store the result into a newly created Img of the same kind, by ImgFactory, as one of the input images, but of type outputType, which is also used as the computation Type.

Parameters:

outputType - The Type of the returned Img and used for computing.

Returns:

A newly created Img with the result of the computation.

intoImg
```
public <O extends RealType<O> & NativeType<O>,C extends RealType<C>> RandomAccessibleInterval<O> intoImg(C computeType,
                                                                                                         O outputType)
```
Execute the computation and store the result into a newly created Img of the same kind, by ImgFactory, as one of the input images, but of type outputType, while using computeType for math operations, converting to the outputType to store the result.

Parameters:

computeType - The Type used to perform mathematical operations.

outputType - The Type of the returned Img.

Returns:

A newly created Img with the result of the computation.

into
```
public <O extends RealType<O>> RandomAccessibleInterval<O> into(RandomAccessibleInterval<O> target)
```
Execute the computation and store the result into the target. The computation is done using Type-based math, with the Type of the target defining the specific math implementation and numerical precision that will be used.

Parameters:

target - The RandomAccessibleInterval into which to store the computation; note its Type determines the precision of the computation and the specific implementation of the mathematical operations.

Returns:

The target.

into
```
public <O extends RealType<O>> RandomAccessibleInterval<O> into(RandomAccessibleInterval<O> target,
                                                                Converter<RealType<?>,O> inConverter)
```
Execute the mathematical operations and store the result into the given RandomAccessibleInterval.

Parameters:

target - The RandomAccessibleInterval into which to store the computation; note its Type determines the precision of the computation and the specific implementation of the mathematical operations.

inConverter - The Converter that transfers all input Type to the Type of the target; when null, will create one that uses double floating-point precision; but note that if the Type of an input RandomAccessibleInterval is the same as that of the target, the converter will not be used.

Returns:

The target.

into

public <O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O> into(RandomAccessibleInterval<O> target,
                                                                                      C computingType)

into

public <O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O> into(RandomAccessibleInterval<O> target,
                                                                                      Converter<RealType<?>,C> inConverter,
                                                                                      C computingType,
                                                                                      Converter<C,O> outConverter)

into
```
public <O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O> into(RandomAccessibleInterval<O> target,
                                                                                      Converter<RealType<?>,C> inConverter,
                                                                                      C computingType,
                                                                                      Converter<C,O> outConverter,
                                                                                      boolean printHierarchy)
```
Execute the mathematical operations and store the result into the given RandomAccessibleInterval. Takes into account whether all images involved in the computation are iterable in a compatible way.

Parameters:

target - The RandomAccessibleInterval into which to store the computation.

inConverter - The Converter that transfers all input Type to the Type of the target; when null, will create one that uses double floating-point precision; but note that if the Type of an input RandomAccessibleInterval is the same as that of the target, the converter will not be used.

computingType - The Type that determines the precision of the computation and the specific implementation of the mathematical operations.

outConverter - The Converter that transfers the computingType to the Type of the target; will not be used if the computeType is the same as the Type of the output; when null, a new one is created, which is the identity when the computingType equal the Type of the target, and a generic RealType converter that uses floating-point values (with RealType#setReal(double)) created with Util#genericRealTypeConverter() is used.

printHierarchy - Emits to stdout the hierarchy of OFunction types.

Returns:

The target.

view

public <O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O> view(Interval interval,
                                                                                      Converter<RealType<?>,C> inConverter,
                                                                                      C computingType,
                                                                                      O outputType,
                                                                                      Converter<C,O> outConverter)

view
```
public <O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O> view(C computingType,
                                                                                      O outputType)
```
View the result of the computations as a RandomAccessibleInterval, i.e. there is no target image, instead any pixel can be viewed as the result of the computation applied to it, dynamically. Conversion between the input and computing type is done with an appropriate converter or none when types are the same. See also ViewableFunction and methods below related to Compute#randomAccess() and Compute#cursor(). The key difference is that, here, the computing and the output type can be different.

Parameters:

computingType - The Type that defines the math to use.

outputType - The @{code Type} of the constructed and returned RandomAccessibleInterval. return A RandomAccessibleInterval view of the result of the computations.

view

public <O extends RealType<O>> RandomAccessibleInterval<O> view(O outputType)

view

public <O extends RealType<O>> RandomAccessibleInterval<O> view()

view

public <O extends RealType<O>> RandomAccessibleInterval<O> view(Interval interval)

view

public <O extends RealType<O>> RandomAccessibleInterval<O> view(Interval interval,
                                                                O outputType)

parallelIntoArrayImg
```
public <O extends RealType<O> & NativeType<O>> RandomAccessibleInterval<O> parallelIntoArrayImg()
```
Compute the result multithreaded into an ArrayImg of the same Type as the first image found, with mathematical operations using that same Type.

parallelIntoArrayImg
```
public <O extends RealType<O> & NativeType<O>> RandomAccessibleInterval<O> parallelIntoArrayImg(O outputType)
```
Compute the result multithreaded into an ArrayImg of the given Type.

Parameters:

outputType - The Type used for both computations and the output image.

parallelIntoArrayImg
```
public <O extends RealType<O> & NativeType<O>,C extends RealType<C>> RandomAccessibleInterval<O> parallelIntoArrayImg(C computeType,
                                                                                                                      O outputType)
```
Compute the result multithreaded into an ArrayImg of the given Type. Uses generic RealType converters where appropriate as provided by Util#genericRealTypeConverter().

Parameters:

computeType - The Type used for computations.

outputType - The Type used for the output image.

parallelIntoArrayImg

public <O extends RealType<O> & NativeType<O>,C extends RealType<C>> RandomAccessibleInterval<O> parallelIntoArrayImg(Converter<RealType<?>,C> inConverter,
                                                                                                                      C computeType,
                                                                                                                      O outputType,
                                                                                                                      Converter<C,O> outConverter)

Compute the result multithreaded into an ArrayImg of the given Type.

Parameters:: inConverter - From input to computeType, or when null, uses Util#genericRealTypeConverter().; computeType - The Type used for computations.; outputType - The Type used for the output image.; outConverter - From computeType to outputType, or when null, uses Util#genericRealTypeConverter().

parallelInto
```
public <O extends RealType<O>> RandomAccessibleInterval<O> parallelInto(RandomAccessibleInterval<O> target)
```
Compute the result multithreaded into an ArrayImg of the given Type. Uses generic RealType converters where appropriate as provided by Util#genericRealTypeConverter().

Parameters:

target - To store the result of the computation, with its Type defining both the output Type and the Type used for computations.

parallelInto

public <O extends RealType<O>,C extends RealType<C>> RandomAccessibleInterval<O> parallelInto(Converter<RealType<?>,C> inConverter,
                                                                                              C computeType,
                                                                                              O outputType,
                                                                                              Converter<C,O> outConverter,
                                                                                              RandomAccessibleInterval<O> target)

Compute the result multithreaded into an ArrayImg of the given Type.

Parameters:: inConverter - From input to computeType, or when null, uses Util#genericRealTypeConverter().; computeType - The Type used for computations.; outputType - The Type used for the output image.; outConverter - From computeType to outputType, or when null, uses Util#genericRealTypeConverter().

validate

public static Compute.Parameters validate(IFunction f)

randomAccess

public <C extends RealType<C>,O extends RealType<O>> RandomAccess<O> randomAccess(Converter<RealType<?>,C> inConverter,
                                                                                  C computeType,
                                                                                  O outputType,
                                                                                  Converter<C,O> outConverter)

randomAccess

public <C extends RealType<C>,O extends RealType<O>> RandomAccess<O> randomAccess(C computeType,
                                                                                  O outputType,
                                                                                  Converter<C,O> outConverter)

randomAccess

public <O extends RealType<O>> RandomAccess<O> randomAccess(O outputType)

randomAccess
```
public <O extends RealType<O>> RandomAccess<O> randomAccess()
```
Returns a RandomAccess with the same type as the first input image found.

cursor

public <C extends RealType<C>,O extends RealType<O>> Cursor<O> cursor(Converter<RealType<?>,C> inConverter,
                                                                      C computeType,
                                                                      O outputType,
                                                                      Converter<C,O> outConverter)

cursor

public <C extends RealType<C>,O extends RealType<O>> Cursor<O> cursor(C computeType,
                                                                      O outputType)

cursor

public <O extends RealType<O>> Cursor<O> cursor(O outputType)

cursor
```
public <O extends RealType<O>> Cursor<O> cursor()
```
Returns a Cursor with the same type as the first input image found.

randomAccessDouble

public <O extends RealType<O>> RandomAccess<O> randomAccessDouble(O outputType,
                                                                  Converter<RealType<?>,O> converter)

randomAccessDouble

public <O extends RealType<O>> RandomAccess<O> randomAccessDouble(O outputType)

randomAccessDouble
```
public <O extends RealType<O>> RandomAccess<O> randomAccessDouble()
```
Returns a RandomAccess with the same type as the first input image found.

cursorDouble

public <O extends RealType<O>> Cursor<O> cursorDouble(O outputType,
                                                      Converter<RealType<?>,O> converter)

cursorDouble

public <O extends RealType<O>> Cursor<O> cursorDouble(O outputType)

cursorDouble
```
public <O extends RealType<O>> Cursor<O> cursorDouble()
```
Returns a Cursor with the same type as the first input image found.

Class Compute

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Compute

Method Detail

intoArrayImg

intoArrayImg

intoArrayImg

intoImg

intoImg

intoImg

into

into

into

into

into

view

view

view

view

view

view

parallelIntoArrayImg

parallelIntoArrayImg

parallelIntoArrayImg

parallelIntoArrayImg

parallelInto

parallelInto

validate

randomAccess

randomAccess

randomAccess

randomAccess

cursor

cursor

cursor

cursor

randomAccessDouble

randomAccessDouble

randomAccessDouble

cursorDouble

cursorDouble

cursorDouble