diff --git a/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/Conversions.java b/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/Conversions.java index 9eeb24402..581d85346 100644 --- a/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/Conversions.java +++ b/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/Conversions.java @@ -241,8 +241,8 @@ private static Optional postprocessIdentity(OpInfo info, return Optional.empty(); } // And only applies when the mutable index was "converted" with identity - if (Ops.info(preConverters.get(ioIndex)).names().contains( - "engine.identity")) + var names = Ops.info(preConverters.get(ioIndex)).names(); + if (names.contains("engine.identity") || names.contains("engine.wrap")) { // In this case, we need neither a postprocessor nor a copier, // because the mutable output was directly edited. diff --git a/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/ConvertedInfoTreeGenerator.java b/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/ConvertedInfoTreeGenerator.java index 7de0920cb..5471566f4 100644 --- a/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/ConvertedInfoTreeGenerator.java +++ b/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/ConvertedInfoTreeGenerator.java @@ -39,6 +39,8 @@ import org.scijava.ops.api.*; import org.scijava.ops.engine.BaseOpHints; import org.scijava.ops.engine.InfoTreeGenerator; +import org.scijava.ops.engine.matcher.impl.DefaultOpRequest; +import org.scijava.ops.engine.matcher.impl.InfoMatchingOpRequest; import org.scijava.types.Nil; /** diff --git a/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/impl/RuntimeSafeMatchingRoutine.java b/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/impl/RuntimeSafeMatchingRoutine.java index 1efe46267..084cdc0b9 100644 --- a/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/impl/RuntimeSafeMatchingRoutine.java +++ b/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/impl/RuntimeSafeMatchingRoutine.java @@ -53,7 +53,6 @@ import org.scijava.ops.engine.matcher.OpMatcher; import org.scijava.ops.engine.matcher.impl.MatchingUtils.TypeVarInfo; import org.scijava.priority.Priority; -import org.scijava.struct.Member; import org.scijava.common3.Types; import org.scijava.types.infer.GenericAssignability; diff --git a/scijava-ops-image/src/main/java/org/scijava/ops/image/convert/ConvertImages.java b/scijava-ops-image/src/main/java/org/scijava/ops/image/convert/ConvertImages.java index d36cf4ce3..a91e3fd82 100644 --- a/scijava-ops-image/src/main/java/org/scijava/ops/image/convert/ConvertImages.java +++ b/scijava-ops-image/src/main/java/org/scijava/ops/image/convert/ConvertImages.java @@ -30,7 +30,14 @@ package org.scijava.ops.image.convert; import net.imglib2.Dimensions; +import net.imglib2.IterableInterval; import net.imglib2.RandomAccessibleInterval; +import net.imglib2.Sampler; +import net.imglib2.converter.Converters; +import net.imglib2.converter.readwrite.SamplerConverter; +import net.imglib2.converter.readwrite.WriteConvertedIterableRandomAccessibleInterval; +import net.imglib2.img.basictypeaccess.DoubleAccess; +import net.imglib2.img.basictypeaccess.LongAccess; import net.imglib2.loops.LoopBuilder; import net.imglib2.type.logic.BitType; import net.imglib2.type.numeric.ComplexType; @@ -39,6 +46,7 @@ import net.imglib2.type.numeric.integer.*; import net.imglib2.type.numeric.real.DoubleType; import net.imglib2.type.numeric.real.FloatType; +import net.imglib2.util.Util; import org.scijava.function.Computers; import org.scijava.ops.spi.OpDependency; @@ -51,384 +59,404 @@ */ public final class ConvertImages { - /** - * @implNote op names='convert.bit, engine.convert', type=Function - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link BitType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}s - * values but whose element types are {@link BitType}s. - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToBit(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.bit") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new BitType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } +// /** +// * @implNote op names='convert.bit, engine.convert', type=Function +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}s +// * values but whose element types are {@link BitType}s. +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToBit(final RAIC input) +// { +// final C ZERO = input.firstElement().createVariable(); +// ZERO.setZero(); +// final C ONE = input.firstElement().createVariable(); +// ONE.setOne(); +// +// return Converters.convert(input, sampler -> new BitType(new LongAccess() { +// @Override +// public long getValue(int index) { +// return sampler.get().equals(ZERO) ? 0L : 1L; +// } +// +// @Override +// public void setValue(int index, long value) { +// if (value == 0L) { +// sampler.get().set(ZERO); +// } else { +// sampler.get().set(ONE); +// } +// } +// })); +// } - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link Unsigned2BitType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link Unsigned2BitType}s. - * @implNote op names='convert.uint2, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToUnsigned2Bit(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.uint2") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new Unsigned2BitType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link Unsigned4BitType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link Unsigned4BitType}s. - * @implNote op names='convert.uint4, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToUnsigned4Bit(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.uint4") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new Unsigned4BitType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link ByteType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link ByteType}s. - * @implNote op names='convert.int8, convert.byte, engine.convert', - * type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToByte(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.int8") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new ByteType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link UnsignedByteType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link UnsignedByteType}s. - * @implNote op names='convert.uint8, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToUnsignedByte(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.uint8") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new UnsignedByteType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link Unsigned12BitType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link Unsigned12BitType}s. - * @implNote op names='convert.uint12, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToUnsigned12Bit( - @OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.uint12") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new Unsigned12BitType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link ShortType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link ShortType}s. - * @implNote op names='convert.int16, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToShort(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.int16") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new ShortType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link UnsignedShortType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link UnsignedShortType}s. - * @implNote op names='convert.uint16, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToUnsignedShort( - @OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.uint16") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new UnsignedShortType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link IntType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link IntType}s. - * @implNote op names='convert.int32, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToInt(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.int32") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new IntType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link UnsignedIntType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link UnsignedIntType}s. - * @implNote op names='convert.uint32, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToUnsignedInt(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.uint32") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new UnsignedIntType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link LongType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link LongType}s. - * @implNote op names='convert.int64, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToLong(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.int64") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new LongType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link UnsignedLongType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link UnsignedLongType}s. - * @implNote op names='convert.uint64, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToUnsignedLong(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.uint64") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new UnsignedLongType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link Unsigned128BitType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link Unsigned128BitType}s. - * @implNote op names='convert.uint128, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToUnsigned128Bit( - @OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.uint128") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new Unsigned128BitType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link FloatType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link FloatType}s. - * @implNote op names='convert.float32, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToFloat32(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.float32") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new FloatType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link ComplexFloatType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link ComplexFloatType}s. - * @implNote op names='convert.cfloat32, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToComplexFloat32( - @OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.cfloat32") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new ComplexFloatType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link DoubleType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link DoubleType}s. - * @implNote op names='convert.float64, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToDouble32(@OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.float64") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new DoubleType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } - - /** - * @param creator a {@link BiFunction} to create the output image - * @param converter a {@link Computers.Arity1} to convert the type to a - * {@link ComplexDoubleType} - * @param input the input image - * @return an output image whose values are equivalent to {@code input}'s - * values but whose element types are {@link ComplexDoubleType}s. - * @implNote op names='convert.cfloat64, engine.convert', type=Function - */ - public static , RAIC extends RandomAccessibleInterval> - RandomAccessibleInterval typeToComplexDouble32( - @OpDependency( - name = "create.img") BiFunction> creator, - @OpDependency( - name = "convert.cfloat64") Computers.Arity1 converter, - final RAIC input) - { - var output = creator.apply(input, - new ComplexDoubleType()); - LoopBuilder.setImages(input, output).forEachPixel(converter); - return output; - } +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link Unsigned2BitType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link Unsigned2BitType}s. +// * @implNote op names='convert.uint2, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToUnsigned2Bit(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.uint2") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new Unsigned2BitType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link Unsigned4BitType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link Unsigned4BitType}s. +// * @implNote op names='convert.uint4, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToUnsigned4Bit(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.uint4") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new Unsigned4BitType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link ByteType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link ByteType}s. +// * @implNote op names='convert.int8, convert.byte, engine.convert', +// * type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToByte(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.int8") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new ByteType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link UnsignedByteType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link UnsignedByteType}s. +// * @implNote op names='convert.uint8, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToUnsignedByte(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.uint8") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new UnsignedByteType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link Unsigned12BitType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link Unsigned12BitType}s. +// * @implNote op names='convert.uint12, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToUnsigned12Bit( +// @OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.uint12") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new Unsigned12BitType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link ShortType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link ShortType}s. +// * @implNote op names='convert.int16, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToShort(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.int16") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new ShortType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link UnsignedShortType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link UnsignedShortType}s. +// * @implNote op names='convert.uint16, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToUnsignedShort( +// @OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.uint16") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new UnsignedShortType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link IntType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link IntType}s. +// * @implNote op names='convert.int32, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToInt(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.int32") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new IntType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link UnsignedIntType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link UnsignedIntType}s. +// * @implNote op names='convert.uint32, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToUnsignedInt(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.uint32") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new UnsignedIntType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link LongType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link LongType}s. +// * @implNote op names='convert.int64, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToLong(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.int64") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new LongType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link UnsignedLongType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link UnsignedLongType}s. +// * @implNote op names='convert.uint64, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToUnsignedLong(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.uint64") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new UnsignedLongType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link Unsigned128BitType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link Unsigned128BitType}s. +// * @implNote op names='convert.uint128, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToUnsigned128Bit( +// @OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.uint128") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new Unsigned128BitType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link FloatType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link FloatType}s. +// * @implNote op names='convert.float32, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToFloat32(@OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.float32") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new FloatType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param creator a {@link BiFunction} to create the output image +// * @param converter a {@link Computers.Arity1} to convert the type to a +// * {@link ComplexFloatType} +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link ComplexFloatType}s. +// * @implNote op names='convert.cfloat32, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToComplexFloat32( +// @OpDependency( +// name = "create.img") BiFunction> creator, +// @OpDependency( +// name = "convert.cfloat32") Computers.Arity1 converter, +// final RAIC input) +// { +// var output = creator.apply(input, +// new ComplexFloatType()); +// LoopBuilder.setImages(input, output).forEachPixel(converter); +// return output; +// } +// +// /** +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link DoubleType}s. +// * @implNote op names='convert.float64, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToDoubleType(final RAIC input) +// { +// return Converters.convert(input, sampler -> new DoubleType(new DoubleAccess() { +// +// @Override +// public double getValue(int index) { +// return sampler.get().getRealDouble(); +// } +// +// @Override +// public void setValue(int index, double value) { +// sampler.get().setReal(value); +// sampler.get().setImaginary(0); +// } +// })); +// } +// +// /** +// * @param input the input image +// * @return an output image whose values are equivalent to {@code input}'s +// * values but whose element types are {@link ComplexDoubleType}s. +// * @implNote op names='convert.cfloat64, engine.convert', type=Function +// */ +// public static , RAIC extends RandomAccessibleInterval> +// RandomAccessibleInterval typeToComplexDouble32( +// final RAIC input) +// { +// return Converters.convert(input, sampler -> new ComplexDoubleType(new DoubleAccess() { +// +// @Override +// public double getValue(int index) { +// if (index % 2 == 0) { +// return sampler.get().getRealDouble(); +// } else { +// return sampler.get().getImaginaryDouble(); +// } +// } +// +// @Override +// public void setValue(int index, double value) { +// if (index % 2 == 0) { +// sampler.get().setReal(value); +// } else { +// sampler.get().setImaginary(value); +// } +// } +// })); +// } } diff --git a/scijava-ops-image/src/main/java/org/scijava/ops/image/convert/RAIWrappers.java b/scijava-ops-image/src/main/java/org/scijava/ops/image/convert/RAIWrappers.java new file mode 100644 index 000000000..4d0aff6f3 --- /dev/null +++ b/scijava-ops-image/src/main/java/org/scijava/ops/image/convert/RAIWrappers.java @@ -0,0 +1,493 @@ +/*- + * #%L + * Image processing operations for SciJava Ops. + * %% + * Copyright (C) 2014 - 2025 SciJava developers. + * %% + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * #L% + */ +package org.scijava.ops.image.convert; + +import net.imglib2.RandomAccessibleInterval; +import net.imglib2.converter.Converters; +import net.imglib2.img.basictypeaccess.*; +import net.imglib2.type.logic.BitType; +import net.imglib2.type.numeric.ComplexType; +import net.imglib2.type.numeric.complex.ComplexDoubleType; +import net.imglib2.type.numeric.complex.ComplexFloatType; +import net.imglib2.type.numeric.integer.*; +import net.imglib2.type.numeric.real.DoubleType; +import net.imglib2.type.numeric.real.FloatType; + +/** + * Wrapper Ops for {@link RandomAccessibleInterval}s of {@link ComplexType}s. + * TODO: Add more types + * + * @author Gabriel Selzer + */ +public class RAIWrappers { + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.bit', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toBitType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new BitType(new LongAccess() { + + @Override + public long getValue(int index) { + // TODO: Check correctness + return sampler.get().getRealDouble() != 0 ? -1L : 0L; + } + + @Override + public void setValue(int index, long value) { + sampler.get().setReal(value != 0 ? 1 : 0); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link Unsigned2BitType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint2', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toU2BitType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new Unsigned2BitType(new LongAccess() { + + @Override + public long getValue(int index) { + return Types.uint2(sampler.get().getRealDouble()); + } + + @Override + public void setValue(int index, long value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link Unsigned4BitType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint4', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toU4BitType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new Unsigned4BitType(new LongAccess() { + + @Override + public long getValue(int index) { + return Types.uint4(sampler.get().getRealDouble()); + } + + @Override + public void setValue(int index, long value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.int8', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toByteType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new ByteType(new ByteAccess() { + + @Override + public byte getValue(int index) { + // TODO: Check correctness + return (byte) sampler.get().getRealDouble(); + } + + @Override + public void setValue(int index, byte value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint8', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toUnsignedByteType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new UnsignedByteType(new ByteAccess() { + + @Override + public byte getValue(int index) { + // TODO: Check correctness + return UnsignedByteType.getCodedSignedByte((int) sampler.get().getRealDouble()); + } + + @Override + public void setValue(int index, byte value) { + sampler.get().setReal(UnsignedByteType.getUnsignedByte(value)); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link Unsigned12BitType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint12', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toU12BitType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new Unsigned12BitType(new LongAccess() { + + @Override + public long getValue(int index) { + return Types.uint12(sampler.get().getRealDouble()); + } + + @Override + public void setValue(int index, long value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.int16', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toShortType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new ShortType(new ShortAccess() { + + @Override + public short getValue(int index) { + return (short) sampler.get().getRealDouble(); + } + + @Override + public void setValue(int index, short value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint16', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toUnsignedShortType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new UnsignedShortType(new ShortAccess() { + + @Override + public short getValue(int index) { + // TODO: Check correctness + return UnsignedShortType.getCodedSignedShort((int) sampler.get().getRealDouble()); + } + + @Override + public void setValue(int index, short value) { + sampler.get().setReal(UnsignedShortType.getUnsignedShort(value)); + sampler.get().setImaginary(0); + } + })); + } + + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.int32', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toIntType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new IntType(new IntAccess() { + + @Override + public int getValue(int index) { + return (int) sampler.get().getRealDouble(); + } + + @Override + public void setValue(int index, int value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint32', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toUnsignedIntType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new UnsignedIntType(new IntAccess() { + + @Override + public int getValue(int index) { + return UnsignedIntType.getCodedSignedInt((long) sampler.get().getRealDouble()); + } + + @Override + public void setValue(int index, int value) { + sampler.get().setReal(UnsignedIntType.getUnsignedInt(value)); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.int64', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toLongType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new LongType(new LongAccess() { + + @Override + public long getValue(int index) { + return (long) sampler.get().getRealDouble(); + } + + @Override + public void setValue(int index, long value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint64', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toUnsignedLong( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new UnsignedLongType(new LongAccess() { + + @Override + public long getValue(int index) { + return (long) sampler.get().getRealDouble(); + } + + @Override + public void setValue(int index, long value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link Unsigned128BitType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint128', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toU128BitType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new Unsigned128BitType(new LongAccess() { + + @Override + public long getValue(int index) { + // This code is adapted from: + // net.imglib2.type.numeric.integer.Unsigned128BitType.setReal + double value = sampler.get().getRealDouble(); + value = Math.floor( value + 0.5 ); + final double base = Math.pow( 2, 64 ); + double upper = Math.floor(value / base ); + double lower = value - base * upper; + if (index % 2 == 0) { // lower long + return Types.int64(lower); + } + else { // upper long + return Types.int64(upper); + } + } + + @Override + public void setValue(int index, long value) { + // FIXME + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.float32', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toFloatType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new FloatType(new FloatAccess() { + + @Override + public float getValue(int index) { + return sampler.get().getRealFloat(); + } + + @Override + public void setValue(int index, float value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link FloatType}s. + * @implNote op names='engine.convert, engine.wrap, convert.cfloat32', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toComplexFloatType( + final RAIC input) + { + return Converters.convert(input, sampler -> new ComplexFloatType(new FloatAccess() { + + @Override + public float getValue(int index) { + if (index % 2 == 0) { + return sampler.get().getRealFloat(); + } + else { + return sampler.get().getImaginaryFloat(); + } + } + + @Override + public void setValue(int index, float value) { + if (index % 2 == 0) { + sampler.get().setReal(value); + } + else { + sampler.get().setImaginary(value); + } + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link DoubleType}s. + * @implNote op names='engine.convert, engine.wrap, convert.float64', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toDoubleType( + final RAIC input) + { + return net.imglib2.converter.Converters.convert(input, sampler -> new DoubleType(new DoubleAccess() { + + @Override + public double getValue(int index) { + return sampler.get().getRealDouble(); + } + + @Override + public void setValue(int index, double value) { + sampler.get().setReal(value); + sampler.get().setImaginary(0); + } + })); + } + + /** + * @param input the input image + * @return an output image whose values are equivalent to {@code input}'s + * values but whose element types are {@link ComplexDoubleType}s. + * @implNote op names='engine.convert, engine.wrap, convert.uint64', type=Function + */ + public static , RAIC extends RandomAccessibleInterval> RandomAccessibleInterval toComplexDoubleType( + final RAIC input) + { + return Converters.convert(input, sampler -> new ComplexDoubleType(new DoubleAccess() { + + @Override + public double getValue(int index) { + if (index % 2 == 0) { + return sampler.get().getRealDouble(); + } + else { + return sampler.get().getImaginaryDouble(); + } + } + + @Override + public void setValue(int index, double value) { + if (index % 2 == 0) { + sampler.get().setReal(value); + } + else { + sampler.get().setImaginary(value); + } + } + })); + } +} diff --git a/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/ConvertImagesCorrectnessTest.java b/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/ConvertImagesCorrectnessTest.java new file mode 100644 index 000000000..b957eec74 --- /dev/null +++ b/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/ConvertImagesCorrectnessTest.java @@ -0,0 +1,87 @@ +/*- + * #%L + * Image processing operations for SciJava Ops. + * %% + * Copyright (C) 2014 - 2025 SciJava developers. + * %% + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * #L% + */ +package org.scijava.ops.image.convert; + +import net.imglib2.img.array.ArrayImgs; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.scijava.common3.MersenneTwisterFast; + +public class ConvertImagesCorrectnessTest { + + @Test + public void realTypeToComplexDoubleTypeTest() { + MersenneTwisterFast mt = new MersenneTwisterFast(0xdeadbeefL); + int width = 10, height = 10; + var backing = ArrayImgs.bytes(width, height); + var converted = RAIWrappers.toComplexDoubleType(backing); + + var cursor = backing.cursor(); + var ra = converted.randomAccess(); + double inc = 3.2; + byte max = (byte) (Byte.MAX_VALUE - (byte) Math.ceil(inc)); + while(cursor.hasNext()) { + cursor.next(); + ra.setPosition(cursor); + byte b = mt.nextByte(); + if (b > max) b = max; + cursor.get().set(b); + Assertions.assertEquals(b, ra.get().getRealDouble()); + ra.get().set(b + inc, inc); + Assertions.assertEquals(b + (byte) inc, cursor.get().get()); + Assertions.assertEquals(0, cursor.get().getImaginaryDouble()); + } + } + + @Test + public void complexTypeToComplexDoubleTypeTest() { + MersenneTwisterFast mt = new MersenneTwisterFast(0xdeadbeefL); + int width = 10, height = 10; + var backing = ArrayImgs.complexFloats(width, height); + var converted = RAIWrappers.toComplexDoubleType(backing); + + var cursor = backing.cursor(); + var ra = converted.randomAccess(); + while(cursor.hasNext()) { + cursor.next(); + ra.setPosition(cursor); + var r = mt.nextFloat(); + var i = mt.nextFloat(); + cursor.get().set(r, i); + Assertions.assertEquals(r, ra.get().getRealDouble(), 1e-6); + Assertions.assertEquals(i, ra.get().getImaginaryDouble(), 1e-6); + ra.get().set(r + r, i + i); + Assertions.assertEquals(r + r, cursor.get().getRealFloat(), 1e-6); + Assertions.assertEquals(i + i, cursor.get().getImaginaryFloat(), 1e-6); + } + } + + + +} diff --git a/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/RAIConvertersTest.java b/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/RAIConvertersTest.java index 683add8de..7a3fe4793 100644 --- a/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/RAIConvertersTest.java +++ b/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/RAIConvertersTest.java @@ -37,8 +37,6 @@ import net.imglib2.img.array.ArrayImgs; import net.imglib2.loops.LoopBuilder; import net.imglib2.type.logic.BitType; -import net.imglib2.type.numeric.complex.ComplexDoubleType; -import net.imglib2.type.numeric.complex.ComplexFloatType; import net.imglib2.type.numeric.integer.*; import net.imglib2.type.numeric.real.DoubleType; import net.imglib2.type.numeric.real.FloatType; @@ -52,7 +50,9 @@ public class RAIConvertersTest extends AbstractOpTest { * @param out the output image * @implNote op names='test.convert.image.BitType', type='Computer' */ - public static void computeBitType(RandomAccessibleInterval out) { + public static void computeBitType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -70,7 +70,9 @@ public void testConvertBitTypeImage() { * @param out the output image * @implNote op names='test.convert.image.Unsigned2BitType', type='Computer' */ - public static void computeUnsigned2BitType(RandomAccessibleInterval out) { + public static void computeUnsigned2BitType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -88,7 +90,9 @@ public void testConvertUnsigned2BitTypeImage() { * @param out the output image * @implNote op names='test.convert.image.Unsigned4BitType', type='Computer' */ - public static void computeUnsigned4BitType(RandomAccessibleInterval out) { + public static void computeUnsigned4BitType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -106,7 +110,9 @@ public void testConvertUnsigned4BitTypeImage() { * @param out the output image * @implNote op names='test.convert.image.UnsignedByteType', type='Computer' */ - public static void computeUnsignedByteType(RandomAccessibleInterval out) { + public static void computeUnsignedByteType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -124,7 +130,9 @@ public void testConvertUnsignedByteTypeImage() { * @param out the output image * @implNote op names='test.convert.image.ByteType', type='Computer' */ - public static void computeByteType(RandomAccessibleInterval out) { + public static void computeByteType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -142,7 +150,9 @@ public void testConvertByteTypeImage() { * @param out the output image * @implNote op names='test.convert.image.UnsignedShortType', type='Computer' */ - public static void computeUnsignedShortType(RandomAccessibleInterval out) { + public static void computeUnsignedShortType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -160,7 +170,9 @@ public void testConvertUnsignedShortTypeImage() { * @param out the output image * @implNote op names='test.convert.image.ShortType', type='Computer' */ - public static void computeShortType(RandomAccessibleInterval out) { + public static void computeShortType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -178,7 +190,9 @@ public void testConvertShortTypeImage() { * @param out the output image * @implNote op names='test.convert.image.Unsigned12BitType', type='Computer' */ - public static void computeUnsigned12BitType(RandomAccessibleInterval out) { + public static void computeUnsigned12BitType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -196,7 +210,9 @@ public void testConvertUnsigned12BitTypeImage() { * @param out the output image * @implNote op names='test.convert.image.UnsignedIntType', type='Computer' */ - public static void computeUnsignedIntType(RandomAccessibleInterval out) { + public static void computeUnsignedIntType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -214,7 +230,9 @@ public void testConvertUnsignedIntTypeImage() { * @param out the output image * @implNote op names='test.convert.image.IntType', type='Computer' */ - public static void computeIntType(RandomAccessibleInterval out) { + public static void computeIntType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -232,7 +250,9 @@ public void testConvertIntTypeImage() { * @param out the output image * @implNote op names='test.convert.image.UnsignedLongType', type='Computer' */ - public static void computeUnsignedLongType(RandomAccessibleInterval out) { + public static void computeUnsignedLongType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -250,7 +270,9 @@ public void testConvertUnsignedLongTypeImage() { * @param out the output image * @implNote op names='test.convert.image.LongType', type='Computer' */ - public static void computeLongType(RandomAccessibleInterval out) { + public static void computeLongType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -268,7 +290,9 @@ public void testConvertLongTypeImage() { * @param out the output image * @implNote op names='test.convert.image.Unsigned128BitType', type='Computer' */ - public static void computeUnsigned128BitType(RandomAccessibleInterval out) { + public static void computeUnsigned128BitType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -286,7 +310,9 @@ public void testConvertUnsigned128BitTypeImage() { * @param out the output image * @implNote op names='test.convert.image.FloatType', type='Computer' */ - public static void computeFloatType(RandomAccessibleInterval out) { + public static void computeFloatType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @@ -304,7 +330,9 @@ public void testConvertFloatTypeImage() { * @param out the output image * @implNote op names='test.convert.image.DoubleType', type='Computer' */ - public static void computeDoubleType(RandomAccessibleInterval out) { + public static void computeDoubleType( + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } diff --git a/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/TestConvertImages.java b/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/TestConvertImages.java index 56de1bc04..45bde822c 100644 --- a/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/TestConvertImages.java +++ b/scijava-ops-image/src/test/java/org/scijava/ops/image/convert/TestConvertImages.java @@ -37,7 +37,6 @@ import java.math.BigInteger; -import org.scijava.ops.image.AbstractOpTest; import net.imglib2.FinalDimensions; import net.imglib2.IterableInterval; import net.imglib2.type.logic.BitType; @@ -58,6 +57,7 @@ import net.imglib2.type.numeric.real.DoubleType; import net.imglib2.type.numeric.real.FloatType; import org.junit.jupiter.api.Test; +import org.scijava.ops.image.AbstractOpTest; /** * Tests the {@link ConvertComplexTypes} ops. @@ -74,6 +74,7 @@ public class TestConvertImages extends AbstractOpTest{ private final BigInteger n128 = new BigInteger("-482301498A285BFD0982EE7DE02398BC9080459284CCDE90E9F0D00C043981210481AAADEF2", 16); /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testBitToBit() { @@ -84,13 +85,13 @@ public void testBitToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -101,6 +102,7 @@ public void testBitToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToBit() { @@ -111,13 +113,13 @@ public void testUint2ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -128,6 +130,7 @@ public void testUint2ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToBit() { @@ -138,13 +141,13 @@ public void testUint4ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -155,6 +158,7 @@ public void testUint4ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToBit() { @@ -165,13 +169,13 @@ public void testInt8ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -179,7 +183,7 @@ public void testInt8ToBit() { assertEquals(Types.bit((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -190,6 +194,7 @@ public void testInt8ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToBit() { @@ -200,13 +205,13 @@ public void testUint8ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -217,6 +222,7 @@ public void testUint8ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToBit() { @@ -227,13 +233,13 @@ public void testUint12ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -244,6 +250,7 @@ public void testUint12ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToBit() { @@ -254,13 +261,13 @@ public void testInt16ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -268,7 +275,7 @@ public void testInt16ToBit() { assertEquals(Types.bit((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -279,6 +286,7 @@ public void testInt16ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToBit() { @@ -289,13 +297,13 @@ public void testUint16ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -306,6 +314,7 @@ public void testUint16ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToBit() { @@ -316,13 +325,13 @@ public void testInt32ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -330,7 +339,7 @@ public void testInt32ToBit() { assertEquals(Types.bit(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -341,6 +350,7 @@ public void testInt32ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToBit() { @@ -351,13 +361,13 @@ public void testUint32ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -368,6 +378,7 @@ public void testUint32ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToBit() { @@ -378,13 +389,13 @@ public void testInt64ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -392,7 +403,7 @@ public void testInt64ToBit() { assertEquals(Types.bit(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -403,6 +414,7 @@ public void testInt64ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToBit() { @@ -413,13 +425,13 @@ public void testUint64ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -427,7 +439,7 @@ public void testUint64ToBit() { assertEquals(Types.bit(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -438,6 +450,7 @@ public void testUint64ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToBit() { @@ -448,13 +461,13 @@ public void testUint128ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -462,7 +475,7 @@ public void testUint128ToBit() { assertEquals(Types.bit(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -473,6 +486,7 @@ public void testUint128ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToBit() { @@ -483,13 +497,13 @@ public void testFloat32ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -497,7 +511,7 @@ public void testFloat32ToBit() { assertEquals(Types.bit(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -508,6 +522,7 @@ public void testFloat32ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToBit() { @@ -518,13 +533,13 @@ public void testCfloat32ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -532,7 +547,7 @@ public void testCfloat32ToBit() { assertEquals(Types.bit(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -543,6 +558,7 @@ public void testCfloat32ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToBit() { @@ -553,13 +569,13 @@ public void testFloat64ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -567,7 +583,7 @@ public void testFloat64ToBit() { assertEquals(Types.bit(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -575,7 +591,7 @@ public void testFloat64ToBit() { assertEquals(Types.bit(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -586,6 +602,7 @@ public void testFloat64ToBit() { } /** Tests {@link ConvertComplexTypes#integerToBit}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToBit() { @@ -596,13 +613,13 @@ public void testCfloat64ToBit() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.bit").input(img).apply(); + var converted = ops.op("convert.bit").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.bit(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -610,7 +627,7 @@ public void testCfloat64ToBit() { assertEquals(Types.bit(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.bit").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -621,6 +638,7 @@ public void testCfloat64ToBit() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testBitToUint2() { @@ -631,13 +649,13 @@ public void testBitToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -648,6 +666,7 @@ public void testBitToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToUint2() { @@ -658,13 +677,13 @@ public void testUint2ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -675,6 +694,7 @@ public void testUint2ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToUint2() { @@ -685,13 +705,13 @@ public void testUint4ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -702,6 +722,7 @@ public void testUint4ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToUint2() { @@ -712,13 +733,13 @@ public void testInt8ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -726,7 +747,7 @@ public void testInt8ToUint2() { assertEquals(Types.uint2((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -737,6 +758,7 @@ public void testInt8ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToUint2() { @@ -747,13 +769,13 @@ public void testUint8ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -764,6 +786,7 @@ public void testUint8ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToUint2() { @@ -774,13 +797,13 @@ public void testUint12ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -791,6 +814,7 @@ public void testUint12ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToUint2() { @@ -801,13 +825,13 @@ public void testInt16ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -815,7 +839,7 @@ public void testInt16ToUint2() { assertEquals(Types.uint2((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -826,6 +850,7 @@ public void testInt16ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToUint2() { @@ -836,13 +861,13 @@ public void testUint16ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -853,6 +878,7 @@ public void testUint16ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToUint2() { @@ -863,13 +889,13 @@ public void testInt32ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -877,7 +903,7 @@ public void testInt32ToUint2() { assertEquals(Types.uint2(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -888,6 +914,7 @@ public void testInt32ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToUint2() { @@ -898,13 +925,13 @@ public void testUint32ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -915,6 +942,7 @@ public void testUint32ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToUint2() { @@ -925,13 +953,13 @@ public void testInt64ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -939,7 +967,7 @@ public void testInt64ToUint2() { assertEquals(Types.uint2(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -950,6 +978,7 @@ public void testInt64ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToUint2() { @@ -960,13 +989,13 @@ public void testUint64ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -974,7 +1003,7 @@ public void testUint64ToUint2() { assertEquals(Types.uint2(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -985,6 +1014,7 @@ public void testUint64ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToUint2() { @@ -995,13 +1025,13 @@ public void testUint128ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1009,7 +1039,7 @@ public void testUint128ToUint2() { assertEquals(Types.uint2(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1020,6 +1050,7 @@ public void testUint128ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToUint2() { @@ -1030,13 +1061,13 @@ public void testFloat32ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1044,7 +1075,7 @@ public void testFloat32ToUint2() { assertEquals(Types.uint2(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1055,6 +1086,7 @@ public void testFloat32ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToUint2() { @@ -1065,13 +1097,13 @@ public void testCfloat32ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1079,7 +1111,7 @@ public void testCfloat32ToUint2() { assertEquals(Types.uint2(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1090,6 +1122,7 @@ public void testCfloat32ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToUint2() { @@ -1100,13 +1133,13 @@ public void testFloat64ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1114,7 +1147,7 @@ public void testFloat64ToUint2() { assertEquals(Types.uint2(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1122,7 +1155,7 @@ public void testFloat64ToUint2() { assertEquals(Types.uint2(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1133,6 +1166,7 @@ public void testFloat64ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint2}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToUint2() { @@ -1143,13 +1177,13 @@ public void testCfloat64ToUint2() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint2").input(img).apply(); + var converted = ops.op("convert.uint2").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint2(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1157,7 +1191,7 @@ public void testCfloat64ToUint2() { assertEquals(Types.uint2(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint2").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1168,6 +1202,7 @@ public void testCfloat64ToUint2() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testBitToUint4() { @@ -1178,13 +1213,13 @@ public void testBitToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1195,6 +1230,7 @@ public void testBitToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToUint4() { @@ -1205,13 +1241,13 @@ public void testUint2ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1222,6 +1258,7 @@ public void testUint2ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToUint4() { @@ -1232,13 +1269,13 @@ public void testUint4ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1249,6 +1286,7 @@ public void testUint4ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToUint4() { @@ -1259,13 +1297,13 @@ public void testInt8ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1273,7 +1311,7 @@ public void testInt8ToUint4() { assertEquals(Types.uint4((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1284,6 +1322,7 @@ public void testInt8ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToUint4() { @@ -1294,13 +1333,13 @@ public void testUint8ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1311,6 +1350,7 @@ public void testUint8ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToUint4() { @@ -1321,13 +1361,13 @@ public void testUint12ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1338,6 +1378,7 @@ public void testUint12ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToUint4() { @@ -1348,13 +1389,13 @@ public void testInt16ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1362,7 +1403,7 @@ public void testInt16ToUint4() { assertEquals(Types.uint4((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1373,6 +1414,7 @@ public void testInt16ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToUint4() { @@ -1383,13 +1425,13 @@ public void testUint16ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1400,6 +1442,7 @@ public void testUint16ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToUint4() { @@ -1410,13 +1453,13 @@ public void testInt32ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1424,7 +1467,7 @@ public void testInt32ToUint4() { assertEquals(Types.uint4(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1435,6 +1478,7 @@ public void testInt32ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToUint4() { @@ -1445,13 +1489,13 @@ public void testUint32ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1462,6 +1506,7 @@ public void testUint32ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToUint4() { @@ -1472,13 +1517,13 @@ public void testInt64ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1486,7 +1531,7 @@ public void testInt64ToUint4() { assertEquals(Types.uint4(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1497,6 +1542,7 @@ public void testInt64ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToUint4() { @@ -1507,13 +1553,13 @@ public void testUint64ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1521,7 +1567,7 @@ public void testUint64ToUint4() { assertEquals(Types.uint4(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1532,6 +1578,7 @@ public void testUint64ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToUint4() { @@ -1542,13 +1589,13 @@ public void testUint128ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1556,7 +1603,7 @@ public void testUint128ToUint4() { assertEquals(Types.uint4(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1567,6 +1614,7 @@ public void testUint128ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToUint4() { @@ -1577,13 +1625,13 @@ public void testFloat32ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1591,7 +1639,7 @@ public void testFloat32ToUint4() { assertEquals(Types.uint4(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1602,6 +1650,7 @@ public void testFloat32ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToUint4() { @@ -1612,13 +1661,13 @@ public void testCfloat32ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1626,7 +1675,7 @@ public void testCfloat32ToUint4() { assertEquals(Types.uint4(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1637,6 +1686,7 @@ public void testCfloat32ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToUint4() { @@ -1647,13 +1697,13 @@ public void testFloat64ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1661,7 +1711,7 @@ public void testFloat64ToUint4() { assertEquals(Types.uint4(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1669,7 +1719,7 @@ public void testFloat64ToUint4() { assertEquals(Types.uint4(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1680,6 +1730,7 @@ public void testFloat64ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToUint4}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToUint4() { @@ -1690,13 +1741,13 @@ public void testCfloat64ToUint4() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint4").input(img).apply(); + var converted = ops.op("convert.uint4").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint4(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1704,7 +1755,7 @@ public void testCfloat64ToUint4() { assertEquals(Types.uint4(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint4").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1715,6 +1766,7 @@ public void testCfloat64ToUint4() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testBitToInt8() { @@ -1725,13 +1777,13 @@ public void testBitToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1742,6 +1794,7 @@ public void testBitToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToInt8() { @@ -1752,13 +1805,13 @@ public void testUint2ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1769,6 +1822,7 @@ public void testUint2ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToInt8() { @@ -1779,13 +1833,13 @@ public void testUint4ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1796,6 +1850,7 @@ public void testUint4ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToInt8() { @@ -1806,13 +1861,13 @@ public void testInt8ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1820,7 +1875,7 @@ public void testInt8ToInt8() { assertEquals(Types.int8((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1831,6 +1886,7 @@ public void testInt8ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToInt8() { @@ -1841,13 +1897,13 @@ public void testUint8ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1858,6 +1914,7 @@ public void testUint8ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToInt8() { @@ -1868,13 +1925,13 @@ public void testUint12ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1885,6 +1942,7 @@ public void testUint12ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToInt8() { @@ -1895,13 +1953,13 @@ public void testInt16ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1909,7 +1967,7 @@ public void testInt16ToInt8() { assertEquals(Types.int8((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1920,6 +1978,7 @@ public void testInt16ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToInt8() { @@ -1930,13 +1989,13 @@ public void testUint16ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1947,6 +2006,7 @@ public void testUint16ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToInt8() { @@ -1957,13 +2017,13 @@ public void testInt32ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1971,7 +2031,7 @@ public void testInt32ToInt8() { assertEquals(Types.int8(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -1982,6 +2042,7 @@ public void testInt32ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToInt8() { @@ -1992,13 +2053,13 @@ public void testUint32ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2009,6 +2070,7 @@ public void testUint32ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToInt8() { @@ -2019,13 +2081,13 @@ public void testInt64ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2033,7 +2095,7 @@ public void testInt64ToInt8() { assertEquals(Types.int8(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2044,6 +2106,7 @@ public void testInt64ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToInt8() { @@ -2054,13 +2117,13 @@ public void testUint64ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2068,7 +2131,7 @@ public void testUint64ToInt8() { assertEquals(Types.int8(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2079,6 +2142,7 @@ public void testUint64ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToInt8() { @@ -2089,13 +2153,13 @@ public void testUint128ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2103,7 +2167,7 @@ public void testUint128ToInt8() { assertEquals(Types.int8(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2114,6 +2178,7 @@ public void testUint128ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToInt8() { @@ -2124,13 +2189,13 @@ public void testFloat32ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2138,7 +2203,7 @@ public void testFloat32ToInt8() { assertEquals(Types.int8(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2149,6 +2214,7 @@ public void testFloat32ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToInt8() { @@ -2159,13 +2225,13 @@ public void testCfloat32ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2173,7 +2239,7 @@ public void testCfloat32ToInt8() { assertEquals(Types.int8(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2184,6 +2250,7 @@ public void testCfloat32ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToInt8() { @@ -2194,13 +2261,13 @@ public void testFloat64ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2208,7 +2275,7 @@ public void testFloat64ToInt8() { assertEquals(Types.int8(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2216,7 +2283,7 @@ public void testFloat64ToInt8() { assertEquals(Types.int8(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2227,6 +2294,7 @@ public void testFloat64ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToInt8}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToInt8() { @@ -2237,13 +2305,13 @@ public void testCfloat64ToInt8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int8").input(img).apply(); + var converted = ops.op("convert.int8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int8(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2251,7 +2319,7 @@ public void testCfloat64ToInt8() { assertEquals(Types.int8(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2262,6 +2330,7 @@ public void testCfloat64ToInt8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testBitToUint8() { @@ -2272,13 +2341,13 @@ public void testBitToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2289,6 +2358,7 @@ public void testBitToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToUint8() { @@ -2299,13 +2369,13 @@ public void testUint2ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2316,6 +2386,7 @@ public void testUint2ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToUint8() { @@ -2326,13 +2397,13 @@ public void testUint4ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2343,6 +2414,7 @@ public void testUint4ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToUint8() { @@ -2353,13 +2425,13 @@ public void testInt8ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2367,7 +2439,7 @@ public void testInt8ToUint8() { assertEquals(Types.uint8((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2378,6 +2450,7 @@ public void testInt8ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToUint8() { @@ -2388,13 +2461,13 @@ public void testUint8ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2405,6 +2478,7 @@ public void testUint8ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToUint8() { @@ -2415,13 +2489,13 @@ public void testUint12ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2432,6 +2506,7 @@ public void testUint12ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToUint8() { @@ -2442,13 +2517,13 @@ public void testInt16ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2456,7 +2531,7 @@ public void testInt16ToUint8() { assertEquals(Types.uint8((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2467,6 +2542,7 @@ public void testInt16ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToUint8() { @@ -2477,13 +2553,13 @@ public void testUint16ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2494,6 +2570,7 @@ public void testUint16ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToUint8() { @@ -2504,13 +2581,13 @@ public void testInt32ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2518,7 +2595,7 @@ public void testInt32ToUint8() { assertEquals(Types.uint8(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2529,6 +2606,7 @@ public void testInt32ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToUint8() { @@ -2539,13 +2617,13 @@ public void testUint32ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2556,6 +2634,7 @@ public void testUint32ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToUint8() { @@ -2566,13 +2645,13 @@ public void testInt64ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2580,7 +2659,7 @@ public void testInt64ToUint8() { assertEquals(Types.uint8(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2591,6 +2670,7 @@ public void testInt64ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToUint8() { @@ -2601,13 +2681,13 @@ public void testUint64ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2615,7 +2695,7 @@ public void testUint64ToUint8() { assertEquals(Types.uint8(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2626,6 +2706,7 @@ public void testUint64ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToUint8() { @@ -2636,13 +2717,13 @@ public void testUint128ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2650,7 +2731,7 @@ public void testUint128ToUint8() { assertEquals(Types.uint8(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2661,6 +2742,7 @@ public void testUint128ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToUint8() { @@ -2671,13 +2753,13 @@ public void testFloat32ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2685,7 +2767,7 @@ public void testFloat32ToUint8() { assertEquals(Types.uint8(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2696,6 +2778,7 @@ public void testFloat32ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToUint8() { @@ -2706,13 +2789,13 @@ public void testCfloat32ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2720,7 +2803,7 @@ public void testCfloat32ToUint8() { assertEquals(Types.uint8(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2731,6 +2814,7 @@ public void testCfloat32ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToUint8() { @@ -2741,13 +2825,13 @@ public void testFloat64ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2755,7 +2839,7 @@ public void testFloat64ToUint8() { assertEquals(Types.uint8(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2763,7 +2847,7 @@ public void testFloat64ToUint8() { assertEquals(Types.uint8(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2774,6 +2858,7 @@ public void testFloat64ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint8}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToUint8() { @@ -2784,13 +2869,13 @@ public void testCfloat64ToUint8() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint8").input(img).apply(); + var converted = ops.op("convert.uint8").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint8(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2798,7 +2883,7 @@ public void testCfloat64ToUint8() { assertEquals(Types.uint8(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint8").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2809,6 +2894,7 @@ public void testCfloat64ToUint8() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testBitToUint12() { @@ -2819,13 +2905,13 @@ public void testBitToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2836,6 +2922,7 @@ public void testBitToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToUint12() { @@ -2846,13 +2933,13 @@ public void testUint2ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2863,6 +2950,7 @@ public void testUint2ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToUint12() { @@ -2873,13 +2961,13 @@ public void testUint4ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2890,6 +2978,7 @@ public void testUint4ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToUint12() { @@ -2900,13 +2989,13 @@ public void testInt8ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2914,7 +3003,7 @@ public void testInt8ToUint12() { assertEquals(Types.uint12((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2925,6 +3014,7 @@ public void testInt8ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToUint12() { @@ -2935,13 +3025,13 @@ public void testUint8ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2952,6 +3042,7 @@ public void testUint8ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToUint12() { @@ -2962,13 +3053,13 @@ public void testUint12ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -2979,6 +3070,7 @@ public void testUint12ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToUint12() { @@ -2989,13 +3081,13 @@ public void testInt16ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3003,7 +3095,7 @@ public void testInt16ToUint12() { assertEquals(Types.uint12((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3014,6 +3106,7 @@ public void testInt16ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToUint12() { @@ -3024,13 +3117,13 @@ public void testUint16ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3041,6 +3134,7 @@ public void testUint16ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToUint12() { @@ -3051,13 +3145,13 @@ public void testInt32ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3065,7 +3159,7 @@ public void testInt32ToUint12() { assertEquals(Types.uint12(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3076,6 +3170,7 @@ public void testInt32ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToUint12() { @@ -3086,13 +3181,13 @@ public void testUint32ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3103,6 +3198,7 @@ public void testUint32ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToUint12() { @@ -3113,13 +3209,13 @@ public void testInt64ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3127,7 +3223,7 @@ public void testInt64ToUint12() { assertEquals(Types.uint12(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3138,6 +3234,7 @@ public void testInt64ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToUint12() { @@ -3148,13 +3245,13 @@ public void testUint64ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3162,7 +3259,7 @@ public void testUint64ToUint12() { assertEquals(Types.uint12(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3173,6 +3270,7 @@ public void testUint64ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToUint12() { @@ -3183,13 +3281,13 @@ public void testUint128ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3197,7 +3295,7 @@ public void testUint128ToUint12() { assertEquals(Types.uint12(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3208,6 +3306,7 @@ public void testUint128ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToUint12() { @@ -3218,13 +3317,13 @@ public void testFloat32ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3232,7 +3331,7 @@ public void testFloat32ToUint12() { assertEquals(Types.uint12(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3243,6 +3342,7 @@ public void testFloat32ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToUint12() { @@ -3253,13 +3353,13 @@ public void testCfloat32ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3267,7 +3367,7 @@ public void testCfloat32ToUint12() { assertEquals(Types.uint12(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3278,6 +3378,7 @@ public void testCfloat32ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToUint12() { @@ -3288,13 +3389,13 @@ public void testFloat64ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3302,7 +3403,7 @@ public void testFloat64ToUint12() { assertEquals(Types.uint12(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3310,7 +3411,7 @@ public void testFloat64ToUint12() { assertEquals(Types.uint12(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3321,6 +3422,7 @@ public void testFloat64ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToUint12}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToUint12() { @@ -3331,13 +3433,13 @@ public void testCfloat64ToUint12() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint12").input(img).apply(); + var converted = ops.op("convert.uint12").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint12(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3345,7 +3447,7 @@ public void testCfloat64ToUint12() { assertEquals(Types.uint12(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint12").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3356,6 +3458,7 @@ public void testCfloat64ToUint12() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testBitToInt16() { @@ -3366,13 +3469,13 @@ public void testBitToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3383,6 +3486,7 @@ public void testBitToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToInt16() { @@ -3393,13 +3497,13 @@ public void testUint2ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3410,6 +3514,7 @@ public void testUint2ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToInt16() { @@ -3420,13 +3525,13 @@ public void testUint4ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3437,6 +3542,7 @@ public void testUint4ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToInt16() { @@ -3447,13 +3553,13 @@ public void testInt8ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3461,7 +3567,7 @@ public void testInt8ToInt16() { assertEquals(Types.int16((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3472,6 +3578,7 @@ public void testInt8ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToInt16() { @@ -3482,13 +3589,13 @@ public void testUint8ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3499,6 +3606,7 @@ public void testUint8ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToInt16() { @@ -3509,13 +3617,13 @@ public void testUint12ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3526,6 +3634,7 @@ public void testUint12ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToInt16() { @@ -3536,13 +3645,13 @@ public void testInt16ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3550,7 +3659,7 @@ public void testInt16ToInt16() { assertEquals(Types.int16((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3561,6 +3670,7 @@ public void testInt16ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToInt16() { @@ -3571,13 +3681,13 @@ public void testUint16ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3588,6 +3698,7 @@ public void testUint16ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToInt16() { @@ -3598,13 +3709,13 @@ public void testInt32ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3612,7 +3723,7 @@ public void testInt32ToInt16() { assertEquals(Types.int16(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3623,6 +3734,7 @@ public void testInt32ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToInt16() { @@ -3633,13 +3745,13 @@ public void testUint32ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3650,6 +3762,7 @@ public void testUint32ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToInt16() { @@ -3660,13 +3773,13 @@ public void testInt64ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3674,7 +3787,7 @@ public void testInt64ToInt16() { assertEquals(Types.int16(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3685,6 +3798,7 @@ public void testInt64ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToInt16() { @@ -3695,13 +3809,13 @@ public void testUint64ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3709,7 +3823,7 @@ public void testUint64ToInt16() { assertEquals(Types.int16(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3720,6 +3834,7 @@ public void testUint64ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToInt16() { @@ -3730,13 +3845,13 @@ public void testUint128ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3744,7 +3859,7 @@ public void testUint128ToInt16() { assertEquals(Types.int16(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3755,6 +3870,7 @@ public void testUint128ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToInt16() { @@ -3765,13 +3881,13 @@ public void testFloat32ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3779,7 +3895,7 @@ public void testFloat32ToInt16() { assertEquals(Types.int16(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3790,6 +3906,7 @@ public void testFloat32ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToInt16() { @@ -3800,13 +3917,13 @@ public void testCfloat32ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3814,7 +3931,7 @@ public void testCfloat32ToInt16() { assertEquals(Types.int16(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3825,6 +3942,7 @@ public void testCfloat32ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToInt16() { @@ -3835,13 +3953,13 @@ public void testFloat64ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3849,7 +3967,7 @@ public void testFloat64ToInt16() { assertEquals(Types.int16(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3857,7 +3975,7 @@ public void testFloat64ToInt16() { assertEquals(Types.int16(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3868,6 +3986,7 @@ public void testFloat64ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToInt16}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToInt16() { @@ -3878,13 +3997,13 @@ public void testCfloat64ToInt16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int16").input(img).apply(); + var converted = ops.op("convert.int16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int16(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3892,7 +4011,7 @@ public void testCfloat64ToInt16() { assertEquals(Types.int16(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3903,6 +4022,7 @@ public void testCfloat64ToInt16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testBitToUint16() { @@ -3913,13 +4033,13 @@ public void testBitToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3930,6 +4050,7 @@ public void testBitToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToUint16() { @@ -3940,13 +4061,13 @@ public void testUint2ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3957,6 +4078,7 @@ public void testUint2ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToUint16() { @@ -3967,13 +4089,13 @@ public void testUint4ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -3984,6 +4106,7 @@ public void testUint4ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToUint16() { @@ -3994,13 +4117,13 @@ public void testInt8ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4008,7 +4131,7 @@ public void testInt8ToUint16() { assertEquals(Types.uint16((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4019,6 +4142,7 @@ public void testInt8ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToUint16() { @@ -4029,13 +4153,13 @@ public void testUint8ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4046,6 +4170,7 @@ public void testUint8ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToUint16() { @@ -4056,13 +4181,13 @@ public void testUint12ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4073,6 +4198,7 @@ public void testUint12ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToUint16() { @@ -4083,13 +4209,13 @@ public void testInt16ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4097,7 +4223,7 @@ public void testInt16ToUint16() { assertEquals(Types.uint16((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4108,6 +4234,7 @@ public void testInt16ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToUint16() { @@ -4118,13 +4245,13 @@ public void testUint16ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4135,6 +4262,7 @@ public void testUint16ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToUint16() { @@ -4145,13 +4273,13 @@ public void testInt32ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4159,7 +4287,7 @@ public void testInt32ToUint16() { assertEquals(Types.uint16(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4170,6 +4298,7 @@ public void testInt32ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToUint16() { @@ -4180,13 +4309,13 @@ public void testUint32ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4197,6 +4326,7 @@ public void testUint32ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToUint16() { @@ -4207,13 +4337,13 @@ public void testInt64ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4221,7 +4351,7 @@ public void testInt64ToUint16() { assertEquals(Types.uint16(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4232,6 +4362,7 @@ public void testInt64ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToUint16() { @@ -4242,13 +4373,13 @@ public void testUint64ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4256,7 +4387,7 @@ public void testUint64ToUint16() { assertEquals(Types.uint16(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4267,6 +4398,7 @@ public void testUint64ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToUint16() { @@ -4277,13 +4409,13 @@ public void testUint128ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4291,7 +4423,7 @@ public void testUint128ToUint16() { assertEquals(Types.uint16(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4302,6 +4434,7 @@ public void testUint128ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToUint16() { @@ -4312,13 +4445,13 @@ public void testFloat32ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4326,7 +4459,7 @@ public void testFloat32ToUint16() { assertEquals(Types.uint16(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4337,6 +4470,7 @@ public void testFloat32ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToUint16() { @@ -4347,13 +4481,13 @@ public void testCfloat32ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4361,7 +4495,7 @@ public void testCfloat32ToUint16() { assertEquals(Types.uint16(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4372,6 +4506,7 @@ public void testCfloat32ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToUint16() { @@ -4382,13 +4517,13 @@ public void testFloat64ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4396,7 +4531,7 @@ public void testFloat64ToUint16() { assertEquals(Types.uint16(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4404,7 +4539,7 @@ public void testFloat64ToUint16() { assertEquals(Types.uint16(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4415,6 +4550,7 @@ public void testFloat64ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToUint16}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToUint16() { @@ -4425,13 +4561,13 @@ public void testCfloat64ToUint16() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint16").input(img).apply(); + var converted = ops.op("convert.uint16").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint16(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4439,7 +4575,7 @@ public void testCfloat64ToUint16() { assertEquals(Types.uint16(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint16").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4450,6 +4586,7 @@ public void testCfloat64ToUint16() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testBitToInt32() { @@ -4460,13 +4597,13 @@ public void testBitToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4477,6 +4614,7 @@ public void testBitToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToInt32() { @@ -4487,13 +4625,13 @@ public void testUint2ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4504,6 +4642,7 @@ public void testUint2ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToInt32() { @@ -4514,13 +4653,13 @@ public void testUint4ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4531,6 +4670,7 @@ public void testUint4ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToInt32() { @@ -4541,13 +4681,13 @@ public void testInt8ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4555,7 +4695,7 @@ public void testInt8ToInt32() { assertEquals(Types.int32((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4566,6 +4706,7 @@ public void testInt8ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToInt32() { @@ -4576,13 +4717,13 @@ public void testUint8ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4593,6 +4734,7 @@ public void testUint8ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToInt32() { @@ -4603,13 +4745,13 @@ public void testUint12ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4620,6 +4762,7 @@ public void testUint12ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToInt32() { @@ -4630,13 +4773,13 @@ public void testInt16ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4644,7 +4787,7 @@ public void testInt16ToInt32() { assertEquals(Types.int32((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4655,6 +4798,7 @@ public void testInt16ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToInt32() { @@ -4665,13 +4809,13 @@ public void testUint16ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4682,6 +4826,7 @@ public void testUint16ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToInt32() { @@ -4692,13 +4837,13 @@ public void testInt32ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4706,7 +4851,7 @@ public void testInt32ToInt32() { assertEquals(Types.int32(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4717,6 +4862,7 @@ public void testInt32ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToInt32() { @@ -4727,13 +4873,13 @@ public void testUint32ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4744,6 +4890,7 @@ public void testUint32ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToInt32() { @@ -4754,13 +4901,13 @@ public void testInt64ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4768,7 +4915,7 @@ public void testInt64ToInt32() { assertEquals(Types.int32(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4779,6 +4926,7 @@ public void testInt64ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToInt32() { @@ -4789,13 +4937,13 @@ public void testUint64ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4803,7 +4951,7 @@ public void testUint64ToInt32() { assertEquals(Types.int32(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4814,6 +4962,7 @@ public void testUint64ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToInt32() { @@ -4824,13 +4973,13 @@ public void testUint128ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4838,7 +4987,7 @@ public void testUint128ToInt32() { assertEquals(Types.int32(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4849,6 +4998,7 @@ public void testUint128ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToInt32() { @@ -4859,13 +5009,13 @@ public void testFloat32ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4873,7 +5023,7 @@ public void testFloat32ToInt32() { assertEquals(Types.int32(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4884,6 +5034,7 @@ public void testFloat32ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToInt32() { @@ -4894,13 +5045,13 @@ public void testCfloat32ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4908,7 +5059,7 @@ public void testCfloat32ToInt32() { assertEquals(Types.int32(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4919,6 +5070,7 @@ public void testCfloat32ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToInt32() { @@ -4929,13 +5081,13 @@ public void testFloat64ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4943,7 +5095,7 @@ public void testFloat64ToInt32() { assertEquals(Types.int32(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4951,7 +5103,7 @@ public void testFloat64ToInt32() { assertEquals(Types.int32(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4962,6 +5114,7 @@ public void testFloat64ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToInt32}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToInt32() { @@ -4972,13 +5125,13 @@ public void testCfloat64ToInt32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int32").input(img).apply(); + var converted = ops.op("convert.int32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int32(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4986,7 +5139,7 @@ public void testCfloat64ToInt32() { assertEquals(Types.int32(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -4997,6 +5150,7 @@ public void testCfloat64ToInt32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testBitToUint32() { @@ -5007,13 +5161,13 @@ public void testBitToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5024,6 +5178,7 @@ public void testBitToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToUint32() { @@ -5034,13 +5189,13 @@ public void testUint2ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5051,6 +5206,7 @@ public void testUint2ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToUint32() { @@ -5061,13 +5217,13 @@ public void testUint4ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5078,6 +5234,7 @@ public void testUint4ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToUint32() { @@ -5088,13 +5245,13 @@ public void testInt8ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5102,7 +5259,7 @@ public void testInt8ToUint32() { assertEquals(Types.uint32((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5113,6 +5270,7 @@ public void testInt8ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToUint32() { @@ -5123,13 +5281,13 @@ public void testUint8ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5140,6 +5298,7 @@ public void testUint8ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToUint32() { @@ -5150,13 +5309,13 @@ public void testUint12ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5167,6 +5326,7 @@ public void testUint12ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToUint32() { @@ -5177,13 +5337,13 @@ public void testInt16ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5191,7 +5351,7 @@ public void testInt16ToUint32() { assertEquals(Types.uint32((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5202,6 +5362,7 @@ public void testInt16ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToUint32() { @@ -5212,13 +5373,13 @@ public void testUint16ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5229,6 +5390,7 @@ public void testUint16ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToUint32() { @@ -5239,13 +5401,13 @@ public void testInt32ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5253,7 +5415,7 @@ public void testInt32ToUint32() { assertEquals(Types.uint32(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5264,6 +5426,7 @@ public void testInt32ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToUint32() { @@ -5274,13 +5437,13 @@ public void testUint32ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5291,6 +5454,7 @@ public void testUint32ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToUint32() { @@ -5301,13 +5465,13 @@ public void testInt64ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5315,7 +5479,7 @@ public void testInt64ToUint32() { assertEquals(Types.uint32(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5326,6 +5490,7 @@ public void testInt64ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToUint32() { @@ -5336,13 +5501,13 @@ public void testUint64ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5350,7 +5515,7 @@ public void testUint64ToUint32() { assertEquals(Types.uint32(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5361,6 +5526,7 @@ public void testUint64ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToUint32() { @@ -5371,13 +5537,13 @@ public void testUint128ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5385,7 +5551,7 @@ public void testUint128ToUint32() { assertEquals(Types.uint32(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5396,6 +5562,7 @@ public void testUint128ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToUint32() { @@ -5406,13 +5573,13 @@ public void testFloat32ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5420,7 +5587,7 @@ public void testFloat32ToUint32() { assertEquals(Types.uint32(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5431,6 +5598,7 @@ public void testFloat32ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToUint32() { @@ -5441,13 +5609,13 @@ public void testCfloat32ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5455,7 +5623,7 @@ public void testCfloat32ToUint32() { assertEquals(Types.uint32(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5466,6 +5634,7 @@ public void testCfloat32ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToUint32() { @@ -5476,13 +5645,13 @@ public void testFloat64ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5490,7 +5659,7 @@ public void testFloat64ToUint32() { assertEquals(Types.uint32(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5498,7 +5667,7 @@ public void testFloat64ToUint32() { assertEquals(Types.uint32(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5509,6 +5678,7 @@ public void testFloat64ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToUint32}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToUint32() { @@ -5519,13 +5689,13 @@ public void testCfloat64ToUint32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint32").input(img).apply(); + var converted = ops.op("convert.uint32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint32(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5533,7 +5703,7 @@ public void testCfloat64ToUint32() { assertEquals(Types.uint32(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5544,6 +5714,7 @@ public void testCfloat64ToUint32() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testBitToInt64() { @@ -5554,13 +5725,13 @@ public void testBitToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5571,6 +5742,7 @@ public void testBitToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToInt64() { @@ -5581,13 +5753,13 @@ public void testUint2ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5598,6 +5770,7 @@ public void testUint2ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToInt64() { @@ -5608,13 +5781,13 @@ public void testUint4ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5625,6 +5798,7 @@ public void testUint4ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToInt64() { @@ -5635,13 +5809,13 @@ public void testInt8ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5649,7 +5823,7 @@ public void testInt8ToInt64() { assertEquals(Types.int64((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5660,6 +5834,7 @@ public void testInt8ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToInt64() { @@ -5670,13 +5845,13 @@ public void testUint8ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5687,6 +5862,7 @@ public void testUint8ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToInt64() { @@ -5697,13 +5873,13 @@ public void testUint12ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5714,6 +5890,7 @@ public void testUint12ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToInt64() { @@ -5724,13 +5901,13 @@ public void testInt16ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5738,7 +5915,7 @@ public void testInt16ToInt64() { assertEquals(Types.int64((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5749,6 +5926,7 @@ public void testInt16ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToInt64() { @@ -5759,13 +5937,13 @@ public void testUint16ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5776,6 +5954,7 @@ public void testUint16ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToInt64() { @@ -5786,13 +5965,13 @@ public void testInt32ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5800,7 +5979,7 @@ public void testInt32ToInt64() { assertEquals(Types.int64(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5811,6 +5990,7 @@ public void testInt32ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToInt64() { @@ -5821,13 +6001,13 @@ public void testUint32ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5838,6 +6018,7 @@ public void testUint32ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToInt64() { @@ -5848,13 +6029,13 @@ public void testInt64ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5862,7 +6043,7 @@ public void testInt64ToInt64() { assertEquals(Types.int64(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5873,6 +6054,7 @@ public void testInt64ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToInt64() { @@ -5883,13 +6065,13 @@ public void testUint64ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5897,7 +6079,7 @@ public void testUint64ToInt64() { assertEquals(Types.int64(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5908,6 +6090,7 @@ public void testUint64ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToInt64() { @@ -5918,13 +6101,13 @@ public void testUint128ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5932,7 +6115,7 @@ public void testUint128ToInt64() { assertEquals(Types.int64(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5943,6 +6126,7 @@ public void testUint128ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToInt64() { @@ -5953,13 +6137,13 @@ public void testFloat32ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5967,7 +6151,7 @@ public void testFloat32ToInt64() { assertEquals(Types.int64(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -5978,6 +6162,7 @@ public void testFloat32ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToInt64() { @@ -5988,13 +6173,13 @@ public void testCfloat32ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6002,7 +6187,7 @@ public void testCfloat32ToInt64() { assertEquals(Types.int64(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6013,6 +6198,7 @@ public void testCfloat32ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToInt64() { @@ -6023,13 +6209,13 @@ public void testFloat64ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6037,7 +6223,7 @@ public void testFloat64ToInt64() { assertEquals(Types.int64(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6045,7 +6231,7 @@ public void testFloat64ToInt64() { assertEquals(Types.int64(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6056,6 +6242,7 @@ public void testFloat64ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToInt64}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToInt64() { @@ -6066,13 +6253,13 @@ public void testCfloat64ToInt64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.int64").input(img).apply(); + var converted = ops.op("convert.int64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.int64(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6080,7 +6267,7 @@ public void testCfloat64ToInt64() { assertEquals(Types.int64(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.int64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6091,6 +6278,7 @@ public void testCfloat64ToInt64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testBitToUint64() { @@ -6101,13 +6289,13 @@ public void testBitToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(1), cursor.next().getBigInteger()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6118,6 +6306,7 @@ public void testBitToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToUint64() { @@ -6128,13 +6317,13 @@ public void testUint2ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(2), cursor.next().getBigInteger()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6145,6 +6334,7 @@ public void testUint2ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToUint64() { @@ -6155,13 +6345,13 @@ public void testUint4ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(15), cursor.next().getBigInteger()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6172,6 +6362,7 @@ public void testUint4ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToUint64() { @@ -6182,13 +6373,13 @@ public void testInt8ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64((byte) 8), cursor.next().getBigInteger()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6196,7 +6387,7 @@ public void testInt8ToUint64() { assertEquals(Types.uint64((byte) 0), cursor.next().getBigInteger()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6207,6 +6398,7 @@ public void testInt8ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToUint64() { @@ -6217,13 +6409,13 @@ public void testUint8ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(100), cursor.next().getBigInteger()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6234,6 +6426,7 @@ public void testUint8ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToUint64() { @@ -6244,13 +6437,13 @@ public void testUint12ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(212L), cursor.next().getBigInteger()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6261,6 +6454,7 @@ public void testUint12ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToUint64() { @@ -6271,13 +6465,13 @@ public void testInt16ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64((short) 52), cursor.next().getBigInteger()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6285,7 +6479,7 @@ public void testInt16ToUint64() { assertEquals(Types.uint64((short) 0), cursor.next().getBigInteger()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6296,6 +6490,7 @@ public void testInt16ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToUint64() { @@ -6306,13 +6501,13 @@ public void testUint16ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(480), cursor.next().getBigInteger()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6323,6 +6518,7 @@ public void testUint16ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToUint64() { @@ -6333,13 +6529,13 @@ public void testInt32ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(301), cursor.next().getBigInteger()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6347,7 +6543,7 @@ public void testInt32ToUint64() { assertEquals(Types.uint64(0), cursor.next().getBigInteger()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6358,6 +6554,7 @@ public void testInt32ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToUint64() { @@ -6368,13 +6565,13 @@ public void testUint32ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(20L), cursor.next().getBigInteger()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6385,6 +6582,7 @@ public void testUint32ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToUint64() { @@ -6395,13 +6593,13 @@ public void testInt64ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(891L), cursor.next().getBigInteger()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6409,7 +6607,7 @@ public void testInt64ToUint64() { assertEquals(Types.uint64(0L), cursor.next().getBigInteger()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6420,6 +6618,7 @@ public void testInt64ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToUint64() { @@ -6430,13 +6629,13 @@ public void testUint64ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(1049L), cursor.next().getBigInteger()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6444,7 +6643,7 @@ public void testUint64ToUint64() { assertEquals(Types.uint64(0L), cursor.next().getBigInteger()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6455,6 +6654,7 @@ public void testUint64ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToUint64() { @@ -6465,13 +6665,13 @@ public void testUint128ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(beef), cursor.next().getBigInteger()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6479,7 +6679,7 @@ public void testUint128ToUint64() { assertEquals(Types.uint64(biZero), cursor.next().getBigInteger()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6490,6 +6690,7 @@ public void testUint128ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToUint64() { @@ -6500,13 +6701,13 @@ public void testFloat32ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(123453.125f), cursor.next().getBigInteger()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6514,7 +6715,7 @@ public void testFloat32ToUint64() { assertEquals(Types.uint64(0f), cursor.next().getBigInteger()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6525,6 +6726,7 @@ public void testFloat32ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToUint64() { @@ -6535,13 +6737,13 @@ public void testCfloat32ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(5839.25f), cursor.next().getBigInteger()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6549,7 +6751,7 @@ public void testCfloat32ToUint64() { assertEquals(Types.uint64(0f), cursor.next().getBigInteger()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6560,6 +6762,7 @@ public void testCfloat32ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToUint64() { @@ -6570,13 +6773,13 @@ public void testFloat64ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(4098d), cursor.next().getBigInteger()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6584,7 +6787,7 @@ public void testFloat64ToUint64() { assertEquals(Types.uint64(0d), cursor.next().getBigInteger()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6592,7 +6795,7 @@ public void testFloat64ToUint64() { assertEquals(Types.uint64(-10948.015625d), cursor.next().getBigInteger()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6603,6 +6806,7 @@ public void testFloat64ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint64}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToUint64() { @@ -6613,13 +6817,13 @@ public void testCfloat64ToUint64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint64").input(img).apply(); + var converted = ops.op("convert.uint64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint64(9087d), cursor.next().getBigInteger()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6627,7 +6831,7 @@ public void testCfloat64ToUint64() { assertEquals(Types.uint64(0d), cursor.next().getBigInteger()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6638,6 +6842,7 @@ public void testCfloat64ToUint64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testBitToUint128() { @@ -6648,13 +6853,13 @@ public void testBitToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(1), cursor.next().get()); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6665,6 +6870,7 @@ public void testBitToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToUint128() { @@ -6675,13 +6881,13 @@ public void testUint2ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(2), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6692,6 +6898,7 @@ public void testUint2ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToUint128() { @@ -6702,13 +6909,13 @@ public void testUint4ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(15), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6719,6 +6926,7 @@ public void testUint4ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToUint128() { @@ -6729,13 +6937,13 @@ public void testInt8ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128((byte) 8), cursor.next().get()); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6743,7 +6951,7 @@ public void testInt8ToUint128() { assertEquals(Types.uint128((byte) 0), cursor.next().get()); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6754,6 +6962,7 @@ public void testInt8ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToUint128() { @@ -6764,13 +6973,13 @@ public void testUint8ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(100), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6781,6 +6990,7 @@ public void testUint8ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToUint128() { @@ -6791,13 +7001,13 @@ public void testUint12ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(212L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6808,6 +7018,7 @@ public void testUint12ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToUint128() { @@ -6818,13 +7029,13 @@ public void testInt16ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128((short) 52), cursor.next().get()); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6832,7 +7043,7 @@ public void testInt16ToUint128() { assertEquals(Types.uint128((short) 0), cursor.next().get()); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6843,6 +7054,7 @@ public void testInt16ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToUint128() { @@ -6853,13 +7065,13 @@ public void testUint16ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(480), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6870,6 +7082,7 @@ public void testUint16ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToUint128() { @@ -6880,13 +7093,13 @@ public void testInt32ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(301), cursor.next().get()); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6894,7 +7107,7 @@ public void testInt32ToUint128() { assertEquals(Types.uint128(0), cursor.next().get()); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6905,6 +7118,7 @@ public void testInt32ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToUint128() { @@ -6915,13 +7129,13 @@ public void testUint32ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(20L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6932,6 +7146,7 @@ public void testUint32ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToUint128() { @@ -6942,13 +7157,13 @@ public void testInt64ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(891L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6956,7 +7171,7 @@ public void testInt64ToUint128() { assertEquals(Types.uint128(0L), cursor.next().get()); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6967,6 +7182,7 @@ public void testInt64ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToUint128() { @@ -6977,13 +7193,13 @@ public void testUint64ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(1049L), cursor.next().get()); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -6991,7 +7207,7 @@ public void testUint64ToUint128() { assertEquals(Types.uint128(0L), cursor.next().get()); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7002,6 +7218,7 @@ public void testUint64ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToUint128() { @@ -7012,13 +7229,13 @@ public void testUint128ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(beef), cursor.next().get()); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7026,7 +7243,7 @@ public void testUint128ToUint128() { assertEquals(Types.uint128(biZero), cursor.next().get()); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7037,6 +7254,7 @@ public void testUint128ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToUint128() { @@ -7047,13 +7265,13 @@ public void testFloat32ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(123453.125f), cursor.next().get()); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7061,7 +7279,7 @@ public void testFloat32ToUint128() { assertEquals(Types.uint128(0f), cursor.next().get()); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7072,6 +7290,7 @@ public void testFloat32ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToUint128() { @@ -7082,13 +7301,13 @@ public void testCfloat32ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(5839.25f), cursor.next().get()); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7096,7 +7315,7 @@ public void testCfloat32ToUint128() { assertEquals(Types.uint128(0f), cursor.next().get()); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7107,6 +7326,7 @@ public void testCfloat32ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToUint128() { @@ -7117,13 +7337,13 @@ public void testFloat64ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(4098d), cursor.next().get()); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7131,7 +7351,7 @@ public void testFloat64ToUint128() { assertEquals(Types.uint128(0d), cursor.next().get()); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7139,7 +7359,7 @@ public void testFloat64ToUint128() { assertEquals(Types.uint128(-10948.015625d), cursor.next().get()); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7150,6 +7370,7 @@ public void testFloat64ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToUint128() { @@ -7160,13 +7381,13 @@ public void testCfloat64ToUint128() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.uint128").input(img).apply(); + var converted = ops.op("convert.uint128").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.uint128(9087d), cursor.next().get()); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7174,7 +7395,7 @@ public void testCfloat64ToUint128() { assertEquals(Types.uint128(0d), cursor.next().get()); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.uint128").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7185,6 +7406,7 @@ public void testCfloat64ToUint128() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testBitToFloat32() { @@ -7195,13 +7417,13 @@ public void testBitToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(1), cursor.next().get(), 0); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7212,6 +7434,7 @@ public void testBitToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToFloat32() { @@ -7222,13 +7445,13 @@ public void testUint2ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(2), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7239,6 +7462,7 @@ public void testUint2ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToFloat32() { @@ -7249,13 +7473,13 @@ public void testUint4ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(15), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7266,6 +7490,7 @@ public void testUint4ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToFloat32() { @@ -7276,13 +7501,13 @@ public void testInt8ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32((byte) 8), cursor.next().get(), 0); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7290,7 +7515,7 @@ public void testInt8ToFloat32() { assertEquals(Types.float32((byte) 0), cursor.next().get(), 0); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7301,6 +7526,7 @@ public void testInt8ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToFloat32() { @@ -7311,13 +7537,13 @@ public void testUint8ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(100), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7328,6 +7554,7 @@ public void testUint8ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToFloat32() { @@ -7338,13 +7565,13 @@ public void testUint12ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(212L), cursor.next().get(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7355,6 +7582,7 @@ public void testUint12ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToFloat32() { @@ -7365,13 +7593,13 @@ public void testInt16ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32((short) 52), cursor.next().get(), 0); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7379,7 +7607,7 @@ public void testInt16ToFloat32() { assertEquals(Types.float32((short) 0), cursor.next().get(), 0); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7390,6 +7618,7 @@ public void testInt16ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToFloat32() { @@ -7400,13 +7629,13 @@ public void testUint16ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(480), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7417,6 +7646,7 @@ public void testUint16ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToFloat32() { @@ -7427,13 +7657,13 @@ public void testInt32ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(301), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7441,7 +7671,7 @@ public void testInt32ToFloat32() { assertEquals(Types.float32(0), cursor.next().get(), 0); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7452,6 +7682,7 @@ public void testInt32ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToFloat32() { @@ -7462,13 +7693,13 @@ public void testUint32ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(20L), cursor.next().get(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7479,6 +7710,7 @@ public void testUint32ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToFloat32() { @@ -7489,13 +7721,13 @@ public void testInt64ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(891L), cursor.next().get(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7503,7 +7735,7 @@ public void testInt64ToFloat32() { assertEquals(Types.float32(0L), cursor.next().get(), 0); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7514,6 +7746,7 @@ public void testInt64ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToFloat32() { @@ -7524,13 +7757,13 @@ public void testUint64ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(1049L), cursor.next().get(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7538,7 +7771,7 @@ public void testUint64ToFloat32() { assertEquals(Types.float32(0L), cursor.next().get(), 0); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7549,6 +7782,7 @@ public void testUint64ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToFloat32() { @@ -7559,13 +7793,13 @@ public void testUint128ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(beef), cursor.next().get(), 0); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7573,7 +7807,7 @@ public void testUint128ToFloat32() { assertEquals(Types.float32(biZero), cursor.next().get(), 0); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7584,6 +7818,7 @@ public void testUint128ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToFloat32() { @@ -7594,13 +7829,13 @@ public void testFloat32ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(123453.125f), cursor.next().get(), 0); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7608,7 +7843,7 @@ public void testFloat32ToFloat32() { assertEquals(Types.float32(0f), cursor.next().get(), 0); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7619,6 +7854,7 @@ public void testFloat32ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToFloat32() { @@ -7629,13 +7865,13 @@ public void testCfloat32ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(5839.25f), cursor.next().get(), 0); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7643,7 +7879,7 @@ public void testCfloat32ToFloat32() { assertEquals(Types.float32(0f), cursor.next().get(), 0); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7654,6 +7890,7 @@ public void testCfloat32ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToFloat32() { @@ -7664,13 +7901,13 @@ public void testFloat64ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(4098d), cursor.next().get(), 0); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7678,7 +7915,7 @@ public void testFloat64ToFloat32() { assertEquals(Types.float32(0d), cursor.next().get(), 0); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7686,7 +7923,7 @@ public void testFloat64ToFloat32() { assertEquals(Types.float32(-10948.015625d), cursor.next().get(), 0); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7697,6 +7934,7 @@ public void testFloat64ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToFloat32() { @@ -7707,13 +7945,13 @@ public void testCfloat64ToFloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float32").input(img).apply(); + var converted = ops.op("convert.float32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(9087d), cursor.next().get(), 0); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7721,7 +7959,7 @@ public void testCfloat64ToFloat32() { assertEquals(Types.float32(0d), cursor.next().get(), 0); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7732,6 +7970,7 @@ public void testCfloat64ToFloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testBitToCfloat32() { @@ -7742,14 +7981,14 @@ public void testBitToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(1), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0), cursor.next().getImaginaryFloat(), 0); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7761,6 +8000,7 @@ public void testBitToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToCfloat32() { @@ -7771,14 +8011,14 @@ public void testUint2ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(2), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0), cursor.next().getImaginaryFloat(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7790,6 +8030,7 @@ public void testUint2ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToCfloat32() { @@ -7800,14 +8041,14 @@ public void testUint4ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(15), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0), cursor.next().getImaginaryFloat(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7819,6 +8060,7 @@ public void testUint4ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToCfloat32() { @@ -7829,14 +8071,14 @@ public void testInt8ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32((byte) 8), cursor.next().getRealFloat(), 0); assertEquals(Types.float32((byte) 0), cursor.next().getImaginaryFloat(), 0); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7845,7 +8087,7 @@ public void testInt8ToCfloat32() { assertEquals(Types.float32((byte) 0), cursor.next().getImaginaryFloat(), 0); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7857,6 +8099,7 @@ public void testInt8ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToCfloat32() { @@ -7867,14 +8110,14 @@ public void testUint8ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(100), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0), cursor.next().getImaginaryFloat(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7886,6 +8129,7 @@ public void testUint8ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToCfloat32() { @@ -7896,14 +8140,14 @@ public void testUint12ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(212L), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0L), cursor.next().getImaginaryFloat(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7915,6 +8159,7 @@ public void testUint12ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToCfloat32() { @@ -7925,14 +8170,14 @@ public void testInt16ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32((short) 52), cursor.next().getRealFloat(), 0); assertEquals(Types.float32((short) 0), cursor.next().getImaginaryFloat(), 0); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7941,7 +8186,7 @@ public void testInt16ToCfloat32() { assertEquals(Types.float32((short) 0), cursor.next().getImaginaryFloat(), 0); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7953,6 +8198,7 @@ public void testInt16ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToCfloat32() { @@ -7963,14 +8209,14 @@ public void testUint16ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(480), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0), cursor.next().getImaginaryFloat(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -7982,6 +8228,7 @@ public void testUint16ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToCfloat32() { @@ -7992,14 +8239,14 @@ public void testInt32ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(301), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0), cursor.next().getImaginaryFloat(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8008,7 +8255,7 @@ public void testInt32ToCfloat32() { assertEquals(Types.float32(0), cursor.next().getImaginaryFloat(), 0); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8020,6 +8267,7 @@ public void testInt32ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToCfloat32() { @@ -8030,14 +8278,14 @@ public void testUint32ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(20L), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0L), cursor.next().getImaginaryFloat(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8049,6 +8297,7 @@ public void testUint32ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToCfloat32() { @@ -8059,14 +8308,14 @@ public void testInt64ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(891L), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0L), cursor.next().getImaginaryFloat(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8075,7 +8324,7 @@ public void testInt64ToCfloat32() { assertEquals(Types.float32(0L), cursor.next().getImaginaryFloat(), 0); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8087,6 +8336,7 @@ public void testInt64ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToCfloat32() { @@ -8097,14 +8347,14 @@ public void testUint64ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(1049L), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0L), cursor.next().getImaginaryFloat(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8113,7 +8363,7 @@ public void testUint64ToCfloat32() { assertEquals(Types.float32(0L), cursor.next().getImaginaryFloat(), 0); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8125,6 +8375,7 @@ public void testUint64ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToCfloat32() { @@ -8135,14 +8386,14 @@ public void testUint128ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(beef), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(biZero), cursor.next().getImaginaryFloat(), 0); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8151,7 +8402,7 @@ public void testUint128ToCfloat32() { assertEquals(Types.float32(biZero), cursor.next().getImaginaryFloat(), 0); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8163,6 +8414,7 @@ public void testUint128ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToCfloat32() { @@ -8173,14 +8425,14 @@ public void testFloat32ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(123453.125f), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0f), cursor.next().getImaginaryFloat(), 0); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8189,7 +8441,7 @@ public void testFloat32ToCfloat32() { assertEquals(Types.float32(0f), cursor.next().getImaginaryFloat(), 0); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8201,6 +8453,7 @@ public void testFloat32ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToCfloat32() { @@ -8211,14 +8464,14 @@ public void testCfloat32ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(5839.25f), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(120f), cursor.next().getImaginaryFloat(), 0); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8227,7 +8480,7 @@ public void testCfloat32ToCfloat32() { assertEquals(Types.float32(0f), cursor.next().getImaginaryFloat(), 0); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8239,6 +8492,7 @@ public void testCfloat32ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToCfloat32() { @@ -8249,14 +8503,14 @@ public void testFloat64ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(4098d), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(0d), cursor.next().getImaginaryFloat(), 0); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8265,7 +8519,7 @@ public void testFloat64ToCfloat32() { assertEquals(Types.float32(0d), cursor.next().getImaginaryFloat(), 0); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8274,7 +8528,7 @@ public void testFloat64ToCfloat32() { assertEquals(Types.float32(0d), cursor.next().getImaginaryFloat(), 0); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8286,6 +8540,7 @@ public void testFloat64ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToCfloat32() { @@ -8296,14 +8551,14 @@ public void testCfloat64ToCfloat32() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat32").input(img).apply(); + var converted = ops.op("convert.cfloat32").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float32(9087d), cursor.next().getRealFloat(), 0); assertEquals(Types.float32(879542.125d), cursor.next().getImaginaryFloat(), 0); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8312,7 +8567,7 @@ public void testCfloat64ToCfloat32() { assertEquals(Types.float32(0d), cursor.next().getImaginaryFloat(), 0); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat32").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8324,6 +8579,7 @@ public void testCfloat64ToCfloat32() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testBitToFloat64() { @@ -8334,13 +8590,13 @@ public void testBitToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(1), cursor.next().get(), 0); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8351,6 +8607,7 @@ public void testBitToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToFloat64() { @@ -8361,13 +8618,13 @@ public void testUint2ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(2), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8378,6 +8635,7 @@ public void testUint2ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToFloat64() { @@ -8388,13 +8646,13 @@ public void testUint4ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(15), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8405,6 +8663,7 @@ public void testUint4ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToFloat64() { @@ -8415,13 +8674,13 @@ public void testInt8ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64((byte) 8), cursor.next().get(), 0); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8429,7 +8688,7 @@ public void testInt8ToFloat64() { assertEquals(Types.float64((byte) 0), cursor.next().get(), 0); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8440,6 +8699,7 @@ public void testInt8ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToFloat64() { @@ -8450,13 +8710,13 @@ public void testUint8ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(100), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8467,6 +8727,7 @@ public void testUint8ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToFloat64() { @@ -8477,13 +8738,13 @@ public void testUint12ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(212L), cursor.next().get(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8494,6 +8755,7 @@ public void testUint12ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToFloat64() { @@ -8504,13 +8766,13 @@ public void testInt16ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64((short) 52), cursor.next().get(), 0); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8518,7 +8780,7 @@ public void testInt16ToFloat64() { assertEquals(Types.float64((short) 0), cursor.next().get(), 0); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8529,6 +8791,7 @@ public void testInt16ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToFloat64() { @@ -8539,13 +8802,13 @@ public void testUint16ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(480), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8556,6 +8819,7 @@ public void testUint16ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToFloat64() { @@ -8566,13 +8830,13 @@ public void testInt32ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(301), cursor.next().get(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8580,7 +8844,7 @@ public void testInt32ToFloat64() { assertEquals(Types.float64(0), cursor.next().get(), 0); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8591,6 +8855,7 @@ public void testInt32ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToFloat64() { @@ -8601,13 +8866,13 @@ public void testUint32ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(20L), cursor.next().get(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8618,6 +8883,7 @@ public void testUint32ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToFloat64() { @@ -8628,13 +8894,13 @@ public void testInt64ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(891L), cursor.next().get(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8642,7 +8908,7 @@ public void testInt64ToFloat64() { assertEquals(Types.float64(0L), cursor.next().get(), 0); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8653,6 +8919,7 @@ public void testInt64ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToFloat64() { @@ -8663,13 +8930,13 @@ public void testUint64ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(1049L), cursor.next().get(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8677,7 +8944,7 @@ public void testUint64ToFloat64() { assertEquals(Types.float64(0L), cursor.next().get(), 0); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8688,6 +8955,7 @@ public void testUint64ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToFloat64() { @@ -8698,13 +8966,13 @@ public void testUint128ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(beef), cursor.next().get(), 0); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8712,7 +8980,7 @@ public void testUint128ToFloat64() { assertEquals(Types.float64(biZero), cursor.next().get(), 0); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8723,6 +8991,7 @@ public void testUint128ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToFloat64() { @@ -8733,13 +9002,13 @@ public void testFloat32ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(123453.125f), cursor.next().get(), 0); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8747,7 +9016,7 @@ public void testFloat32ToFloat64() { assertEquals(Types.float64(0f), cursor.next().get(), 0); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8758,6 +9027,7 @@ public void testFloat32ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToFloat64() { @@ -8768,13 +9038,13 @@ public void testCfloat32ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(5839.25f), cursor.next().get(), 0); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8782,7 +9052,7 @@ public void testCfloat32ToFloat64() { assertEquals(Types.float64(0f), cursor.next().get(), 0); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8793,6 +9063,7 @@ public void testCfloat32ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToFloat64() { @@ -8803,13 +9074,13 @@ public void testFloat64ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(4098d), cursor.next().get(), 0); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8817,7 +9088,7 @@ public void testFloat64ToFloat64() { assertEquals(Types.float64(0d), cursor.next().get(), 0); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8825,7 +9096,7 @@ public void testFloat64ToFloat64() { assertEquals(Types.float64(-10948.015625d), cursor.next().get(), 0); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8836,6 +9107,7 @@ public void testFloat64ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToFloat64() { @@ -8846,13 +9118,13 @@ public void testCfloat64ToFloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.float64").input(img).apply(); + var converted = ops.op("convert.float64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(9087d), cursor.next().get(), 0); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8860,7 +9132,7 @@ public void testCfloat64ToFloat64() { assertEquals(Types.float64(0d), cursor.next().get(), 0); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.float64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8871,6 +9143,7 @@ public void testCfloat64ToFloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testBitToCfloat64() { @@ -8881,14 +9154,14 @@ public void testBitToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(1), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0), cursor.next().getImaginaryDouble(), 0); } - b.set(false); + b.set(false); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8900,6 +9173,7 @@ public void testBitToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint2ToCfloat64() { @@ -8910,14 +9184,14 @@ public void testUint2ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(2), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0), cursor.next().getImaginaryDouble(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8929,6 +9203,7 @@ public void testUint2ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint4ToCfloat64() { @@ -8939,14 +9214,14 @@ public void testUint4ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(15), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0), cursor.next().getImaginaryDouble(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8958,6 +9233,7 @@ public void testUint4ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt8ToCfloat64() { @@ -8968,14 +9244,14 @@ public void testInt8ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64((byte) 8), cursor.next().getRealDouble(), 0); assertEquals(Types.float64((byte) 0), cursor.next().getImaginaryDouble(), 0); } - b.set((byte) 0); + b.set((byte) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8984,7 +9260,7 @@ public void testInt8ToCfloat64() { assertEquals(Types.float64((byte) 0), cursor.next().getImaginaryDouble(), 0); } - b.set((byte) -12); + b.set((byte) -12); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -8996,6 +9272,7 @@ public void testInt8ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint8ToCfloat64() { @@ -9006,14 +9283,14 @@ public void testUint8ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(100), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0), cursor.next().getImaginaryDouble(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9025,6 +9302,7 @@ public void testUint8ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint12ToCfloat64() { @@ -9035,14 +9313,14 @@ public void testUint12ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(212L), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0L), cursor.next().getImaginaryDouble(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9054,6 +9332,7 @@ public void testUint12ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt16ToCfloat64() { @@ -9064,14 +9343,14 @@ public void testInt16ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64((short) 52), cursor.next().getRealDouble(), 0); assertEquals(Types.float64((short) 0), cursor.next().getImaginaryDouble(), 0); } - b.set((short) 0); + b.set((short) 0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9080,7 +9359,7 @@ public void testInt16ToCfloat64() { assertEquals(Types.float64((short) 0), cursor.next().getImaginaryDouble(), 0); } - b.set((short) -154); + b.set((short) -154); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9092,6 +9371,7 @@ public void testInt16ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint16ToCfloat64() { @@ -9102,14 +9382,14 @@ public void testUint16ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(480), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0), cursor.next().getImaginaryDouble(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9121,6 +9401,7 @@ public void testUint16ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt32ToCfloat64() { @@ -9131,14 +9412,14 @@ public void testInt32ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(301), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0), cursor.next().getImaginaryDouble(), 0); } - b.set(0); + b.set(0); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9147,7 +9428,7 @@ public void testInt32ToCfloat64() { assertEquals(Types.float64(0), cursor.next().getImaginaryDouble(), 0); } - b.set(-89); + b.set(-89); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9159,6 +9440,7 @@ public void testInt32ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint32ToCfloat64() { @@ -9169,14 +9451,14 @@ public void testUint32ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(20L), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0L), cursor.next().getImaginaryDouble(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9188,6 +9470,7 @@ public void testUint32ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testInt64ToCfloat64() { @@ -9198,14 +9481,14 @@ public void testInt64ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(891L), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0L), cursor.next().getImaginaryDouble(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9214,7 +9497,7 @@ public void testInt64ToCfloat64() { assertEquals(Types.float64(0L), cursor.next().getImaginaryDouble(), 0); } - b.set(-1024L); + b.set(-1024L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9226,6 +9509,7 @@ public void testInt64ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint64ToCfloat64() { @@ -9236,14 +9520,14 @@ public void testUint64ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(1049L), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0L), cursor.next().getImaginaryDouble(), 0); } - b.set(0L); + b.set(0L); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9252,7 +9536,7 @@ public void testUint64ToCfloat64() { assertEquals(Types.float64(0L), cursor.next().getImaginaryDouble(), 0); } - b.set(p64); + b.set(p64); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9264,6 +9548,7 @@ public void testUint64ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testUint128ToCfloat64() { @@ -9274,14 +9559,14 @@ public void testUint128ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(beef), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(biZero), cursor.next().getImaginaryDouble(), 0); } - b.set(biZero); + b.set(biZero); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9290,7 +9575,7 @@ public void testUint128ToCfloat64() { assertEquals(Types.float64(biZero), cursor.next().getImaginaryDouble(), 0); } - b.set(p128); + b.set(p128); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9302,6 +9587,7 @@ public void testUint128ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat32ToCfloat64() { @@ -9312,14 +9598,14 @@ public void testFloat32ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(123453.125f), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0f), cursor.next().getImaginaryDouble(), 0); } - b.set(0f); + b.set(0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9328,7 +9614,7 @@ public void testFloat32ToCfloat64() { assertEquals(Types.float64(0f), cursor.next().getImaginaryDouble(), 0); } - b.set(-2523485349058.0f); + b.set(-2523485349058.0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9340,6 +9626,7 @@ public void testFloat32ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat32ToCfloat64() { @@ -9350,14 +9637,14 @@ public void testCfloat32ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(5839.25f), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(120f), cursor.next().getImaginaryDouble(), 0); } - b.set(0f, 0f); + b.set(0f, 0f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9366,7 +9653,7 @@ public void testCfloat32ToCfloat64() { assertEquals(Types.float64(0f), cursor.next().getImaginaryDouble(), 0); } - b.set(-4.25f, -123.0625f); + b.set(-4.25f, -123.0625f); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9378,6 +9665,7 @@ public void testCfloat32ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testFloat64ToCfloat64() { @@ -9388,14 +9676,14 @@ public void testFloat64ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(4098d), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(0d), cursor.next().getImaginaryDouble(), 0); } - b.set(0d); + b.set(0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9404,7 +9692,7 @@ public void testFloat64ToCfloat64() { assertEquals(Types.float64(0d), cursor.next().getImaginaryDouble(), 0); } - b.set(-10948.015625d); + b.set(-10948.015625d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9413,7 +9701,7 @@ public void testFloat64ToCfloat64() { assertEquals(Types.float64(0d), cursor.next().getImaginaryDouble(), 0); } - b.set(1.0000152587890625e20); + b.set(1.0000152587890625e20); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9425,6 +9713,7 @@ public void testFloat64ToCfloat64() { } /** Tests {@link ConvertComplexTypes#integerToUint128}. */ + @SuppressWarnings("unchecked") @Test public void testCfloat64ToCfloat64() { @@ -9435,14 +9724,14 @@ public void testCfloat64ToCfloat64() { .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.cfloat64").input(img).apply(); + var converted = ops.op("convert.cfloat64").input(img).apply(); var cursor = ((IterableInterval) converted).cursor(); while(cursor.hasNext()) { assertEquals(Types.float64(9087d), cursor.next().getRealDouble(), 0); assertEquals(Types.float64(879542.125d), cursor.next().getImaginaryDouble(), 0); } - b.set(0d, 0d); + b.set(0d, 0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); @@ -9451,7 +9740,7 @@ public void testCfloat64ToCfloat64() { assertEquals(Types.float64(0d), cursor.next().getImaginaryDouble(), 0); } - b.set(-234.25d, -9.0d); + b.set(-234.25d, -9.0d); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.cfloat64").input(img).apply(); cursor = ((IterableInterval) converted).cursor(); diff --git a/scijava-ops-image/templates/test/java/org/scijava/ops/image/convert/RAIConvertersTest.vm b/scijava-ops-image/templates/test/java/org/scijava/ops/image/convert/RAIConvertersTest.vm index aaa1e7d93..49d1a2639 100644 --- a/scijava-ops-image/templates/test/java/org/scijava/ops/image/convert/RAIConvertersTest.vm +++ b/scijava-ops-image/templates/test/java/org/scijava/ops/image/convert/RAIConvertersTest.vm @@ -20,20 +20,26 @@ import org.scijava.ops.image.AbstractOpTest; public class RAIConvertersTest extends AbstractOpTest { + private static final ArrayImg DOUBLES = ArrayImgs.doubles(1, 1) + #foreach ($toType in $types) /** + * @param in the input image * @param out the output image * @implNote op names='test.convert.image.${toType}', type='Computer' */ - public static void compute$toType(RandomAccessibleInterval<$toType> out) { + public static void compute$toType( + RandomAccessibleInterval<$toType> in, + RandomAccessibleInterval out + ) { LoopBuilder.setImages(out).forEachPixel(o -> o.setReal(1.0)); } @Test public void testConvert${toType}Image() { - var out = ArrayImgs.doubles(1, 1); + var in = ArrayImgs.doubles(1, 1); out.firstElement().set(0.0); - ops.op("test.convert.image.${toType}").output(out).compute(); + ops.op("test.convert.image.${toType}").input(in).output(DOUBLES).compute(); double expected = 1.0; double actual = out.firstElement().get(); Assertions.assertEquals(expected, actual); diff --git a/scijava-ops-image/templates/test/java/org/scijava/ops/image/convert/TestConvertImages.vm b/scijava-ops-image/templates/test/java/org/scijava/ops/image/convert/TestConvertImages.vm index 3154d3237..2ae50b1fe 100644 --- a/scijava-ops-image/templates/test/java/org/scijava/ops/image/convert/TestConvertImages.vm +++ b/scijava-ops-image/templates/test/java/org/scijava/ops/image/convert/TestConvertImages.vm @@ -9,7 +9,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import java.math.BigInteger; -import org.scijava.ops.image.AbstractOpTest; import net.imglib2.FinalDimensions; import net.imglib2.IterableInterval; import net.imglib2.type.logic.BitType; @@ -30,6 +29,7 @@ import net.imglib2.type.numeric.integer.UnsignedShortType; import net.imglib2.type.numeric.real.DoubleType; import net.imglib2.type.numeric.real.FloatType; import org.junit.jupiter.api.Test; +import org.scijava.ops.image.AbstractOpTest; /** * Tests the {@link ConvertComplexTypes} ops. @@ -61,6 +61,7 @@ public class TestConvertImages extends AbstractOpTest{ #set ($imgLibType2 = "$fromType.imglibT" + "Type") #set ($first = "true") /** Tests {@link $className}. */ + @SuppressWarnings("unchecked") @Test public void test${fromType.op}To${toType.op}() { @@ -73,7 +74,7 @@ public class TestConvertImages extends AbstractOpTest{ .apply(); ops.op("image.fill").input(b).output(img).compute(); // Create the converted image - var converted = ops.op("convert.$toType.built").input(img).apply(); + var converted = ops.op("convert.$toType.built").input(img).apply(); var cursor = ((IterableInterval<$imgLibType>) converted).cursor(); while(cursor.hasNext()) { #if($toType.op.contains("C")) @@ -89,7 +90,7 @@ public class TestConvertImages extends AbstractOpTest{ } #set ($first = "false") #else - b.set($value.v); + b.set($value.v); ops.op("image.fill").input(b).output(img).compute(); converted = ops.op("convert.$toType.built").input(img).apply(); cursor = ((IterableInterval<$imgLibType>) converted).cursor();