Converters (ImgLib2 Javadocs 0-SNAPSHOT API)

java.lang.Object
- net.imglib2.converter.Converters

```
public class Converters
extends Object
```
Convenience factory methods for sample conversion.

Author:

Stephan Saalfeld, Tobias Pietzsch

Constructor Summary

Constructors
Constructor and Description

Converters()

Constructors
Constructor and Description
`Converters()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static WriteConvertedRandomAccessible<ARGBType,UnsignedByteType>`	`argbChannel(RandomAccessible<ARGBType> source, int channel)` Create a `WriteConvertedRandomAccessible` to one of the four channels encoded in a `RandomAccessible` of `ARGBType`.
`static WriteConvertedRandomAccessibleInterval<ARGBType,UnsignedByteType>`	`argbChannel(RandomAccessibleInterval<ARGBType> source, int channel)` Create a `WriteConvertedRandomAccessibleInterval` to one of the four channels encoded in a `RandomAccessibleInterval` of `ARGBType`.
`static RandomAccessibleInterval<UnsignedByteType>`	`argbChannels(RandomAccessibleInterval<ARGBType> source)` Create an (n+1)-dimensional `RandomAccessible` of an n-dimensional `RandomAccessible` that maps the four channels encoded in `ARGBType` into a dimension.
`static RandomAccessibleInterval<UnsignedByteType>`	`argbChannels(RandomAccessibleInterval<ARGBType> source, int... channels)` Create an (n+1)-dimensional `RandomAccessible` of an n-dimensional `RandomAccessible` that maps the four channels encoded in `ARGBType` into a dimension.
`static <A,B extends Type<B>> RandomAccessibleInterval<B>`	`compose(List<RandomAccessibleInterval<A>> components, Converter<Composite<A>,B> composer, B targetType)` Compose a list of same `Interval` and same `Type` A `RandomAccessibleIntervals` into a `RandomAccessibleInterval` of some target `Type` B using a `Converter` from `Composite` of A to B.
`static <A,B extends Type<B>> RandomAccessibleInterval<B>`	`compose(List<RandomAccessibleInterval<A>> components, Converter<Composite<A>,B> composer, Supplier<B> targetTypeSupplier)` Compose a list of same `Interval` and same `Type` A `RandomAccessibleIntervals` into a `RandomAccessibleInterval` of some target `Type` B using a `Converter` from `Composite` of A to B.
`static <A extends NumericType<A>,B extends Type<B>> RandomAccessibleInterval<B>`	`composeNumeric(List<RandomAccessibleInterval<A>> components, Converter<NumericComposite<A>,B> composer, B targetType)` Compose a list of same `Interval` and same `NumericType` A `RandomAccessibleIntervals` into a `RandomAccessibleInterval` of some target `Type` B using a `Converter` from `Composite` of A to B.
`static <A extends NumericType<A>,B extends Type<B>> RandomAccessibleInterval<B>`	`composeNumeric(List<RandomAccessibleInterval<A>> components, Converter<NumericComposite<A>,B> composer, Supplier<B> targetTypeSupplier)` Compose a list of same `Interval` and same `NumericType` A `RandomAccessibleIntervals` into a `RandomAccessibleInterval` of some target `Type` B using a `Converter` from `Composite` of A to B.
`static <A extends RealType<A>,B extends Type<B>> RandomAccessibleInterval<B>`	`composeReal(List<RandomAccessibleInterval<A>> components, Converter<RealComposite<A>,B> composer, B targetType)` Compose a list of same `Interval` and same `RealType` A `RandomAccessibleIntervals` into a `RandomAccessibleInterval` of some target `Type` B using a `Converter` from `Composite` of A to B.
`static <A extends RealType<A>,B extends Type<B>> RandomAccessibleInterval<B>`	`composeReal(List<RandomAccessibleInterval<A>> components, Converter<RealComposite<A>,B> composer, Supplier<B> targetTypeSupplier)` Compose a list of same `Interval` and same `RealType` A `RandomAccessibleIntervals` into a `RandomAccessibleInterval` of some target `Type` B using a `Converter` from `Composite` of A to B.
`static <A,B extends Type<B>> IterableInterval<B>`	`convert(IterableInterval<A> source, Converter<? super A,? super B> converter, B b)` Create a `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> IterableInterval<C>`	`convert(IterableInterval<A> sourceA, IterableInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, C c)` Create a `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> IterableInterval<C>`	`convert(IterableInterval<A> sourceA, IterableInterval<B> sourceB, Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, C c)` Create a `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedIterableInterval<A,B>`	`convert(IterableInterval<A> source, SamplerConverter<? super A,B> converter)` Create an `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> IterableInterval<B>`	`convert(IterableInterval<A> source, Supplier<Converter<? super A,? super B>> converterSupplier, B b)` Create a `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedIterableInterval<A,B>`	`convert(IterableInterval<A> source, Supplier<SamplerConverter<? super A,B>> converterSupplier)` Create an `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> IterableRealInterval<B>`	`convert(IterableRealInterval<A> source, Converter<? super A,? super B> converter, B b)` Create a `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> IterableRealInterval<C>`	`convert(IterableRealInterval<A> sourceA, IterableRealInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, C c)` Create an `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> IterableRealInterval<C>`	`convert(IterableRealInterval<A> sourceA, IterableRealInterval<B> sourceB, Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, C c)` Create a `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedIterableRealInterval<A,B>`	`convert(IterableRealInterval<A> source, SamplerConverter<? super A,B> converter)` Create an `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> IterableRealInterval<B>`	`convert(IterableRealInterval<A> source, Supplier<Converter<? super A,? super B>> converterSupplier, B b)` Create a `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RandomAccessible<B>`	`convert(RandomAccessible<A> source, Converter<? super A,? super B> converter, B b)` Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RandomAccessible<C>`	`convert(RandomAccessible<A> sourceA, RandomAccessible<B> sourceB, BiConverter<? super A,? super B,? super C> converter, C c)` Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RandomAccessible<C>`	`convert(RandomAccessible<A> sourceA, RandomAccessible<B> sourceB, Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, C c)` Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedRandomAccessible<A,B>`	`convert(RandomAccessible<A> source, SamplerConverter<? super A,B> converter)` Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RandomAccessible<B>`	`convert(RandomAccessible<A> source, Supplier<Converter<? super A,? super B>> converterSupplier, B b)` Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedRandomAccessible<A,B>`	`convert(RandomAccessible<A> source, Supplier<SamplerConverter<? super A,B>> converterSupplier)` Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RandomAccessibleInterval<B>`	`convert(RandomAccessibleInterval<A> source, Converter<? super A,? super B> converter, B b)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RandomAccessibleInterval<C>`	`convert(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, C c)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RandomAccessibleInterval<C>`	`convert(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, C c)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedRandomAccessibleInterval<A,B>`	`convert(RandomAccessibleInterval<A> source, SamplerConverter<? super A,B> converter)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RandomAccessibleInterval<B>`	`convert(RandomAccessibleInterval<A> source, Supplier<Converter<? super A,? super B>> converterSupplier, B b)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedRandomAccessibleInterval<A,B>`	`convert(RandomAccessibleInterval<A> source, Supplier<SamplerConverter<? super A,B>> converterSupplier)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RealRandomAccessible<B>`	`convert(RealRandomAccessible<A> source, Converter<? super A,? super B> converter, B b)` Create a `RealRandomAccessible` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RealRandomAccessible<C>`	`convert(RealRandomAccessible<A> sourceA, RealRandomAccessible<B> sourceB, BiConverter<? super A,? super B,? super C> converter, C c)` Create a `RealRandomAccessible` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RealRandomAccessible<C>`	`convert(RealRandomAccessible<A> sourceA, RealRandomAccessible<B> sourceB, Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, C c)` Create a `RealRandomAccessible` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RealRandomAccessible<B>`	`convert(RealRandomAccessible<A> source, Supplier<Converter<? super A,? super B>> converterSupplier, B b)` Create a `RealRandomAccessible` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RealRandomAccessibleRealInterval<B>`	`convert(RealRandomAccessibleRealInterval<A> source, Converter<? super A,? super B> converter, B b)` Create a `RealRandomAccessibleRealInterval` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RealRandomAccessibleRealInterval<C>`	`convert(RealRandomAccessibleRealInterval<A> sourceA, RealRandomAccessibleRealInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, C c)` Create a `RealRandomAccessibleRealInterval` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RealRandomAccessibleRealInterval<C>`	`convert(RealRandomAccessibleRealInterval<A> sourceA, RealRandomAccessibleRealInterval<B> sourceB, Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, C c)` Create a `RealRandomAccessibleRealInterval` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RealRandomAccessibleRealInterval<B>`	`convert(RealRandomAccessibleRealInterval<A> source, Supplier<Converter<? super A,? super B>> converterSupplier, B b)` Create a `RealRandomAccessibleRealInterval` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RandomAccessibleInterval<B>`	`convertRAI(RandomAccessibleInterval<A> source, Converter<? super A,? super B> converter, B b)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RandomAccessibleInterval<C>`	`convertRAI(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, C c)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C extends Type<C>> RandomAccessibleInterval<C>`	`convertRAI(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, C c)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedRandomAccessibleInterval<A,B>`	`convertRAI(RandomAccessibleInterval<A> source, SamplerConverter<? super A,B> converter)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RandomAccessibleInterval<B>`	`convertRAI(RandomAccessibleInterval<A> source, Supplier<Converter<? super A,? super B>> converterSupplier, B b)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> WriteConvertedRandomAccessibleInterval<A,B>`	`convertRAI(RandomAccessibleInterval<A> source, Supplier<SamplerConverter<? super A,B>> converterSupplier)` Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>,S extends RandomAccessible<A> & IterableInterval<A>> WriteConvertedIterableRandomAccessibleInterval<A,B,S>`	`convertRandomAccessibleIterableInterval(S source, SamplerConverter<? super A,B> converter)` Create an `WriteConvertedIterableRandomAccessibleInterval` whose `RandomAccesses` and `Cursors` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>,S extends RandomAccessible<A> & IterableInterval<A>> WriteConvertedIterableRandomAccessibleInterval<A,B,S>`	`convertRandomAccessibleIterableInterval(S source, Supplier<SamplerConverter<? super A,B>> converterSupplier)` Create an `WriteConvertedIterableRandomAccessibleInterval` whose `RandomAccesses` and `Cursors` `Sampler.get()` you a converted sample.
`static RandomAccessible<ARGBType>`	`mergeARGB(RandomAccessible<UnsignedByteType> source, ColorChannelOrder channelOrder)` Create an n-dimensional color image from an (n+1)-dimensional image of `UnsignedByteType`.
`static RandomAccessibleInterval<ARGBType>`	`mergeARGB(RandomAccessibleInterval<UnsignedByteType> source, ColorChannelOrder channelOrder)` Create an n-dimensional color image from an (n+1)-dimensional image of `UnsignedByteType`.

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

Constructor Detail
- Converters
```
public Converters()
```

Method Detail

convert

public static final <A,B extends Type<B>> RandomAccessible<B> convert(RandomAccessible<A> source,
                                                                      Converter<? super A,? super B> converter,
                                                                      B b)

Create a RandomAccessible whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted RandomAccessibleInterval has no effect.

Parameters:: source -; converter -; b -
Returns:: a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> RandomAccessible<B> convert(RandomAccessible<A> source,
                                                                      Supplier<Converter<? super A,? super B>> converterSupplier,
                                                                      B b)

Parameters:: source -; converterSupplier -; b -
Returns:: a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> WriteConvertedRandomAccessible<A,B> convert(RandomAccessible<A> source,
                                                                                      SamplerConverter<? super A,B> converter)

Create a RandomAccessible whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values.

Parameters:: source -; converter -
Returns:: a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> WriteConvertedRandomAccessible<A,B> convert(RandomAccessible<A> source,
                                                                                      Supplier<SamplerConverter<? super A,B>> converterSupplier)

Create a RandomAccessible whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values.

Parameters:: source -; converterSupplier -
Returns:: a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> RandomAccessibleInterval<B> convert(RandomAccessibleInterval<A> source,
                                                                              Converter<? super A,? super B> converter,
                                                                              B b)

Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted RandomAccessibleInterval has no effect.

Parameters:: source -; converter -; b -
Returns:: a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> RandomAccessibleInterval<B> convert(RandomAccessibleInterval<A> source,
                                                                              Supplier<Converter<? super A,? super B>> converterSupplier,
                                                                              B b)

Parameters:: source -; converterSupplier -; b -
Returns:: a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convertRAI
```
public static final <A,B extends Type> RandomAccessibleInterval convertRAI(RandomAccessibleInterval<A> source,
 Converter<? super A,? super B> converter,
 B b)
```
Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted RandomAccessibleInterval has no effect. Delegates to convert(RandomAccessibleInterval, Converter, Type). The different method name avoids situations where the compiler or a scripting language interpreter picks the undesired method for an object that implements both RandomAccessibleInterval and IterableInterval.

Parameters:

source -

converter -

b -

Returns:

a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convertRAI
```
public static final <A,B extends Type> RandomAccessibleInterval convertRAI(RandomAccessibleInterval<A> source,
 Supplier<Converter<? super A,? super B>> converterSupplier,
 B b)
```
Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted RandomAccessibleInterval has no effect. Delegates to convert(RandomAccessibleInterval, Converter, Type). The different method name avoids situations where the compiler or a scripting language interpreter picks the undesired method for an object that implements both RandomAccessibleInterval and IterableInterval.

Parameters:

source -

converterSupplier -

b -

Returns:

a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> WriteConvertedRandomAccessibleInterval<A,B> convert(RandomAccessibleInterval<A> source,
                                                                                              SamplerConverter<? super A,B> converter)

Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values.

Parameters:: source -; converter -
Returns:: a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> WriteConvertedRandomAccessibleInterval<A,B> convert(RandomAccessibleInterval<A> source,
                                                                                              Supplier<SamplerConverter<? super A,B>> converterSupplier)

Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values.

Parameters:: source -; converterSupplier -
Returns:: a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convertRAI
```
public static final <A,B extends Type> WriteConvertedRandomAccessibleInterval<A,B> convertRAI(RandomAccessibleInterval<A> source,
 SamplerConverter<? super A,B> converter)
```
Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values. Delegates to convert(RandomAccessibleInterval, SamplerConverter). The different name avoids situations where the compiler or a scripting language interpreter picks the undesired method for an object that implements both RandomAccessibleInterval and IterableInterval.

Parameters:

source -

converter -

Returns:

a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> IterableRealInterval<B> convert(IterableRealInterval<A> source,
                                                                          Converter<? super A,? super B> converter,
                                                                          B b)

Create a IterableRealInterval whose RealCursors Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted IterableRealInterval has no effect.

Parameters:: source -; converter -; b -
Returns:: a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> IterableRealInterval<B> convert(IterableRealInterval<A> source,
                                                                          Supplier<Converter<? super A,? super B>> converterSupplier,
                                                                          B b)

Parameters:: source -; converterSupplier -; b -
Returns:: a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.

convertRAI
```
public static final <A,B extends Type> WriteConvertedRandomAccessibleInterval<A,B> convertRAI(RandomAccessibleInterval<A> source,
 Supplier<SamplerConverter<? super A,B>> converterSupplier)
```
Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values. Delegates to convert(RandomAccessibleInterval, SamplerConverter). The different name avoids situations where the compiler or a scripting language interpreter picks the undesired method for an object that implements both RandomAccessibleInterval and IterableInterval.

Parameters:

source -

converterSupplier -

Returns:

a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> IterableInterval<B> convert(IterableInterval<A> source,
                                                                      Converter<? super A,? super B> converter,
                                                                      B b)

Create a IterableInterval whose Cursors Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted IterableInterval has no effect.

Parameters:: source -; converter -; b -
Returns:: a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> IterableInterval<B> convert(IterableInterval<A> source,
                                                                      Supplier<Converter<? super A,? super B>> converterSupplier,
                                                                      B b)

Create a IterableInterval whose Cursors Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted IterableInterval has no effect.

Parameters:: source -; converterSupplier -; b -
Returns:: a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> WriteConvertedIterableInterval<A,B> convert(IterableInterval<A> source,
                                                                                      SamplerConverter<? super A,B> converter)

Create an IterableInterval whose Cursors Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values.

Parameters:: source -; converter -
Returns:: a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> WriteConvertedIterableRealInterval<A,B> convert(IterableRealInterval<A> source,
                                                                                          SamplerConverter<? super A,B> converter)

Create an IterableRealInterval whose RealCursors Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values.

Parameters:: source -; converter -
Returns:: a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> WriteConvertedIterableInterval<A,B> convert(IterableInterval<A> source,
                                                                                      Supplier<SamplerConverter<? super A,B>> converterSupplier)

Create an IterableInterval whose Cursors Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values.

Parameters:: source -; converterSupplier -
Returns:: a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.

convertRandomAccessibleIterableInterval

public static final <A,B extends Type<B>,S extends RandomAccessible<A> & IterableInterval<A>> WriteConvertedIterableRandomAccessibleInterval<A,B,S> convertRandomAccessibleIterableInterval(S source,
                                                                                                                                                                                            SamplerConverter<? super A,B> converter)

Create an WriteConvertedIterableRandomAccessibleInterval whose RandomAccesses and Cursors Sampler.get() you a converted sample. Conversion is done on-the-fly both when reading and writing values.

Parameters:: source -; converter -
Returns:: a WriteConvertedIterableRandomAccessibleInterval whose Samplers perform on-the-fly value conversion using the provided converter.

convertRandomAccessibleIterableInterval

public static final <A,B extends Type<B>,S extends RandomAccessible<A> & IterableInterval<A>> WriteConvertedIterableRandomAccessibleInterval<A,B,S> convertRandomAccessibleIterableInterval(S source,
                                                                                                                                                                                            Supplier<SamplerConverter<? super A,B>> converterSupplier)

Parameters:: source -; converterSupplier -
Returns:: a WriteConvertedIterableRandomAccessibleInterval whose Samplers perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> RealRandomAccessibleRealInterval<B> convert(RealRandomAccessibleRealInterval<A> source,
                                                                                      Converter<? super A,? super B> converter,
                                                                                      B b)

Create a RealRandomAccessibleRealInterval whose RealRandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted RealRandomAccessibleRealInterval has no effect.

Parameters:: source -; converter -; b -
Returns:: a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> RealRandomAccessibleRealInterval<B> convert(RealRandomAccessibleRealInterval<A> source,
                                                                                      Supplier<Converter<? super A,? super B>> converterSupplier,
                                                                                      B b)

Parameters:: source -; converterSupplier -; b -
Returns:: a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> RealRandomAccessible<B> convert(RealRandomAccessible<A> source,
                                                                          Converter<? super A,? super B> converter,
                                                                          B b)

Create a RealRandomAccessible whose RealRandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted RandomAccessibleInterval has no effect.

Parameters:: source -; converter -; b -
Returns:: a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B extends Type<B>> RealRandomAccessible<B> convert(RealRandomAccessible<A> source,
                                                                          Supplier<Converter<? super A,? super B>> converterSupplier,
                                                                          B b)

Parameters:: source -; converterSupplier -; b -
Returns:: a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.

argbChannel
```
public static final WriteConvertedRandomAccessibleInterval<ARGBType,UnsignedByteType> argbChannel(RandomAccessibleInterval<ARGBType> source,
 int channel)
```
Create a WriteConvertedRandomAccessibleInterval to one of the four channels encoded in a RandomAccessibleInterval of ARGBType. The source is being modified as expected by writing into the converted channels.

Parameters:

source -

channel - 0 = alpha, 1 = red, 2 = green, 3 = blue

Returns:

a converted WriteConvertedRandomAccessibleInterval whose Samplers perform on-the-fly value conversion into and from one channel of the original ARGBType.

argbChannel
```
public static final WriteConvertedRandomAccessible<ARGBType,UnsignedByteType> argbChannel(RandomAccessible<ARGBType> source,
 int channel)
```
Create a WriteConvertedRandomAccessible to one of the four channels encoded in a RandomAccessible of ARGBType. The source is being modified as expected by writing into the converted channels.

Parameters:

source -

channel - 0 = alpha, 1 = red, 2 = green, 3 = blue

Returns:

a converted WriteConvertedRandomAccessible whose Samplers perform on-the-fly value conversion into and from one channel of the original ARGBType.

argbChannels
```
public static final RandomAccessibleInterval<UnsignedByteType> argbChannels(RandomAccessibleInterval<ARGBType> source)
```
Create an (n+1)-dimensional RandomAccessible of an n-dimensional RandomAccessible that maps the four channels encoded in ARGBType into a dimension. The source is being modified as expected by writing into the converted channels.

Parameters:

source -

Returns:

a converted RandomAccessibleInterval whose Samplers perform on-the-fly value conversion into and from the corresponding channels of the original ARGBType.

argbChannels
```
public static final RandomAccessibleInterval<UnsignedByteType> argbChannels(RandomAccessibleInterval<ARGBType> source,
 int... channels)
```
Create an (n+1)-dimensional RandomAccessible of an n-dimensional RandomAccessible that maps the four channels encoded in ARGBType into a dimension. The order of the channels passed as arguments is preserved. The source is being modified as expected by writing into the converted channels.

Parameters:

source -

channels - 0 = alpha, 1 = red, 2 = green, 3 = blue

Returns:

a converted RandomAccessibleInterval whose Samplers perform on-the-fly value conversion into and from the corresponding channels of the original ARGBType.

mergeARGB
```
public static final RandomAccessible<ARGBType> mergeARGB(RandomAccessible<UnsignedByteType> source,
 ColorChannelOrder channelOrder)
```
Create an n-dimensional color image from an (n+1)-dimensional image of UnsignedByteType.

Parameters:

source - The last dimension of the image must be the color channel. Views.stack(java.util.List<? extends net.imglib2.RandomAccessibleInterval<T>>) could be used to create the source, if there is a separate image for each color channel.

channelOrder - Order of the color channels.

Returns:

Color view to the source image that can be used for reading and writing.

mergeARGB
```
public static final RandomAccessibleInterval<ARGBType> mergeARGB(RandomAccessibleInterval<UnsignedByteType> source,
 ColorChannelOrder channelOrder)
```
Create an n-dimensional color image from an (n+1)-dimensional image of UnsignedByteType.

Parameters:

source - The last dimension of the image must be the color channel. Views.stack(java.util.List<? extends net.imglib2.RandomAccessibleInterval<T>>) could be used to create the source, if there is a separate image for each color channel.

channelOrder - Order of the color channels.

Returns:

Color view to the source image that can be used for reading and writing.

composeReal

public static final <A extends RealType<A>,B extends Type<B>> RandomAccessibleInterval<B> composeReal(List<RandomAccessibleInterval<A>> components,
                                                                                                      Converter<RealComposite<A>,B> composer,
                                                                                                      B targetType)

Compose a list of same Interval and same RealType A RandomAccessibleIntervals into a RandomAccessibleInterval of some target Type B using a Converter from Composite of A to B.

Parameters:: components -; composer -; targetType -
Returns:

composeReal

public static final <A extends RealType<A>,B extends Type<B>> RandomAccessibleInterval<B> composeReal(List<RandomAccessibleInterval<A>> components,
                                                                                                      Converter<RealComposite<A>,B> composer,
                                                                                                      Supplier<B> targetTypeSupplier)

Compose a list of same Interval and same RealType A RandomAccessibleIntervals into a RandomAccessibleInterval of some target Type B using a Converter from Composite of A to B.

Parameters:: components -; composer -; targetTypeSupplier -
Returns:

composeNumeric

public static final <A extends NumericType<A>,B extends Type<B>> RandomAccessibleInterval<B> composeNumeric(List<RandomAccessibleInterval<A>> components,
                                                                                                            Converter<NumericComposite<A>,B> composer,
                                                                                                            B targetType)

Compose a list of same Interval and same NumericType A RandomAccessibleIntervals into a RandomAccessibleInterval of some target Type B using a Converter from Composite of A to B.

Parameters:: components -; composer -; targetType -
Returns:

composeNumeric

public static final <A extends NumericType<A>,B extends Type<B>> RandomAccessibleInterval<B> composeNumeric(List<RandomAccessibleInterval<A>> components,
                                                                                                            Converter<NumericComposite<A>,B> composer,
                                                                                                            Supplier<B> targetTypeSupplier)

Compose a list of same Interval and same NumericType A RandomAccessibleIntervals into a RandomAccessibleInterval of some target Type B using a Converter from Composite of A to B.

Parameters:: components -; composer -; targetTypeSupplier -
Returns:

compose

public static final <A,B extends Type<B>> RandomAccessibleInterval<B> compose(List<RandomAccessibleInterval<A>> components,
                                                                              Converter<Composite<A>,B> composer,
                                                                              B targetType)

Compose a list of same Interval and same Type A RandomAccessibleIntervals into a RandomAccessibleInterval of some target Type B using a Converter from Composite of A to B.

Parameters:: components -; composer -; targetType -
Returns:

compose

public static final <A,B extends Type<B>> RandomAccessibleInterval<B> compose(List<RandomAccessibleInterval<A>> components,
                                                                              Converter<Composite<A>,B> composer,
                                                                              Supplier<B> targetTypeSupplier)

Compose a list of same Interval and same Type A RandomAccessibleIntervals into a RandomAccessibleInterval of some target Type B using a Converter from Composite of A to B.

Parameters:: components -; composer -; targetTypeSupplier -
Returns:

convert

public static final <A,B,C extends Type<C>> RandomAccessible<C> convert(RandomAccessible<A> sourceA,
                                                                        RandomAccessible<B> sourceB,
                                                                        BiConverter<? super A,? super B,? super C> converter,
                                                                        C c)

Parameters:: sourceA -; sourceB -; converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> RandomAccessible<C> convert(RandomAccessible<A> sourceA,
                                                                        RandomAccessible<B> sourceB,
                                                                        Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
                                                                        C c)

Parameters:: sourceA -; sourceB -; converterSupplier - a supplier of a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> RandomAccessibleInterval<C> convert(RandomAccessibleInterval<A> sourceA,
                                                                                RandomAccessibleInterval<B> sourceB,
                                                                                BiConverter<? super A,? super B,? super C> converter,
                                                                                C c)

Parameters:: sourceA -; sourceB -; converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided BiConverter.

convert

public static final <A,B,C extends Type<C>> RandomAccessibleInterval<C> convert(RandomAccessibleInterval<A> sourceA,
                                                                                RandomAccessibleInterval<B> sourceB,
                                                                                Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
                                                                                C c)

Parameters:: sourceA -; sourceB -; converterSupplier - a supplier of a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided BiConverter.

convertRAI
```
public static final <A,B,C extends Type<C>> RandomAccessibleInterval<C> convertRAI(RandomAccessibleInterval<A> sourceA,
 RandomAccessibleInterval sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 C c)
```
Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted RandomAccessibleInterval has no effect. Delegates to convert(RandomAccessibleInterval, Converter, Type). The different method name avoids situations where the compiler or a scripting language interpreter picks the undesired method for an object that implements both RandomAccessibleInterval and IterableInterval.

Parameters:

sourceA -

sourceB -

converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get())

c -

Returns:

a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convertRAI
```
public static final <A,B,C extends Type<C>> RandomAccessibleInterval<C> convertRAI(RandomAccessibleInterval<A> sourceA,
 RandomAccessibleInterval sourceB,
 Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 C c)
```
Create a RandomAccessibleInterval whose RandomAccesses Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted RandomAccessibleInterval has no effect. Delegates to convert(RandomAccessibleInterval, Converter, Type). The different method name avoids situations where the compiler or a scripting language interpreter picks the undesired method for an object that implements both RandomAccessibleInterval and IterableInterval.

Parameters:

sourceA -

sourceB -

converterSupplier - s aupplier of a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get())

c -

Returns:

a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> IterableInterval<C> convert(IterableInterval<A> sourceA,
                                                                        IterableInterval<B> sourceB,
                                                                        BiConverter<? super A,? super B,? super C> converter,
                                                                        C c)

Create a IterableInterval whose Cursors Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted IterableInterval has no effect.

Parameters:: sourceA -; sourceB -; converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> IterableInterval<C> convert(IterableInterval<A> sourceA,
                                                                        IterableInterval<B> sourceB,
                                                                        Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
                                                                        C c)

Create a IterableInterval whose Cursors Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted IterableInterval has no effect.

Parameters:: sourceA -; sourceB -; converterSupplier - supplies a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> IterableRealInterval<C> convert(IterableRealInterval<A> sourceA,
                                                                            IterableRealInterval<B> sourceB,
                                                                            BiConverter<? super A,? super B,? super C> converter,
                                                                            C c)

Create an IterableRealInterval whose RealCursors Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted IterableRealInterval has no effect.

Parameters:: sourceA -; sourceB -; converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> IterableRealInterval<C> convert(IterableRealInterval<A> sourceA,
                                                                            IterableRealInterval<B> sourceB,
                                                                            Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
                                                                            C c)

Parameters:: sourceA -; sourceB -; converterSupplier - supplies a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> RealRandomAccessibleRealInterval<C> convert(RealRandomAccessibleRealInterval<A> sourceA,
                                                                                        RealRandomAccessibleRealInterval<B> sourceB,
                                                                                        BiConverter<? super A,? super B,? super C> converter,
                                                                                        C c)

Parameters:: sourceA -; sourceB -; converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> RealRandomAccessibleRealInterval<C> convert(RealRandomAccessibleRealInterval<A> sourceA,
                                                                                        RealRandomAccessibleRealInterval<B> sourceB,
                                                                                        Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
                                                                                        C c)

Parameters:: sourceA -; sourceB -; converterSupplier - a supplier of a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> RealRandomAccessible<C> convert(RealRandomAccessible<A> sourceA,
                                                                            RealRandomAccessible<B> sourceB,
                                                                            BiConverter<? super A,? super B,? super C> converter,
                                                                            C c)

Parameters:: sourceA -; sourceB -; converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.

convert

public static final <A,B,C extends Type<C>> RealRandomAccessible<C> convert(RealRandomAccessible<A> sourceA,
                                                                            RealRandomAccessible<B> sourceB,
                                                                            Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
                                                                            C c)

Parameters:: sourceA -; sourceB -; converterSupplier - a supplier of a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get()); c -
Returns:: a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.

Class Converters

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Converters

Method Detail

convert

convert

convert

convert

convert

convert

convertRAI

convertRAI

convert

convert

convertRAI

convert

convert

convertRAI

convert

convert

convert

convert

convert

convertRandomAccessibleIterableInterval

convertRandomAccessibleIterableInterval

convert

convert

convert

convert

argbChannel

argbChannel

argbChannels

argbChannels

mergeARGB

mergeARGB

composeReal

composeReal

composeNumeric

composeNumeric

compose

compose

convert

convert

convert

convert

convertRAI

convertRAI

convert

convert

convert

convert

convert

convert

convert

convert