Opify hough package

Author: gselzer

src/main/java/net/imglib2/algorithm/hough/HoughTransforms.java

@@ -37,11 +37,7 @@
 import java.util.List;
 import java.util.function.Predicate;
 
-import net.imglib2.Cursor;
-import net.imglib2.Dimensions;
-import net.imglib2.Point;
-import net.imglib2.RandomAccess;
-import net.imglib2.RandomAccessibleInterval;
+import net.imglib2.*;
 import net.imglib2.algorithm.localextrema.LocalExtrema;
 import net.imglib2.algorithm.localextrema.LocalExtrema.MaximumCheck;
 import net.imglib2.type.numeric.IntegerType;
@@ -201,14 +197,14 @@ public static < T extends Comparable< T > > List< Point > pickLinePeaks(
 	 * Runs a Hough Line Tranform on an image and populates the vote space
 	 * parameter with the results.
 	 *
+	 * @implNote op names='voteLines',
+	 *           type='org.scijava.function.Computers.Arity1'
 	 * @param input
 	 *            - the {@link RandomAccessibleInterval} to run the Hough Line
 	 *            Transform over
 	 * @param votespace
 	 *            - the {@link RandomAccessibleInterval} in which the results
 	 *            are stored
-	 * @implNote op names='hough.lines',
-	 *           type='org.scijava.function.Computers.Arity1'
 	 */
 	public static < T extends Comparable< T >, U extends IntegerType< U > > void voteLines(
 			final RandomAccessibleInterval< T > input,
@@ -238,6 +234,34 @@ public static < T extends Comparable< T >, U extends IntegerType< U > > void vot
 		voteLines( input, votespace, nTheta, defaultRho( input ), Util.getTypeFromInterval( input ) );
 	}
 
+	/**
+	 * Runs a Hough Line Tranform on an image and populates the vote space
+	 * parameter with the results.
+	 * <p>
+	 * This method differs from
+	 * {@link #voteLines(RandomAccessibleInterval, RandomAccessibleInterval, int)}
+	 * only in that its parameter order is tailored to an Op. The output comes
+	 * last, and the primary input (the input image) comes first.
+	 * </p>
+	 *
+	 * @implNote op name='voteLines', type='org.scijava.function.Computers.Arity2'
+	 * @param input
+	 *            - the {@link RandomAccessibleInterval} to run the Hough Line
+	 *            Transform over
+	 * @param nTheta
+	 *            - the number of bins for theta resolution
+	 * @param votespace
+	 *            - the {@link RandomAccessibleInterval} in which the results
+	 *            are stored
+	 */
+	public static < T extends Comparable< T >, U extends IntegerType< U > > void voteLines(
+			final RandomAccessibleInterval< T > input,
+			final int nTheta,
+			final RandomAccessibleInterval< U > votespace)
+	{
+		voteLines( input, votespace, nTheta);
+	}
+
 	/**
 	 * Runs a Hough Line Tranform on an image and populates the vote space
 	 * parameter with the results.
@@ -262,6 +286,37 @@ public static < T extends Comparable< T >, U extends IntegerType< U > > void vot
 		voteLines( input, votespace, nTheta, nRho, Util.getTypeFromInterval( input ) );
 	}
 
+	/**
+	 * Runs a Hough Line Tranform on an image and populates the vote space
+	 * parameter with the results.
+	 * <p>
+	 * This method differs from
+	 * {@link #voteLines(RandomAccessibleInterval, RandomAccessibleInterval, int, int)}
+	 * only in that its parameter order is tailored to an Op. The output comes
+	 * last, and the primary input (the input image) comes first.
+	 * </p>
+	 *
+	 * @implNote op names='voteLines', type='org.scijava.function.Computers.Arity3'
+	 * @param input
+	 *            - the {@link RandomAccessibleInterval} to run the Hough Line
+	 *            Transform over
+	 * @param votespace
+	 *            - the {@link RandomAccessibleInterval} in which the results
+	 *            are stored
+	 * @param nTheta
+	 *            - the number of bins for theta resolution
+	 * @param nRho
+	 *            - the number of bins for rho resolution
+	 */
+	public static < T extends Comparable< T >, U extends IntegerType< U > > void voteLines(
+			final RandomAccessibleInterval< T > input,
+			final int nTheta,
+			final int nRho,
+			final RandomAccessibleInterval< U > votespace)
+	{
+		voteLines(input, votespace, nTheta, nRho);
+	}
+
 	/**
 	 * Runs a Hough Line Tranform on an image and populates the vote space
 	 * parameter with the results.
@@ -292,6 +347,42 @@ public static < T extends Comparable< T >, U extends IntegerType< U > > void vot
 		voteLines( input, votespace, nTheta, nRho, p );
 	}
 
+	/**
+	 * Runs a Hough Line Tranform on an image and populates the vote space
+	 * parameter with the results.
+	 * <p>
+	 * This method differs from
+	 * {@link #voteLines(RandomAccessibleInterval, RandomAccessibleInterval, int, int, Comparable)}
+	 * only in that its parameter order is tailored to an Op. The output comes
+	 * last, and the primary input (the input image) comes first.
+	 * </p>
+	 *
+	 * @implNote op name='voteLines', type='org.scijava.function.Computers.Arity4'
+	 * @param input
+	 *            - the {@link RandomAccessibleInterval} to run the Hough Line
+	 *            Transform over
+	 * @param nTheta
+	 *            - the number of bins for theta resolution
+	 * @param nRho
+	 *            - the number of bins for rho resolution
+	 * @param threshold
+	 *            - the minimum value allowed by the populator. Any input less
+	 *            than this value will be disregarded by the populator.
+	 * @param votespace
+	 *            - the {@link RandomAccessibleInterval} in which the results
+	 *            are stored
+	 */
+	public static < T extends Comparable< T >, U extends IntegerType< U > > void voteLines(
+			final RandomAccessibleInterval< T > input,
+			final int nTheta,
+			final int nRho,
+			final T threshold,
+			final RandomAccessibleInterval< U > votespace)
+
+	{
+		voteLines(input, votespace, nTheta, nRho, threshold);
+	}
+
 	/**
 	 *
 	 * Runs a Hough Line Tranform on an image and populates the vote space
@@ -405,12 +496,85 @@ public static < T, U extends IntegerType< U > > void voteLines(
 		}
 	}
 
+	/**
+	 *
+	 * Runs a Hough Line Tranform on an image and populates the vote space
+	 * parameter with the results.
+	 * <p>
+	 * Vote space here has two dimensions: {@code rho} and {@code theta}.
+	 * {@code theta} is measured in radians {@code [-pi/2 pi/2)}, {@code rho} is
+	 * measured in {@code [-rhoMax, rhoMax)}.
+	 * </p>
+	 * <p>
+	 * Lines are modeled as
+	 * </p>
+	 *
+	 * <pre>
+	 * l(t) = | x | = rho * |  cos(theta) | + t * | sin(theta) |
+	 *        | y |         | -sin(theta) |       | cos(theta) |
+	 * </pre>
+	 * <p>
+	 * In other words, {@code rho} represents the signed minimum distance from
+	 * the image origin to the line, and {@code theta} indicates the angle
+	 * between the row-axis and the minimum offset vector.
+	 * </p>
+	 * <p>
+	 * For a given point, then, votes are placed along the curve
+	 * </p>
+	 *
+	 * <pre>
+	 * rho = y * sin( theta ) + x * cos( theta )
+	 * </pre>
+	 * <p>
+	 * It is important to note that the interval of the first dimension of the
+	 * vote space image is NOT {@code [-maxRho, maxRho)} but instead
+	 * {@code [0, maxRho * 2)}; the same applies to the second dimension of the
+	 * vote space as well. Thus if {@link HoughTransforms#pickLinePeaks} is not
+	 * used to retrieve the maxima from the vote space, the vote space will have
+	 * to be translated by {@code -maxRho} in dimension 0 to get the correct
+	 * {@code rho} and {@code theta} values from the vote space.
+	 * </p>
+	 * <p>
+	 * This method differs from
+	 * {@link #voteLines(RandomAccessibleInterval, RandomAccessibleInterval, int, int, Predicate)}
+	 * only in that its parameter order is tailored to an Op. The output comes
+	 * last, and the primary input (the input image) comes first.
+	 * </p>
+	 *
+	 * @implNote op name='voteLines', type='org.scijava.function.Computers.Arity4'
+	 * @param input
+	 *            - the {@link RandomAccessibleInterval} to run the Hough Line
+	 *            Transform over
+	 * @param nTheta
+	 *            - the number of bins for theta resolution
+	 * @param nRho
+	 *            - the number of bins for rho resolution
+	 * @param filter
+	 *            - a {@link Predicate} judging whether or not the a value is
+	 *            above the minimum value allowed by the populator. Any input
+	 *            less than or equal to this value will be disregarded by the
+	 *            populator.
+	 * @param votespace
+	 *            - the {@link RandomAccessibleInterval} in which the results
+	 *            are stored
+	 */
+	public static < T, U extends IntegerType< U > > void voteLines(
+			final RandomAccessibleInterval< T > input,
+			final int nTheta,
+			final int nRho,
+			final Predicate< T > filter,
+			final RandomAccessibleInterval< U > votespace)
+	{
+		voteLines(input, votespace, nTheta, nRho, filter);
+	}
+
 	/**
 	 * Method used to convert the {rho, theta} output of the
 	 * {@link HoughTransforms#voteLines} algorithm into a more useful
 	 * y-intercept value. Used with {@link HoughTransforms#getSlope} to create
 	 * line equations.
 	 *
+	 * @implNote op name='getIntercept', type='java.util.function.BiFunction'
 	 * @param rho
 	 *            - the {@code rho} of the line
 	 * @param theta
@@ -429,6 +593,7 @@ public static double getIntercept( final long rho, final long theta )
 	 * value. Used with {@link HoughTransforms#getIntercept} to create line
 	 * equations.
 	 *
+	 * @implNote op name='getSlope', type='java.util.function.Function'
 	 * @param theta
 	 *            - the {@code theta} of the line
 	 * @return {@code double} - the y-intercept of the line