Change Thresholder implementation to multi-threaded LoopBuilder

This simplifies the existing implementation while staying backwards
compatible. The code adds a new method:

 Thresholder.threshold( source, threshold, above )

That is multi-threaded according to the Parallelization context.

Author: maarzt

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 );
 	}
 
 }