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

public class Converters
extends java.lang.Object

Convenience factory methods for sample conversion.

Constructor Summary

Constructors
Constructor Description

Converters()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	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(java.util.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>`	`compose2(java.util.List<RandomAccessibleInterval<A>> components, Converter<Composite<A>,B> composer, java.util.function.Supplier<B> targetSupplier)`	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(java.util.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> RandomAccessibleInterval<B>`	`composeNumeric2(java.util.List<RandomAccessibleInterval<A>> components, Converter<NumericComposite<A>,B> composer, java.util.function.Supplier<B> targetSupplier)`	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(java.util.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> RandomAccessibleInterval<B>`	`composeReal2(java.util.List<RandomAccessibleInterval<A>> components, Converter<RealComposite<A>,B> composer, java.util.function.Supplier<B> targetSupplier)`	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, java.util.function.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, java.util.function.Supplier<SamplerConverter<? super A,B>> converterSupplier)`	Create an `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`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 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,C extends Type<C>> IterableInterval<C>`	`convert(IterableInterval<A> sourceA, IterableInterval<B> sourceB, java.util.function.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,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 extends Type<B>> IterableRealInterval<B>`	`convert(IterableRealInterval<A> source, java.util.function.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>> 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 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,C extends Type<C>> IterableRealInterval<C>`	`convert(IterableRealInterval<A> sourceA, IterableRealInterval<B> sourceB, java.util.function.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,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 extends Type<B>> RandomAccessible<B>`	`convert(RandomAccessible<A> source, java.util.function.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, java.util.function.Supplier<SamplerConverter<? super A,B>> converterSupplier)`	Create a `RandomAccessible` whose `RandomAccesses` `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 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,C extends Type<C>> RandomAccessible<C>`	`convert(RandomAccessible<A> sourceA, RandomAccessible<B> sourceB, java.util.function.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,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 extends Type<B>> RandomAccessibleInterval<B>`	`convert(RandomAccessibleInterval<A> source, java.util.function.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, java.util.function.Supplier<SamplerConverter<? super A,B>> converterSupplier)`	Create a `RandomAccessibleInterval` 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 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,C extends Type<C>> RandomAccessibleInterval<C>`	`convert(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, java.util.function.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,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 extends Type<B>> RealRandomAccessible<B>`	`convert(RealRandomAccessible<A> source, java.util.function.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>> 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, java.util.function.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,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 extends Type<B>> RealRandomAccessibleRealInterval<B>`	`convert(RealRandomAccessibleRealInterval<A> source, java.util.function.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>> 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, java.util.function.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,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> IterableInterval<B>`	`convert2(IterableInterval<A> source, java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier, java.util.function.Supplier<B> targetSupplier)`	Create a `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B> IterableInterval<B>`	`convert2(IterableInterval<A> source, Converter<? super A,? super B> converter, java.util.function.Supplier<B> targetSupplier)`	Create a `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B,C> IterableInterval<C>`	`convert2(IterableInterval<A> sourceA, IterableInterval<B> sourceB, java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, java.util.function.Supplier<C> targetSupplier)`	Create a `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B,C> IterableInterval<C>`	`convert2(IterableInterval<A> sourceA, IterableInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, java.util.function.Supplier<C> targetSupplier)`	Create a `IterableInterval` whose `Cursors` `Sampler.get()` you a converted sample.
`static <A,B> IterableRealInterval<B>`	`convert2(IterableRealInterval<A> source, java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier, java.util.function.Supplier<B> targetSupplier)`	Create a `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B> IterableRealInterval<B>`	`convert2(IterableRealInterval<A> source, Converter<? super A,? super B> converter, java.util.function.Supplier<B> targetSupplier)`	Create a `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B,C> IterableRealInterval<C>`	`convert2(IterableRealInterval<A> sourceA, IterableRealInterval<B> sourceB, java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, java.util.function.Supplier<C> targetSupplier)`	Create a `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B,C> IterableRealInterval<C>`	`convert2(IterableRealInterval<A> sourceA, IterableRealInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, java.util.function.Supplier<C> targetSupplier)`	Create an `IterableRealInterval` whose `RealCursors` `Sampler.get()` you a converted sample.
`static <A,B> RandomAccessible<B>`	`convert2(RandomAccessible<A> source, java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier, java.util.function.Supplier<B> targetSupplier)`	Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B> RandomAccessible<B>`	`convert2(RandomAccessible<A> source, Converter<? super A,? super B> converter, java.util.function.Supplier<B> targetSupplier)`	Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RandomAccessible<C>`	`convert2(RandomAccessible<A> sourceA, RandomAccessible<B> sourceB, java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, java.util.function.Supplier<C> targetSupplier)`	Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RandomAccessible<C>`	`convert2(RandomAccessible<A> sourceA, RandomAccessible<B> sourceB, BiConverter<? super A,? super B,? super C> converter, java.util.function.Supplier<C> targetSupplier)`	Create a `RandomAccessible` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B> RandomAccessibleInterval<B>`	`convert2(RandomAccessibleInterval<A> source, java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier, java.util.function.Supplier<B> targetSupplier)`	Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B> RandomAccessibleInterval<B>`	`convert2(RandomAccessibleInterval<A> source, Converter<? super A,? super B> converter, java.util.function.Supplier<B> targetSupplier)`	Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RandomAccessibleInterval<C>`	`convert2(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, java.util.function.Supplier<C> targetSupplier)`	Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RandomAccessibleInterval<C>`	`convert2(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, java.util.function.Supplier<C> targetSupplier)`	Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B> RealRandomAccessible<B>`	`convert2(RealRandomAccessible<A> source, java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier, java.util.function.Supplier<B> targetSupplier)`	Create a `RealRandomAccessible` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B> RealRandomAccessible<B>`	`convert2(RealRandomAccessible<A> source, Converter<? super A,? super B> converter, java.util.function.Supplier<B> targetSupplier)`	Create a `RealRandomAccessible` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RealRandomAccessible<C>`	`convert2(RealRandomAccessible<A> sourceA, RealRandomAccessible<B> sourceB, java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, java.util.function.Supplier<C> targetSupplier)`	Create a `RealRandomAccessible` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RealRandomAccessible<C>`	`convert2(RealRandomAccessible<A> sourceA, RealRandomAccessible<B> sourceB, BiConverter<? super A,? super B,? super C> converter, java.util.function.Supplier<C> targetSupplier)`	Create a `RealRandomAccessible` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B> RealRandomAccessibleRealInterval<B>`	`convert2(RealRandomAccessibleRealInterval<A> source, java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier, java.util.function.Supplier<B> targetSupplier)`	Create a `RealRandomAccessibleRealInterval` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B> RealRandomAccessibleRealInterval<B>`	`convert2(RealRandomAccessibleRealInterval<A> source, Converter<? super A,? super B> converter, java.util.function.Supplier<B> targetSupplier)`	Create a `RealRandomAccessibleRealInterval` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RealRandomAccessibleRealInterval<C>`	`convert2(RealRandomAccessibleRealInterval<A> sourceA, RealRandomAccessibleRealInterval<B> sourceB, java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, java.util.function.Supplier<C> targetSupplier)`	Create a `RealRandomAccessibleRealInterval` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RealRandomAccessibleRealInterval<C>`	`convert2(RealRandomAccessibleRealInterval<A> sourceA, RealRandomAccessibleRealInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, java.util.function.Supplier<C> targetSupplier)`	Create a `RealRandomAccessibleRealInterval` whose `RealRandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B extends Type<B>> RandomAccessibleInterval<B>`	`convertRAI(RandomAccessibleInterval<A> source, java.util.function.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, java.util.function.Supplier<SamplerConverter<? super A,B>> converterSupplier)`	Create a `RandomAccessibleInterval` whose `RandomAccesses` `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 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,C extends Type<C>> RandomAccessibleInterval<C>`	`convertRAI(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, java.util.function.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,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> RandomAccessibleInterval<B>`	`convertRAI2(RandomAccessibleInterval<A> source, java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier, java.util.function.Supplier<B> targetSupplier)`	Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B> RandomAccessibleInterval<B>`	`convertRAI2(RandomAccessibleInterval<A> source, Converter<? super A,? super B> converter, java.util.function.Supplier<B> targetSupplier)`	Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RandomAccessibleInterval<C>`	`convertRAI2(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier, java.util.function.Supplier<C> targetSupplier)`	Create a `RandomAccessibleInterval` whose `RandomAccesses` `Sampler.get()` you a converted sample.
`static <A,B,C> RandomAccessibleInterval<C>`	`convertRAI2(RandomAccessibleInterval<A> sourceA, RandomAccessibleInterval<B> sourceB, BiConverter<? super A,? super B,? super C> converter, java.util.function.Supplier<C> targetSupplier)`	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, java.util.function.Supplier<SamplerConverter<? super A,B>> converterSupplier)`	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, SamplerConverter<? super A,B> converter)`	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 <A,B extends Type> RandomAccessible 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 - must be stateless when multi-threading
 
 b -
 
 Returns:
 
 a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> RandomAccessible convert2(RandomAccessible<A> source,
 Converter<? super A,? super B> converter,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converter - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> RandomAccessible convert(RandomAccessible<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 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 -
 
 converterSupplier -
 
 b -
 
 Returns:
 
 a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> RandomAccessible convert2(RandomAccessible<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converterSupplier -
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> 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 - must be stateless when multi-threading
 
 Returns:
 
 a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> WriteConvertedRandomAccessible<A,B> convert(RandomAccessible<A> source,
 java.util.function.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 <A,B extends Type> RandomAccessibleInterval 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 - must be stateless when multi-threading
 
 b -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> RandomAccessibleInterval convert2(RandomAccessibleInterval<A> source,
 Converter<? super A,? super B> converter,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converter - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> RandomAccessibleInterval convert(RandomAccessibleInterval<A> source,
 java.util.function.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.
 
 Parameters:
 
 source -
 
 converterSupplier -
 
 b -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> RandomAccessibleInterval convert2(RandomAccessibleInterval<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converterSupplier -
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convertRAI
```
public static <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 - must be stateless when multi-threading
 
 b -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convertRAI2
```
public static <A,B> RandomAccessibleInterval convertRAI2(RandomAccessibleInterval<A> source,
 Converter<? super A,? super B> converter,
 java.util.function.Supplier targetSupplier)
```
 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 convert2(RandomAccessibleInterval, Converter, Supplier). 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. The method signature is convertRAI2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converter - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convertRAI
```
public static <A,B extends Type> RandomAccessibleInterval convertRAI(RandomAccessibleInterval<A> source,
 java.util.function.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.
 - convertRAI2
```
public static <A,B> RandomAccessibleInterval convertRAI2(RandomAccessibleInterval<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 java.util.function.Supplier targetSupplier)
```
 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 convert2(RandomAccessibleInterval, Converter, Supplier). 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. The method signature is convertRAI2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converterSupplier -
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> 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 - must be stateless when multi-threading
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> WriteConvertedRandomAccessibleInterval<A,B> convert(RandomAccessibleInterval<A> source,
 java.util.function.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 <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 - must be stateless when multi-threading
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> IterableRealInterval 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 - must be stateless when multi-threading
 
 b -
 
 Returns:
 
 a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> IterableRealInterval convert2(IterableRealInterval<A> source,
 Converter<? super A,? super B> converter,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converter - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> IterableRealInterval convert(IterableRealInterval<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 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 -
 
 converterSupplier -
 
 b -
 
 Returns:
 
 a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> IterableRealInterval convert2(IterableRealInterval<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converterSupplier -
 
 targetSupplier -
 
 Returns:
 
 a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convertRAI
```
public static <A,B extends Type> WriteConvertedRandomAccessibleInterval<A,B> convertRAI(RandomAccessibleInterval<A> source,
 java.util.function.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 <A,B extends Type> IterableInterval 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 - must be stateless when multi-threading
 
 b -
 
 Returns:
 
 a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> IterableInterval convert2(IterableInterval<A> source,
 Converter<? super A,? super B> converter,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converter - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> IterableInterval convert(IterableInterval<A> source,
 java.util.function.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.
 - convert2
```
public static <A,B> IterableInterval convert2(IterableInterval<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converterSupplier -
 
 targetSupplier -
 
 Returns:
 
 a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> 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 - must be stateless when multi-threading
 
 Returns:
 
 a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> 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 - must be stateless when multi-threading
 
 Returns:
 
 a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> WriteConvertedIterableInterval<A,B> convert(IterableInterval<A> source,
 java.util.function.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 <A,B extends Type,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 - must be stateless when multi-threading
 
 Returns:
 
 a WriteConvertedIterableRandomAccessibleInterval whose Samplers perform on-the-fly value conversion using the provided converter.
 - convertRandomAccessibleIterableInterval
```
public static <A,B extends Type,S extends RandomAccessible<A> & IterableInterval<A>> WriteConvertedIterableRandomAccessibleInterval<A,B,S> convertRandomAccessibleIterableInterval(S source,
 java.util.function.Supplier<SamplerConverter<? super A,B>> converterSupplier)
```
 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 -
 
 converterSupplier -
 
 Returns:
 
 a WriteConvertedIterableRandomAccessibleInterval whose Samplers perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> RealRandomAccessibleRealInterval 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 - must be stateless when multi-threading
 
 b -
 
 Returns:
 
 a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> RealRandomAccessibleRealInterval convert2(RealRandomAccessibleRealInterval<A> source,
 Converter<? super A,? super B> converter,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converter - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> RealRandomAccessibleRealInterval convert(RealRandomAccessibleRealInterval<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 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 -
 
 converterSupplier -
 
 b -
 
 Returns:
 
 a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> RealRandomAccessibleRealInterval convert2(RealRandomAccessibleRealInterval<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converterSupplier -
 
 targetSupplier -
 
 Returns:
 
 a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> RealRandomAccessible 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 - must be stateless when multi-threading
 
 b -
 
 Returns:
 
 a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> RealRandomAccessible convert2(RealRandomAccessible<A> source,
 Converter<? super A,? super B> converter,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converter - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B extends Type> RealRandomAccessible convert(RealRandomAccessible<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 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 -
 
 converterSupplier -
 
 b -
 
 Returns:
 
 a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B> RealRandomAccessible convert2(RealRandomAccessible<A> source,
 java.util.function.Supplier<Converter<? super A,? super B>> converterSupplier,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 source -
 
 converterSupplier -
 
 targetSupplier -
 
 Returns:
 
 a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - argbChannel
```
public 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. 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 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 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 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 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 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 <A extends RealType<A>,B extends Type> RandomAccessibleInterval composeReal(java.util.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 - must be stateless when multi-threading
 
 targetType -
 
 Returns:
 - composeReal2
```
public static <A extends RealType<A>,B> RandomAccessibleInterval composeReal2(java.util.List<RandomAccessibleInterval<A>> components,
 Converter<RealComposite<A>,B> composer,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is composeReal2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 components -
 
 composer - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 - composeNumeric
```
public static <A extends NumericType<A>,B extends Type> RandomAccessibleInterval composeNumeric(java.util.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 - must be stateless when multi-threading
 
 targetType -
 
 Returns:
 - composeNumeric2
```
public static <A extends NumericType<A>,B> RandomAccessibleInterval composeNumeric2(java.util.List<RandomAccessibleInterval<A>> components,
 Converter<NumericComposite<A>,B> composer,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is composeNumeric2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 components -
 
 composer - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 - compose
```
public static <A,B extends Type> RandomAccessibleInterval compose(java.util.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 - must be stateless when multi-threading
 
 targetType -
 
 Returns:
 - compose2
```
public static <A,B extends Type> RandomAccessibleInterval compose2(java.util.List<RandomAccessibleInterval<A>> components,
 Converter<Composite<A>,B> composer,
 java.util.function.Supplier targetSupplier)
```
 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. The method signature is compose2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 components -
 
 composer - must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 - convert
```
public static <A,B,C extends Type<C>> RandomAccessible<C> convert(RandomAccessible<A> sourceA,
 RandomAccessible sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 C c)
```
 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:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 c -
 
 Returns:
 
 a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B,C> RandomAccessible<C> convert2(RandomAccessible<A> sourceA,
 RandomAccessible sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> RandomAccessible<C> convert(RandomAccessible<A> sourceA,
 RandomAccessible sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 C c)
```
 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:
 
 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.
 - convert2
```
public static <A,B,C> RandomAccessible<C> convert2(RandomAccessible<A> sourceA,
 RandomAccessible sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 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())
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessible whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> RandomAccessibleInterval<C> convert(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.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 c -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided BiConverter.
 - convert2
```
public static <A,B,C> RandomAccessibleInterval<C> convert2(RandomAccessibleInterval<A> sourceA,
 RandomAccessibleInterval sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided BiConverter.
 - convert
```
public static <A,B,C extends Type<C>> RandomAccessibleInterval<C> convert(RandomAccessibleInterval<A> sourceA,
 RandomAccessibleInterval sourceB,
 java.util.function.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.
 
 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.
 - convert2
```
public static <A,B,C> RandomAccessibleInterval<C> convert2(RandomAccessibleInterval<A> sourceA,
 RandomAccessibleInterval sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 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())
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided BiConverter.
 - convertRAI
```
public static <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()) must be stateless when multi-threading
 
 c -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convertRAI2
```
public static <A,B,C> RandomAccessibleInterval<C> convertRAI2(RandomAccessibleInterval<A> sourceA,
 RandomAccessibleInterval sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convertRAI2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convertRAI
```
public static <A,B,C extends Type<C>> RandomAccessibleInterval<C> convertRAI(RandomAccessibleInterval<A> sourceA,
 RandomAccessibleInterval sourceB,
 java.util.function.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.
 - convertRAI2
```
public static <A,B,C> RandomAccessibleInterval<C> convertRAI2(RandomAccessibleInterval<A> sourceA,
 RandomAccessibleInterval sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convertRAI2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 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())
 
 targetSupplier -
 
 Returns:
 
 a converted RandomAccessibleInterval whose RandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> IterableInterval<C> convert(IterableInterval<A> sourceA,
 IterableInterval 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()) must be stateless when multi-threading
 
 c -
 
 Returns:
 
 a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B,C> IterableInterval<C> convert2(IterableInterval<A> sourceA,
 IterableInterval sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> IterableInterval<C> convert(IterableInterval<A> sourceA,
 IterableInterval sourceB,
 java.util.function.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.
 - convert2
```
public static <A,B,C> IterableInterval<C> convert2(IterableInterval<A> sourceA,
 IterableInterval sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converterSupplier - supplies a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get())
 
 targetSupplier -
 
 Returns:
 
 a converted IterableInterval whose Cursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> IterableRealInterval<C> convert(IterableRealInterval<A> sourceA,
 IterableRealInterval 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()) must be stateless when multi-threading
 
 c -
 
 Returns:
 
 a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B,C> IterableRealInterval<C> convert2(IterableRealInterval<A> sourceA,
 IterableRealInterval sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> IterableRealInterval<C> convert(IterableRealInterval<A> sourceA,
 IterableRealInterval sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 C c)
```
 Create a IterableRealInterval whose RealCursors 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 IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B,C> IterableRealInterval<C> convert2(IterableRealInterval<A> sourceA,
 IterableRealInterval sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 java.util.function.Supplier<C> targetSupplier)
```
 Create a IterableRealInterval whose RealCursors Sampler.get() you a converted sample. Conversion is done on-the-fly when reading values. Writing to the converted IterableInterval has no effect. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converterSupplier - supplies a two variable function into a preallocated output, e.g. () -> (a, b, c) -> c.set(a.get() + b.get())
 
 targetSupplier -
 
 Returns:
 
 a converted IterableRealInterval whose RealCursors perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> RealRandomAccessibleRealInterval<C> convert(RealRandomAccessibleRealInterval<A> sourceA,
 RealRandomAccessibleRealInterval sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 C c)
```
 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:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 c -
 
 Returns:
 
 a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B,C> RealRandomAccessibleRealInterval<C> convert2(RealRandomAccessibleRealInterval<A> sourceA,
 RealRandomAccessibleRealInterval sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> RealRandomAccessibleRealInterval<C> convert(RealRandomAccessibleRealInterval<A> sourceA,
 RealRandomAccessibleRealInterval sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 C c)
```
 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:
 
 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.
 - convert2
```
public static <A,B,C> RealRandomAccessibleRealInterval<C> convert2(RealRandomAccessibleRealInterval<A> sourceA,
 RealRandomAccessibleRealInterval sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 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())
 
 targetSupplier -
 
 Returns:
 
 a converted RealRandomAccessibleRealInterval whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> RealRandomAccessible<C> convert(RealRandomAccessible<A> sourceA,
 RealRandomAccessible sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 C c)
```
 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:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 c -
 
 Returns:
 
 a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert2
```
public static <A,B,C> RealRandomAccessible<C> convert2(RealRandomAccessible<A> sourceA,
 RealRandomAccessible sourceB,
 BiConverter<? super A,? super B,? super C> converter,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 Parameters:
 
 sourceA -
 
 sourceB -
 
 converter - a two variable function into a preallocated output, e.g. (a, b, c) -> c.set(a.get() + b.get()) must be stateless when multi-threading
 
 targetSupplier -
 
 Returns:
 
 a converted RealRandomAccessible whose RealRandomAccesses perform on-the-fly value conversion using the provided converter.
 - convert
```
public static <A,B,C extends Type<C>> RealRandomAccessible<C> convert(RealRandomAccessible<A> sourceA,
 RealRandomAccessible sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 C c)
```
 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:
 
 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.
 - convert2
```
public static <A,B,C> RealRandomAccessible<C> convert2(RealRandomAccessible<A> sourceA,
 RealRandomAccessible sourceB,
 java.util.function.Supplier<BiConverter<? super A,? super B,? super C>> converterSupplier,
 java.util.function.Supplier<C> targetSupplier)
```
 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. The method signature is convert2 because many Java compilers cannot resolve the correct overload when the target Supplier is passed as a lambda and cause spurious and seemingly false ambiguous method errors.
 
 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())
 
 targetSupplier -
 
 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

convert2

convert

convert2

convert

convert

convert

convert2

convert

convert2

convertRAI

convertRAI2

convertRAI

convertRAI2

convert

convert

convertRAI

convert

convert2

convert

convert2

convertRAI

convert

convert2

convert

convert2

convert

convert

convert

convertRandomAccessibleIterableInterval

convertRandomAccessibleIterableInterval

convert

convert2

convert

convert2

convert

convert2

convert

convert2

argbChannel

argbChannel

argbChannels

argbChannels

mergeARGB

mergeARGB

composeReal

composeReal2

composeNumeric

composeNumeric2

compose

compose2

convert

convert2

convert

convert2

convert

convert2

convert

convert2

convertRAI

convertRAI2

convertRAI

convertRAI2

convert

convert2

convert

convert2

convert

convert2

convert

convert2

convert

convert2