Use new imglib2 parallelization approach

pom.xml

@@ -200,6 +200,7 @@ Jean-Yves Tinevez and Michael Zinsmaier.</license.copyrightOwners>
 
 		<!-- NB: Deploy releases to the SciJava Maven repository. -->
 		<releaseProfiles>sign,deploy-to-scijava</releaseProfiles>
+		<imglib2.version>5.13.0</imglib2.version>
 	</properties>
 
 	<repositories>

src/main/java/net/imglib2/algorithm/binary/Thresholder.java

@@ -33,16 +33,12 @@
  */
 package net.imglib2.algorithm.binary;
 
-import java.util.Vector;
+import java.util.function.BiConsumer;
 
-import net.imglib2.Cursor;
-import net.imglib2.RandomAccess;
-import net.imglib2.converter.Converter;
-import net.imglib2.exception.IncompatibleTypeException;
 import net.imglib2.img.Img;
 import net.imglib2.img.ImgFactory;
-import net.imglib2.multithreading.Chunk;
-import net.imglib2.multithreading.SimpleMultiThreading;
+import net.imglib2.loops.LoopBuilder;
+import net.imglib2.parallel.Parallelization;
 import net.imglib2.type.Type;
 import net.imglib2.type.logic.BitType;
 
@@ -73,95 +69,39 @@ public class Thresholder
 	 */
 	public static final < T extends Type< T > & Comparable< T >> Img< BitType > threshold( final Img< T > source, final T threshold, final boolean above, final int numThreads )
 	{
-		final ImgFactory< T > factory = source.factory();
-		try
-		{
-			final ImgFactory< BitType > bitFactory = factory.imgFactory( new BitType() );
-			final Img< BitType > target = bitFactory.create( source );
-
-			final Converter< T, BitType > converter;
-			if ( above )
-			{
-				converter = new Converter< T, BitType >()
-				{
-					@Override
-					public void convert( final T input, final BitType output )
-					{
-						output.set( input.compareTo( threshold ) > 0 );
-					}
-				};
-			}
-			else
-			{
-				converter = new Converter< T, BitType >()
-				{
-					@Override
-					public void convert( final T input, final BitType output )
-					{
-						output.set( input.compareTo( threshold ) < 0 );
-					}
-				};
-			}
-
-			final Vector< Chunk > chunks = SimpleMultiThreading.divideIntoChunks( target.size(), numThreads );
-			final Thread[] threads = SimpleMultiThreading.newThreads( numThreads );
+		return Parallelization.runWithNumThreads( numThreads,
+				() -> threshold( source, threshold, above ) );
+	}
 
-			if ( target.iterationOrder().equals( source.iterationOrder() ) )
-			{
-				for ( int i = 0; i < threads.length; i++ )
-				{
-					final Chunk chunk = chunks.get( i );
-					threads[ i ] = new Thread( "Thresholder thread " + i )
-					{
-						@Override
-						public void run()
-						{
-							final Cursor< BitType > cursorTarget = target.cursor();
-							cursorTarget.jumpFwd( chunk.getStartPosition() );
-							final Cursor< T > cursorSource = source.cursor();
-							cursorSource.jumpFwd( chunk.getStartPosition() );
-							for ( long steps = 0; steps < chunk.getLoopSize(); steps++ )
-							{
-								cursorTarget.fwd();
-								cursorSource.fwd();
-								converter.convert( cursorSource.get(), cursorTarget.get() );
-							}
-						}
-					};
-				}
-			}
-			else
-			{
-				for ( int i = 0; i < threads.length; i++ )
-				{
-					final Chunk chunk = chunks.get( i );
-					threads[ i ] = new Thread( "Thresholder thread " + i )
-					{
-						@Override
-						public void run()
-						{
-							final Cursor< BitType > cursorTarget = target.cursor();
-							cursorTarget.jumpFwd( chunk.getStartPosition() );
-							final RandomAccess< T > ra = source.randomAccess( target );
-							for ( long steps = 0; steps < chunk.getLoopSize(); steps++ )
-							{
-								cursorTarget.fwd();
-								ra.setPosition( cursorTarget );
-								converter.convert( ra.get(), cursorTarget.get() );
-							}
-						}
-					};
-				}
-			}
+	/**
+	 * Returns a new boolean {@link Img} generated by thresholding the values of
+	 * the source image.
+	 *
+	 * @param source
+	 *            the image to threshold.
+	 * @param threshold
+	 *            the threshold.
+	 * @param above
+	 *            if {@code true}, the target value will be true for source
+	 *            values above the threshold, {@code false} otherwise.
+	 * @return a new {@link Img} of type {@link BitType} and of same dimension
+	 *         that the source image.
+	 */
+	public static < T extends Type< T > & Comparable< T > > Img< BitType > threshold( Img< T > source, T threshold, boolean above )
+	{
+		final ImgFactory< BitType > factory = source.factory().imgFactory( new BitType() );
+		final Img< BitType > target = factory.create( source );
+		final BiConsumer< T, BitType > converter = getThresholdConverter( threshold, above );
+		LoopBuilder.setImages( source, target ).multiThreaded().forEachPixel( converter );
+		return target;
+	}
 
-			SimpleMultiThreading.startAndJoin( threads );
-			return target;
-		}
-		catch ( final IncompatibleTypeException e )
-		{
-			e.printStackTrace();
-			return null;
-		}
+	private static < T extends Type< T > & Comparable< T > > BiConsumer< T, BitType > getThresholdConverter( T threshold, boolean above )
+	{
+		if ( above )
+			return ( input, output ) -> output.set( input.compareTo( threshold ) > 0 );
+		else
+			return ( input, output ) -> output.set( input.compareTo( threshold ) < 0 );
 	}
 
 }

src/main/java/net/imglib2/algorithm/dog/DifferenceOfGaussian.java

@@ -33,26 +33,20 @@
  */
 package net.imglib2.algorithm.dog;
 
-import java.util.ArrayList;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-
-import net.imglib2.Cursor;
-import net.imglib2.IterableInterval;
-import net.imglib2.RandomAccess;
 import net.imglib2.RandomAccessible;
 import net.imglib2.RandomAccessibleInterval;
 import net.imglib2.algorithm.gauss3.Gauss3;
-import net.imglib2.exception.IncompatibleTypeException;
 import net.imglib2.img.Img;
+import net.imglib2.loops.LoopBuilder;
+import net.imglib2.parallel.Parallelization;
 import net.imglib2.type.NativeType;
 import net.imglib2.type.numeric.NumericType;
 import net.imglib2.util.Util;
 import net.imglib2.view.IntervalView;
 import net.imglib2.view.Views;
 
+import java.util.concurrent.ExecutorService;
+
 /**
  * Compute Difference-of-Gaussian of a {@link RandomAccessible}.
  * 
@@ -66,7 +60,7 @@ public class DifferenceOfGaussian
 	 * of sigmaLarger (where {@code sigmaLarger > sigmaSmaller}).
 	 * <p>
 	 * Creates an appropriate temporary image and calls
-	 * {@link #DoG(double[], double[], RandomAccessible, RandomAccessible, RandomAccessibleInterval, ExecutorService)}
+	 * {@link #DoG(double[], double[], RandomAccessible, RandomAccessible, RandomAccessibleInterval)}
 	 * .
 	 * </p>
 	 *
@@ -80,21 +74,18 @@ public class DifferenceOfGaussian
 	 *            convolution).
 	 * @param dog
 	 *            the Difference-of-Gaussian result image.
-	 * @param service
-	 *            service providing threads for multi-threading
 	 */
 	public static < I extends NumericType< I >, T extends NumericType< T > & NativeType< T > > void DoG(
 			final double[] sigmaSmaller,
 			final double[] sigmaLarger,
 			final RandomAccessible< I > input,
-			final RandomAccessibleInterval< T > dog,
-			final ExecutorService service )
+			final RandomAccessibleInterval< T > dog )
 	{
 		final T type = Util.getTypeFromInterval( dog );
 		final Img< T > g1 = Util.getArrayOrCellImgFactory( dog, type ).create( dog );
 		final long[] translation = new long[ dog.numDimensions() ];
 		dog.min( translation );
-		DoG( sigmaSmaller, sigmaLarger, input, Views.translate( g1, translation ), dog, service );
+		DoG( sigmaSmaller, sigmaLarger, input, Views.translate( g1, translation ), dog );
 	}
 
 	/**
@@ -115,88 +106,59 @@ public static < I extends NumericType< I >, T extends NumericType< T > & NativeT
 	 *            dog result image.
 	 * @param dog
 	 *            the Difference-of-Gaussian result image.
-	 * @param service
-	 *            how many threads to use for the computation.
 	 */
 	public static < I extends NumericType< I >, T extends NumericType< T > & NativeType< T > > void DoG(
 			final double[] sigmaSmaller,
 			final double[] sigmaLarger,
 			final RandomAccessible< I > input,
 			final RandomAccessible< T > tmp,
+			final RandomAccessibleInterval< T > dog )
+	{
+		final IntervalView< T > tmpInterval = Views.interval( tmp, dog );
+		Gauss3.gauss( sigmaSmaller, input, tmpInterval );
+		Gauss3.gauss( sigmaLarger, input, dog );
+		LoopBuilder.setImages( dog, tmpInterval ).multiThreaded().forEachPixel( ( d, t ) -> d.sub( t ) );
+	}
+
+	/**
+	 * @deprecated Please use:
+	 *
+	 * <p>
+	 * {@code Parallelization.withExecutor( service ).run( () -> DoG( sigmaSmaller, sigmaLarger, input, dog ) )}
+	 *
+	 * @see Parallelization
+	 */
+	public static < I extends NumericType< I >, T extends NumericType< T > & NativeType< T > > void DoG(
+			final double[] sigmaSmaller,
+			final double[] sigmaLarger,
+			final RandomAccessible< I > input,
 			final RandomAccessibleInterval< T > dog,
 			final ExecutorService service )
 	{
-		final IntervalView< T > tmpInterval = Views.interval( tmp, dog );
-		try
-		{
-			Gauss3.gauss( sigmaSmaller, input, tmpInterval, service );
-			Gauss3.gauss( sigmaLarger, input, dog, service );
-		}
-		catch ( final IncompatibleTypeException e )
-		{
-			e.printStackTrace();
-		}
-		final IterableInterval< T > dogIterable = Views.iterable( dog );
-		final IterableInterval< T > tmpIterable = Views.iterable( tmpInterval );
-		final long size = dogIterable.size();
-		// FIXME find better heuristic?
-		final int numThreads = Runtime.getRuntime().availableProcessors();
-		final int numTasks = numThreads <= 1 ? 1 : numThreads * 20;
-		final long taskSize = size / numTasks;
-		final ArrayList< Future< Void > > futures = new ArrayList<>();
-		for ( int taskNum = 0; taskNum < numTasks; ++taskNum )
-		{
-			final long fromIndex = taskNum * taskSize;
-			final long thisTaskSize = ( taskNum == numTasks - 1 ) ? size - fromIndex : taskSize;
-			if ( dogIterable.iterationOrder().equals( tmpIterable.iterationOrder() ) )
-				futures.add( service.submit( new Callable< Void >()
-				{
-					@Override
-					public Void call()
-					{
-						final Cursor< T > dogCursor = dogIterable.cursor();
-						final Cursor< T > tmpCursor = tmpIterable.cursor();
-						dogCursor.jumpFwd( fromIndex );
-						tmpCursor.jumpFwd( fromIndex );
-						for ( int i = 0; i < thisTaskSize; ++i )
-							dogCursor.next().sub( tmpCursor.next() );
-						return null;
-					}
-				} ) );
-			else
-				futures.add( service.submit( new Callable< Void >()
-				{
-					@Override
-					public Void call()
-					{
-						final Cursor< T > dogCursor = dogIterable.localizingCursor();
-						final RandomAccess< T > tmpAccess = tmpInterval.randomAccess();
-						dogCursor.jumpFwd( fromIndex );
-						for ( int i = 0; i < thisTaskSize; ++i )
-						{
-							final T o = dogCursor.next();
-							tmpAccess.setPosition( dogCursor );
-							o.sub( tmpAccess.get() );
-						}
-						return null;
-					}
-				} ) );
-		}
-		for ( final Future< Void > f : futures )
-		{
-			try
-			{
-				f.get();
-			}
-			catch ( final InterruptedException e )
-			{
-				e.printStackTrace();
-			}
-			catch ( final ExecutionException e )
-			{
-				e.printStackTrace();
-			}
-		}
+		Parallelization.runWithExecutor( service,
+				() -> DoG( sigmaSmaller, sigmaLarger, input, dog )
+		);
+	}
+
+	/**
+	 * @deprecated Please use:
+	 *
+	 * <p>
+	 * {@code Parallelization.withExecutor( service ). run( () -> DoG( sigmaSmaller, sigmaLarger, input, tmp, dog ) ); }
+	 *
+	 * @see Parallelization
+	 */
+	public static < I extends NumericType< I >, T extends NumericType< T > & NativeType< T > > void DoG(
+			final double[] sigmaSmaller,
+			final double[] sigmaLarger,
+			final RandomAccessible< I > input,
+			final RandomAccessible< T > tmp,
+			final RandomAccessibleInterval< T > dog,
+			final ExecutorService service )
+	{
+		Parallelization.runWithExecutor( service,
+				() -> DoG( sigmaSmaller, sigmaLarger, input, tmp, dog )
+		);
 	}
 
 	/**