KernelConvolverFactory: Use FloatType for all convolutions on RealType except DoubleType

This is required for higher precision when blurring for example
ByteType images.

Author: maarzt

src/main/java/net/imglib2/algorithm/convolution/LineConvolution.java

@@ -16,6 +16,10 @@
 import net.imglib2.RandomAccess;
 import net.imglib2.RandomAccessible;
 import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.type.Type;
+import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.real.DoubleType;
+import net.imglib2.type.numeric.real.FloatType;
 import net.imglib2.util.IntervalIndexer;
 import net.imglib2.util.Intervals;
 import net.imglib2.view.Views;
@@ -51,7 +55,7 @@ public Interval requiredSourceInterval( final Interval targetInterval )
 	@Override
 	public T preferredSourceType( final T targetType )
 	{
-		return targetType;
+		return (T) factory.preferredSourceType( targetType );
 	}
 
 	@Override

src/main/java/net/imglib2/algorithm/convolution/LineConvolverFactory.java

@@ -1,6 +1,7 @@
 package net.imglib2.algorithm.convolution;
 
 import net.imglib2.RandomAccess;
+import net.imglib2.type.Type;
 
 /**
  * The interesting part of a separable convolution is how one line of the image
@@ -54,4 +55,6 @@ public interface LineConvolverFactory< T >
 	 *         getBorderAfter())
 	 */
 	Runnable getConvolver( RandomAccess< ? extends T > in, RandomAccess< ? extends T > out, int d, long lineLength );
+
+	T preferredSourceType( T targetType );
 }

src/main/java/net/imglib2/algorithm/convolution/fast_gauss/FastGaussConvolverRealType.java

@@ -6,6 +6,8 @@
 import net.imglib2.algorithm.convolution.LineConvolverFactory;
 import net.imglib2.loops.ClassCopyProvider;
 import net.imglib2.type.numeric.RealType;
+import net.imglib2.type.numeric.real.DoubleType;
+import net.imglib2.type.numeric.real.FloatType;
 
 /**
  * Implementation of {@link LineConvolverFactory} that uses
@@ -44,6 +46,12 @@ public Runnable getConvolver( final RandomAccess< ? extends RealType< ? > > in,
 		return provider.newInstanceForKey( key, d, fc, in, out, lineLength );
 	}
 
+	@Override
+	public RealType< ? > preferredSourceType( RealType< ? > targetType )
+	{
+		return (targetType instanceof DoubleType) ? targetType : new FloatType();
+	}
+
 	public static class MyConvolver implements Runnable
 	{
 		private final int d;

src/main/java/net/imglib2/algorithm/convolution/kernel/KernelConvolverFactory.java

@@ -11,6 +11,7 @@
 import net.imglib2.type.numeric.NumericType;
 import net.imglib2.type.numeric.RealType;
 import net.imglib2.type.numeric.real.DoubleType;
+import net.imglib2.type.numeric.real.FloatType;
 
 /**
  * Used by {@link SeparableKernelConvolution} as {@link LineConvolverFactory}
@@ -56,6 +57,16 @@ public Runnable getConvolver( final RandomAccess< ? extends NumericType< ? > > i
 		return provider.newInstanceForKey( key, kernel, in, out, d, lineLength );
 	}
 
+	@Override
+	public NumericType< ? > preferredSourceType( NumericType< ? > targetType )
+	{
+		if (targetType instanceof DoubleType)
+			return targetType;
+		if (targetType instanceof RealType)
+			return new FloatType();
+		return targetType;
+	}
+
 	private ClassCopyProvider< Runnable > getProvider( final NumericType< ? > sourceType, final NumericType< ? > targetType )
 	{
 		for ( final Entry entry : factories )

src/main/java/net/imglib2/algorithm/convolution/kernel/SeparableKernelConvolution.java

@@ -37,7 +37,7 @@ public class SeparableKernelConvolution
 	 *
 	 * @see Convolution
 	 */
-	public static Convolution< NumericType< ? > > convolution( final Kernel1D[] kernels )
+	public static Convolution< NumericType< ? > > convolution( final Kernel1D... kernels )
 	{
 		final List< Convolution< NumericType< ? > > > steps = IntStream.range( 0, kernels.length )
 				.mapToObj( i -> convolution1d( kernels[ i ], i ) )

src/test/java/net/imglib2/algorithm/convolution/LineConvolutionTest.java

@@ -71,5 +71,11 @@ static class ForwardDifferenceConvolverFactory implements LineConvolverFactory<
 				}
 			};
 		}
+
+		@Override
+		public UnsignedByteType preferredSourceType( UnsignedByteType targetType )
+		{
+			return new UnsignedByteType();
+		}
 	}
 }

src/test/java/net/imglib2/algorithm/convolution/kernel/SeparableKernelConvolutionTest.java

@@ -4,10 +4,12 @@
 import net.imglib2.Interval;
 import net.imglib2.RandomAccessible;
 import net.imglib2.RandomAccessibleInterval;
-import net.imglib2.exception.IncompatibleTypeException;
+import net.imglib2.algorithm.convolution.Convolution;
 import net.imglib2.img.Img;
 import net.imglib2.img.array.ArrayImgs;
 import net.imglib2.type.numeric.ARGBType;
+import net.imglib2.type.numeric.NumericType;
+import net.imglib2.type.numeric.integer.UnsignedByteType;
 import net.imglib2.type.numeric.real.DoubleType;
 import net.imglib2.type.numeric.real.FloatType;
 import net.imglib2.util.Intervals;
@@ -19,6 +21,7 @@
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
@@ -122,4 +125,26 @@ private static void assertImagesEqual( RandomAccessibleInterval< DoubleType > ex
 		Views.interval( Views.pair( expected, actual ), expected ).forEach( p -> assertEquals( p.getA().getRealDouble(), p.getB().getRealDouble(), delta ) );
 	}
 
+	@Test
+	public void testPrecisionOfTemporaryImages() {
+		// NB: This test assures that for convolution on UnsignedByteType,
+		// the pixel type to store intermediate results can store 0.1, hence
+		// is FloatType or DoubleType.
+		final byte[] inputPixels = { 1 };
+		final byte[] outputPixels = new byte[ 1 ];
+		final Kernel1D[] kernels = { Kernel1D.symmetric( 0.1 ), Kernel1D.symmetric( 10 ) };
+		Img< UnsignedByteType > input = ArrayImgs.unsignedBytes( inputPixels, 1, 1 );
+		Img< UnsignedByteType > output = ArrayImgs.unsignedBytes( outputPixels, 1, 1 );
+		SeparableKernelConvolution.convolution( kernels ).process( input, output );
+		assertArrayEquals( inputPixels, outputPixels );
+	}
+
+	@Test
+	public void testPreferredSourceType() {
+		Convolution< NumericType< ? > > convolution = SeparableKernelConvolution.convolution( Kernel1D.symmetric( 1.0 ) );
+		assertTrue( convolution.preferredSourceType( new UnsignedByteType() ) instanceof FloatType );
+		assertTrue( convolution.preferredSourceType( new DoubleType() ) instanceof DoubleType );
+		assertTrue( convolution.preferredSourceType( new FloatType() ) instanceof FloatType );
+		assertTrue( convolution.preferredSourceType( new ARGBType() ) instanceof ARGBType );
+	}
 }