ConfigExtract + related

- Updated formatting and style

Author: lessthanoptimal

main/boofcv-feature/src/main/java/boofcv/abst/feature/detect/extract/ConfigExtract.java

@@ -20,39 +20,23 @@
 
 import boofcv.struct.Configuration;
 
-/**
- * General configuration for {@link NonMaxSuppression}.
- *
- * @author Peter Abeles
- */
+/// General configuration for [NonMaxSuppression].
 public class ConfigExtract implements Configuration {
-	/**
-	 * Search radius of the non-maximum region. Most common value is 1 for a 3x3 region. Default is 1.
-	 */
+	/// Search radius of the non-maximum region. Most common value is 1 for a 3x3 region. Default is 1.
 	public int radius = 1;
-	/**
-	 * Minimum feature intensity it will consider when detecting a maximum. For local minimums
-	 * it will use a value of -threshold. Defaults to 0.
-	 */
+	/// Minimum feature intensity it will consider when detecting a maximum. For local minimums
+	/// it will use a value of -threshold. Defaults to 0.
 	public float threshold = 0;
-	/**
-	 * Size of border around the image in which pixels are not considered. Default is 0.
-	 */
+	/// Size of border around the image in which pixels are not considered. Default is 0.
 	public int ignoreBorder = 0;
-	/**
-	 * Is a strict test used to test for local maximums. If strict the local maximum must be greater than
-	 * all its neighbors, otherwise it just needs to be greater than or equal to its neighbors. Default is true.
-	 */
+	/// Is a strict test used to test for local maximums. If strict the local maximum must be greater than
+	/// all its neighbors, otherwise it just needs to be greater than or equal to its neighbors. Default is true.
 	public boolean useStrictRule = true;
 
-	/**
-	 * If false then local maximums will be found
-	 */
+	/// If false then local maximums will be found
 	public boolean detectMinimums = false;
 
-	/**
-	 * If true then local maximums will be found
-	 */
+	/// If true then local maximums will be found
 	public boolean detectMaximums = true;
 
 	public static ConfigExtract max( int radius, float threshold, int ignoreBorder, boolean useStrictRule ) {
@@ -86,9 +70,7 @@ public ConfigExtract( int radius, float threshold, int ignoreBorder, boolean use
 		this.useStrictRule = useStrictRule;
 	}
 
-	/**
-	 * Constructor which defaults to an ignore border of 0 and to using a strict rule
-	 */
+	/// Constructor which defaults to an ignore border of 0 and to using a strict rule
 	public ConfigExtract( int radius, float threshold ) {
 		this(radius, threshold, 0, true);
 	}
@@ -105,8 +87,7 @@ public ConfigExtract setTo( ConfigExtract src ) {
 		return this;
 	}
 
-	@Override
-	public void checkValidity() {
+	@Override public void checkValidity() {
 		if (radius <= 0)
 			throw new IllegalArgumentException("Search radius must be >= 1");
 		if (ignoreBorder < 0)

main/boofcv-feature/src/main/java/boofcv/abst/feature/detect/extract/NonMaxLimiter.java

@@ -30,17 +30,13 @@
 import org.ddogleg.struct.FastArray;
 import org.jetbrains.annotations.Nullable;
 
-/**
- * Adds the ability to specify the maximum number of points that you wish to return. The selected
- * points will be sorted by feature intensity. If maximums and minimums are found then the total
- * number refers to the total combined number of features. The intensity that it sorts by is the absolute value.
- *
- * @author Peter Abeles
- */
+/// Adds the ability to specify the maximum number of points that you wish to return. The selected
+/// points will be sorted by feature intensity. If maximums and minimums are found then the total
+/// number refers to the total combined number of features. The intensity that it sorts by is the absolute value.
 public class NonMaxLimiter {
 	@Getter NonMaxSuppression nonmax;
 
-	/** Maximum number of features it can return. If %le; 0 then there will be no limit */
+	/// Maximum number of features it can return. If %le; 0 then there will be no limit
 	@Getter @Setter int maxTotalFeatures;
 
 	// Detected minimums and maximums
@@ -54,12 +50,10 @@ public class NonMaxLimiter {
 	// Just the selected features
 	FastArray<LocalExtreme> foundSelected = new FastArray<>(LocalExtreme.class);
 
-	/**
-	 * Configures the limiter
-	 *
-	 * @param nonmax Non-maximum suppression algorithm
-	 * @param maxTotalFeatures The total number of allowed features it can return. Set to a value &le; 0 to disable.
-	 */
+	/// Configures the limiter
+	///
+	/// @param nonmax Non-maximum suppression algorithm
+	/// @param maxTotalFeatures The total number of allowed features it can return. Set to a value &le; 0 to disable.
 	public NonMaxLimiter( NonMaxSuppression nonmax,
 						  FeatureSelectLimitIntensity<LocalExtreme> selector,
 						  int maxTotalFeatures ) {
@@ -77,14 +71,11 @@ public NonMaxLimiter( NonMaxSuppression nonmax,
 		});
 	}
 
-	/**
-	 * Extracts local max and/or min from the intensity image. If more than the maximum features are found then
-	 * only the most intense ones will be returned
-	 *
-	 * @param intensity Feature image intensity
-	 */
+	/// Extracts local max and/or min from the intensity image. If more than the maximum features are found then
+	/// only the most intense ones will be returned
+	///
+	/// @param intensity Feature image intensity
 	public void process( GrayF32 intensity ) {
-
 		originalMin.reset();
 		originalMax.reset();
 		nonmax.process(intensity, null, null, originalMin, originalMax);
@@ -114,16 +105,12 @@ public FastAccess<LocalExtreme> getFeatures() {
 		return foundSelected;
 	}
 
-	/**
-	 * Data structure which provides information on a local extremum.
-	 */
+	/// Data structure which provides information on a local extremum.
 	@SuppressWarnings({"NullAway.Init"})
 	public static class LocalExtreme implements Comparable<LocalExtreme> {
-		/**
-		 * Absolute value of image intensity
-		 */
+		/// Absolute value of image intensity
 		public float intensity;
-		/** true if it was a maximum (positive) or minimum (negative intensity) */
+		/// true if it was a maximum (positive) or minimum (negative intensity)
 		public boolean max;
 		public Point2D_I16 location;
 
@@ -134,18 +121,15 @@ public LocalExtreme set( float intensity, boolean max, Point2D_I16 location ) {
 			return this;
 		}
 
-		/**
-		 * Returns the value of the feature in the intensity image. Adds the sign back
-		 */
+		/// Returns the value of the feature in the intensity image. Adds the sign back
 		public float getIntensitySigned() {
 			if (max)
 				return intensity;
 			else
 				return -intensity;
 		}
 
-		@Override
-		public int compareTo( LocalExtreme o ) {
+		@Override public int compareTo( LocalExtreme o ) {
 			if (intensity < o.intensity) {
 				return 1;
 			} else if (intensity > o.intensity) {

main/boofcv-feature/src/main/java/boofcv/abst/feature/detect/extract/NonMaxSuppression.java

@@ -23,125 +23,94 @@
 import boofcv.struct.image.GrayF32;
 import org.jetbrains.annotations.Nullable;
 
-/**
- * <p>
- * Detects local minimums and/or maximums in an intensity image inside square regions. This is known as non-maximum
- * suppression. The detector can be configured to ignore pixels along the image border by a user specified distance.
- * Some implementations require candidate locations for the features. This allows for a sparse algorithm to be used,
- * resulting in a significant speed boost. Pixel values with a value of -Float.MAX_VALUE or Float.MAX_VALUE will
- * not be considered for local minimum/maximum, respectively. This is a good way to ignore previously detected
- * features.
- * </p>
- *
- * <p>
- * Not all implementations will search for both minimums or maximums. Be sure you are using the correct one. If
- * you don't intend on detecting a minimum or maximum pass in null for the candidate list and the output found list.
- * </p>
- *
- * <p>
- * An extractor which uses candidate features must always be provided them. However, an algorithm which does not
- * use candidate features will simply ignore that input and operate as usual. Can check capabilities at runtime
- * using the {@link #canDetectMinimums()} and {@link #canDetectMaximums()} functions.
- * </p>
- *
- * <p>
- * A border can be specified around the outside of the image in which extremes can't be detected. However, a pixel
- * outside this border can influence if a pixel is a maximum inside, if the local search radius extends that far.
- * This is specified by the border parameter and the valid region is defined as follows:<br>
- * border &le; x &lt; width-border AND border &le; y &lt; height-border</p>
- *
- * @author Peter Abeles
- */
+///
+/// Detects local minimums and/or maximums in an intensity image inside square regions. This is known as non-maximum
+/// suppression. The detector can be configured to ignore pixels along the image border by a user specified distance.
+/// Some implementations require candidate locations for the features. This allows for a sparse algorithm to be used,
+/// resulting in a significant speed boost. Pixel values with a value of -Float.MAX_VALUE or Float.MAX_VALUE will
+/// not be considered for local minimum/maximum, respectively. This is a good way to ignore previously detected
+/// features.
+///
+///
+/// Not all implementations will search for both minimums or maximums. Be sure you are using the correct one. If
+/// you don't intend on detecting a minimum or maximum pass in null for the candidate list and the output found list.
+///
+///
+/// An extractor which uses candidate features must always be provided them. However, an algorithm which does not
+/// use candidate features will simply ignore that input and operate as usual. Can check capabilities at runtime
+/// using the [#canDetectMinimums()] and [#canDetectMaximums()] functions.
+///
+///
+/// A border can be specified around the outside of the image in which extremes can't be detected. However, a pixel
+/// outside this border can influence if a pixel is a maximum inside, if the local search radius extends that far.
+/// This is specified by the border parameter and the valid region is defined as follows:
+/// border &le; x &lt; width-border AND border &le; y &lt; height-border
 public interface NonMaxSuppression {
 
-	/**
-	 * Process a feature intensity image to extract the point features. If a pixel has an intensity
-	 * value == -Float.MAX_VALUE  or Float.MAX_VALUE it will not be considered for a local min or max, respectively.
-	 * If an algorithm only detect local minimums or maximums and null can be passed in for unused lists. This is
-	 * the recommended procedure since it will force an exception to be thrown if a mistake was made.
-	 *
-	 * @param intensity (Input) Feature intensity image. Not modified.
-	 * @param candidateMin (Input) (Optional) List of candidate local minimum features. Can be null if not used.
-	 * @param candidateMax (Input) (Optional) List of candidate local maximum features  Can be null if not used.
-	 * @param foundMin (Output) Storage for found minimums. Can be null if not used.
-	 * @param foundMax (Output) Storage for found maximums. Can be null if not used.
-	 */
+	/// Process a feature intensity image to extract the point features. If a pixel has an intensity
+	/// value == -Float.MAX_VALUE  or Float.MAX_VALUE it will not be considered for a local min or max, respectively.
+	/// If an algorithm only detect local minimums or maximums and null can be passed in for unused lists. This is
+	/// the recommended procedure since it will force an exception to be thrown if a mistake was made.
+	///
+	/// @param intensity (Input) Feature intensity image. Not modified.
+	/// @param candidateMin (Input) (Optional) List of candidate local minimum features. Can be null if not used.
+	/// @param candidateMax (Input) (Optional) List of candidate local maximum features  Can be null if not used.
+	/// @param foundMin (Output) Storage for found minimums. Can be null if not used.
+	/// @param foundMax (Output) Storage for found maximums. Can be null if not used.
 	void process( GrayF32 intensity,
 				  @Nullable ListIntPoint2D candidateMin, @Nullable ListIntPoint2D candidateMax,
 				  @Nullable QueueCorner foundMin, @Nullable QueueCorner foundMax );
 
-	/**
-	 * Returns true if the algorithm requires a candidate list of corners.
-	 *
-	 * @return true if candidates are required.
-	 */
+	/// Returns true if the algorithm requires a candidate list of corners.
+	///
+	/// @return true if candidates are required.
 	boolean getUsesCandidates();
 
-	/**
-	 * Maximum value for detected minimums
-	 *
-	 * @return threshold for feature selection
-	 */
+	/// Maximum value for detected minimums
+	///
+	/// @return threshold for feature selection
 	float getThresholdMinimum();
 
-	/**
-	 * Minimum value for detected maximums
-	 *
-	 * @return threshold for feature selection
-	 */
+	/// Minimum value for detected maximums
+	///
+	/// @return threshold for feature selection
 	float getThresholdMaximum();
 
-	/**
-	 * Change the feature selection threshold for finding local minimums.
-	 *
-	 * @param threshold The new selection threshold.
-	 */
+	/// Change the feature selection threshold for finding local minimums.
+	///
+	/// @param threshold The new selection threshold.
 	void setThresholdMinimum( float threshold );
 
-	/**
-	 * Change the feature selection threshold for finding local maximums.
-	 *
-	 * @param threshold The new selection threshold.
-	 */
+	/// Change the feature selection threshold for finding local maximums.
+	///
+	/// @param threshold The new selection threshold.
 	void setThresholdMaximum( float threshold );
 
-	/**
-	 * Defines the region inside the image in which a pixel can be an extreme.
-	 * valid region is: border &le; x &lt; width-border AND border &le; y &lt; height-border
-	 *
-	 * @param border Border size in pixels.
-	 */
+	/// Defines the region inside the image in which a pixel can be an extreme.
+	/// valid region is: border &le; x &lt; width-border AND border &le; y &lt; height-border
+	///
+	/// @param border Border size in pixels.
 	void setIgnoreBorder( int border );
 
-	/**
-	 * Returns the size of the image border.
-	 *
-	 * @return border size
-	 */
+	/// Returns the size of the image border.
+	///
+	/// @return border size
 	int getIgnoreBorder();
 
-	/**
-	 * Species the search radius for the feature
-	 *
-	 * @param radius Radius in pixels
-	 */
+	/// Species the search radius for the feature
+	///
+	/// @param radius Radius in pixels
 	void setSearchRadius( int radius );
 
-	/**
-	 * Describes how large the region is that is being searched. The radius is the number of
-	 * pixels away from the center.
-	 *
-	 * @return Search radius
-	 */
+	/// Describes how large the region is that is being searched. The radius is the number of
+	/// pixels away from the center.
+	///
+	/// @return Search radius
 	int getSearchRadius();
 
-	/**
-	 * True if it can detect local maximums.
-	 */
+	/// True if it can detect local maximums.
 	boolean canDetectMaximums();
 
-	/**
-	 * True if it can detect local minimums.
-	 */
+	/// True if it can detect local minimums.
 	boolean canDetectMinimums();
 }