Formatting

Author: tpietzsch

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

@@ -1,20 +1,22 @@
 package net.imglib2.algorithm.convolution;
 
-import net.imglib2.RandomAccessible;
-import net.imglib2.RandomAccessibleInterval;
-
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadPoolExecutor;
 
+import net.imglib2.RandomAccessible;
+import net.imglib2.RandomAccessibleInterval;
+
 /**
  * Abstract class to help implementing a Convolution, that is multi threaded
  * using an {@link ExecutorService}. This implements the method
  * {@link Convolution#setExecutor(ExecutorService)}.
  * <p>
- * Classes that derive from
- * {@link AbstractMultiThreadedConvolution} must override
+ * Classes that derive from {@link AbstractMultiThreadedConvolution} must
+ * override
  * {@link AbstractMultiThreadedConvolution#process(RandomAccessible, RandomAccessibleInterval, ExecutorService, int)}
+ *
+ * @author Matthias Arzt
  */
 public abstract class AbstractMultiThreadedConvolution< T > implements Convolution< T >
 {
@@ -24,20 +26,21 @@ public abstract class AbstractMultiThreadedConvolution< T > implements Convoluti
 	abstract protected void process( RandomAccessible< ? extends T > source,
 			RandomAccessibleInterval< ? extends T > target,
 			ExecutorService executorService,
-			int numThreads);
+			int numThreads );
 
 	@Override
-	public void setExecutor( ExecutorService executor )
+	public void setExecutor( final ExecutorService executor )
 	{
 		this.executor = executor;
 	}
 
 	@Override
-	final public void process( RandomAccessible< ? extends T > source, RandomAccessibleInterval< ? extends T > target )
+	final public void process( final RandomAccessible< ? extends T > source, final RandomAccessibleInterval< ? extends T > target )
 	{
-		if(executor == null) {
-			int numThreads = suggestNumThreads();
-			ExecutorService executor = Executors.newFixedThreadPool( numThreads );
+		if ( executor == null )
+		{
+			final int numThreads = suggestNumThreads();
+			final ExecutorService executor = Executors.newFixedThreadPool( numThreads );
 			try
 			{
 				process( source, target, executor, numThreads );
@@ -47,12 +50,13 @@ final public void process( RandomAccessible< ? extends T > source, RandomAccessi
 				executor.shutdown();
 			}
 		}
-		else {
+		else
+		{
 			process( source, target, executor, getNumThreads( executor ) );
 		}
 	}
 
-	private int getNumThreads(ExecutorService executor)
+	private int getNumThreads( final ExecutorService executor )
 	{
 		if ( executor instanceof ThreadPoolExecutor )
 			return ( ( ThreadPoolExecutor ) executor ).getMaximumPoolSize();

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

@@ -1,5 +1,10 @@
 package net.imglib2.algorithm.convolution;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+
 import net.imglib2.Interval;
 import net.imglib2.RandomAccessible;
 import net.imglib2.RandomAccessibleInterval;
@@ -11,11 +16,6 @@
 import net.imglib2.util.ValuePair;
 import net.imglib2.view.Views;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.ExecutorService;
-
 /**
  * Helper to implement {@link Convolution#concat}.
  *
@@ -26,18 +26,19 @@ class Concatenation< T > implements Convolution< T >
 
 	private final List< Convolution< T > > steps;
 
-	Concatenation( List< ? extends Convolution< T > > steps )
+	Concatenation( final List< ? extends Convolution< T > > steps )
 	{
 		this.steps = new ArrayList<>( steps );
 	}
 
-	@Override public void setExecutor( ExecutorService executor )
+	@Override
+	public void setExecutor( final ExecutorService executor )
 	{
 		steps.forEach( step -> step.setExecutor( executor ) );
 	}
 
 	@Override
-	public Interval requiredSourceInterval( Interval targetInterval )
+	public Interval requiredSourceInterval( final Interval targetInterval )
 	{
 		Interval result = targetInterval;
 		for ( int i = steps.size() - 1; i >= 0; i-- )
@@ -54,17 +55,17 @@ public T preferredSourceType( T targetType )
 	}
 
 	@Override
-	public void process( RandomAccessible< ? extends T > source, RandomAccessibleInterval< ? extends T > target )
+	public void process( final RandomAccessible< ? extends T > source, final RandomAccessibleInterval< ? extends T > target )
 	{
-		List< Pair< T, Interval > > srcIntervals = tmpIntervals( Util.getTypeFromInterval( target ), target );
+		final List< Pair< T, Interval > > srcIntervals = tmpIntervals( Util.getTypeFromInterval( target ), target );
 		RandomAccessibleInterval< ? extends T > currentSource = Views.interval( source, srcIntervals.get( 0 ).getB() );
 		RandomAccessibleInterval< ? extends T > available = null;
 
 		for ( int i = 0; i < steps.size(); i++ )
 		{
-			Convolution< T > step = steps.get( i );
-			T targetType = srcIntervals.get( i + 1 ).getA();
-			Interval targetInterval = srcIntervals.get( i + 1 ).getB();
+			final Convolution< T > step = steps.get( i );
+			final T targetType = srcIntervals.get( i + 1 ).getA();
+			final Interval targetInterval = srcIntervals.get( i + 1 ).getB();
 			RandomAccessibleInterval< ? extends T > currentTarget =
 					( i == steps.size() - 1 ) ? target : null;
 
@@ -84,27 +85,28 @@ public void process( RandomAccessible< ? extends T > source, RandomAccessibleInt
 		}
 	}
 
-	private static < T extends NativeType< T > > RandomAccessibleInterval< T > createImage( T targetType, Interval targetInterval )
+	private static < T extends NativeType< T > > RandomAccessibleInterval< T > createImage( final T targetType, final Interval targetInterval )
 	{
-		long[] dimensions = Intervals.dimensionsAsLongArray( targetInterval );
-		Img< T > ts = Util.getArrayOrCellImgFactory( targetInterval, targetType ).create( dimensions );
+		final long[] dimensions = Intervals.dimensionsAsLongArray( targetInterval );
+		final Img< T > ts = Util.getArrayOrCellImgFactory( targetInterval, targetType ).create( dimensions );
 		return Views.translate( ts, Intervals.minAsLongArray( targetInterval ) );
 	}
 
-	private static < T > T uncheckedCast( Object in )
+	private static < T > T uncheckedCast( final Object in )
 	{
 		@SuppressWarnings( "unchecked" )
+		final
 		T in1 = ( T ) in;
 		return in1;
 	}
 
 	private List< Pair< T, Interval > > tmpIntervals( T type, Interval interval )
 	{
-		List< Pair< T, Interval > > result = new ArrayList<>( Collections.nCopies( steps.size() + 1, null ) );
+		final List< Pair< T, Interval > > result = new ArrayList<>( Collections.nCopies( steps.size() + 1, null ) );
 		result.set( steps.size(), new ValuePair<>( type, interval ) );
 		for ( int i = steps.size() - 1; i >= 0; i-- )
 		{
-			Convolution< T > step = steps.get( i );
+			final Convolution< T > step = steps.get( i );
 			interval = step.requiredSourceInterval( interval );
 			type = step.preferredSourceType( type );
 			result.set( i, new ValuePair<>( type, interval ) );

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

@@ -1,62 +1,64 @@
 package net.imglib2.algorithm.convolution;
 
-import net.imglib2.Interval;
-import net.imglib2.RandomAccessible;
-import net.imglib2.RandomAccessibleInterval;
-
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 
+import net.imglib2.Interval;
+import net.imglib2.RandomAccessible;
+import net.imglib2.RandomAccessibleInterval;
+
 /**
- * This interface allows the client to perform a convolution.
- * But also to query for the required input image size and preferred input image type.
- * The ExectorService can be set, to allow multi or single threaded operation.
+ * This interface allows the client to perform a convolution. But also to query
+ * for the required input image size and preferred input image type. The
+ * ExectorService can be set, to allow multi or single threaded operation.
  * <p>
  * Very importantly, multiple {@link Convolution}s can be easily concatenated.
  *
  * @author Matthias Arzt
  */
 public interface Convolution< T >
 {
-
 	/**
-	 * Returns the required size for source image, to calculate the given target interval?
+	 * Returns the required size for source image, to calculate the given target
+	 * interval.
 	 */
 	Interval requiredSourceInterval( Interval targetInterval );
 
 	/**
-	 * What's the preferred type for the source image,
-	 * when target should have the specified type.
-	 **/
+	 * What's the preferred type for the source image, when target should have
+	 * the specified type?
+	 */
 	T preferredSourceType( T targetType );
 
 	/**
 	 * Set the {@link ExecutorService} to be used for convolution.
 	 */
-	default void setExecutor( ExecutorService executor )
-	{
-	}
+	default void setExecutor( final ExecutorService executor )
+	{}
 
 	/**
 	 * Fills the target image, with the convolution result.
 	 *
-	 * @param source Source image. It must allow pixel access in the interval returned
-	 *               by {@code requiredSourceInterval(target)}
-	 * @param target Target image.
+	 * @param source
+	 *            Source image. It must allow pixel access in the interval
+	 *            returned by {@code requiredSourceInterval(target)}
+	 * @param target
+	 *            Target image.
 	 */
 	void process( RandomAccessible< ? extends T > source, RandomAccessibleInterval< ? extends T > target );
 
 	/**
-	 * Concatenate multiple {@link Convolution}s to one convolution.
-	 * (e.g. Concatenation of a gauss convolution in X, and a gauss convolution in Y will be a 2d gauss convolution).
+	 * Concatenate multiple {@link Convolution}s to one convolution. (e.g.
+	 * Concatenation of a gauss convolution in X, and a gauss convolution in Y
+	 * will be a 2d gauss convolution).
 	 */
-	static < T > Convolution< T > concat( Convolution< T >... steps )
+	static < T > Convolution< T > concat( final Convolution< T >... steps )
 	{
 		return concat( Arrays.asList( steps ) );
 	}
 
-	static < T > Convolution< T > concat( List< ? extends Convolution< T > > steps )
+	static < T > Convolution< T > concat( final List< ? extends Convolution< T > > steps )
 	{
 		if ( steps.isEmpty() )
 			throw new IllegalArgumentException( "Concat requires at least one convolution operation." );
@@ -65,4 +67,3 @@ static < T > Convolution< T > concat( List< ? extends Convolution< T > > steps )
 		return new Concatenation<>( steps );
 	}
 }
-