NonMaxSuppression

 - Code Formatting
 - Small but breaking API change
 - Local maximums can now be stored in different data structures

Author: lessthanoptimal

change.txt

@@ -8,8 +8,11 @@ Version Meaning: <compatible>.<feature>.<bug fix>
 
 ---------------------
 Date    : 2025/XX/YY
-Version : 1.2.5
+Version : 1.3.0
 
+- NonMaxSuppression
+  * Small but breaking API change
+  * Local maximums can now be stored in different data structures
 - ImageProcessingFragment
   * Support for warmup frames
 - Mean Blur

examples/src/main/java/boofcv/examples/features/ExampleNonMaximumSupression.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, Peter Abeles. All Rights Reserved.
+ * Copyright (c) 2025, Peter Abeles. All Rights Reserved.
  *
  * This file is part of BoofCV (http://boofcv.org).
  *
@@ -52,7 +52,7 @@ public class ExampleNonMaximumSupression {
 
 	public static BufferedImage renderNonMax( GrayF32 intensity, int radius, float threshold ) {
 		// Create and configure the feature detector
-		NonMaxSuppression nonmax = FactoryFeatureExtractor.nonmax(new ConfigExtract(radius, threshold));
+		NonMaxSuppression<QueueCorner> nonmax = FactoryFeatureExtractor.nonmax(new ConfigExtract(radius, threshold));
 
 		// We will only search for the maximums. Other variants will look for minimums or will exclude previous
 		// candidate detections from being detected twice

main/boofcv-feature/src/benchmark/java/boofcv/alg/feature/detect/extract/BenchmarkExtractors.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Peter Abeles. All Rights Reserved.
+ * Copyright (c) 2025, Peter Abeles. All Rights Reserved.
  *
  * This file is part of BoofCV (http://boofcv.org).
  *
@@ -49,26 +49,25 @@ public class BenchmarkExtractors {
 	//	@Param({"500","5000"})
 	public int width = 1000;
 
-//	@Param({"2", "5", "20"})
+	//	@Param({"2", "5", "20"})
 	@Param({"2", "20"})
 	public int radius;
 
 	GrayF32 intensity = new GrayF32(1, 1);
 	QueueCorner corners;
 
-	NonMaxSuppression blockStrictMax;
+	NonMaxSuppression<QueueCorner> blockStrictMax;
 
-	@Setup
-	public void setup() {
+	@Setup public void setup() {
 		BoofConcurrency.USE_CONCURRENT = concurrent;
 
 		intensity.reshape(width, width);
 		corners = new QueueCorner();
 
-		Random rand = new Random(234);
+		var rand = new Random(234);
 		ImageMiscOps.fillUniform(intensity, rand, 0, 200);
 
-		ConfigExtract config = new ConfigExtract();
+		var config = new ConfigExtract();
 		config.radius = radius;
 		config.detectMaximums = true;
 		config.detectMinimums = false;
@@ -77,50 +76,46 @@ public void setup() {
 		blockStrictMax = FactoryFeatureExtractor.nonmax(config);
 	}
 
-	@Benchmark
-	public void blockStrictMax() {
+	@Benchmark public void blockStrictMax() {
 		blockStrictMax.process(intensity, null, null, corners, corners);
 	}
 
-	@Benchmark
-	public void blockStrictMinMax() {
-		ConfigExtract config = new ConfigExtract();
+	@Benchmark public void blockStrictMinMax() {
+		var config = new ConfigExtract();
 		config.radius = radius;
 		config.detectMaximums = true;
 		config.detectMinimums = true;
 		config.threshold = threshold;
 		config.useStrictRule = true;
-		NonMaxSuppression alg = FactoryFeatureExtractor.nonmax(config);
+		NonMaxSuppression<QueueCorner> alg = FactoryFeatureExtractor.nonmax(config);
 		alg.process(intensity, null, null, corners, corners);
 	}
 
-	@Benchmark
-	public void blockRelaxedMax() {
-		ConfigExtract config = new ConfigExtract();
+	@Benchmark public void blockRelaxedMax() {
+		var config = new ConfigExtract();
 		config.radius = radius;
 		config.detectMaximums = true;
 		config.detectMinimums = false;
 		config.threshold = threshold;
 		config.useStrictRule = false;
-		NonMaxSuppression alg = FactoryFeatureExtractor.nonmax(config);
+		NonMaxSuppression<QueueCorner> alg = FactoryFeatureExtractor.nonmax(config);
 		alg.process(intensity, null, null, corners, corners);
 	}
 
-	@Benchmark
-	public void blockRelaxedMinMax() {
-		ConfigExtract config = new ConfigExtract();
+	@Benchmark public void blockRelaxedMinMax() {
+		var config = new ConfigExtract();
 		config.radius = radius;
 		config.detectMaximums = true;
 		config.detectMinimums = true;
 		config.threshold = threshold;
 		config.useStrictRule = false;
-		NonMaxSuppression alg = FactoryFeatureExtractor.nonmax(config);
+		NonMaxSuppression<QueueCorner> alg = FactoryFeatureExtractor.nonmax(config);
 		alg.process(intensity, null, null, corners, corners);
 	}
 
-	@Benchmark
-	public void naiveStrictMax() {
-		NonMaxExtractorNaive alg = new NonMaxExtractorNaive(true);
+	@Benchmark public void naiveStrictMax() {
+		var alg = new NonMaxExtractorNaive<QueueCorner>(true);
+		alg.storageAccess(QueueCorner::append, QueueCorner::reset);
 		alg.radius = radius;
 		alg.thresh = threshold;
 		alg.process(intensity, corners);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Peter Abeles. All Rights Reserved.
+ * Copyright (c) 2025, Peter Abeles. All Rights Reserved.
  *
  * This file is part of BoofCV (http://boofcv.org).
  *

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Peter Abeles. All Rights Reserved.
+ * Copyright (c) 2025, Peter Abeles. All Rights Reserved.
  *
  * This file is part of BoofCV (http://boofcv.org).
  *
@@ -20,8 +20,8 @@
 
 import boofcv.alg.feature.detect.selector.FeatureSelectLimitIntensity;
 import boofcv.alg.feature.detect.selector.SampleIntensity;
-import boofcv.struct.QueueCorner;
 import boofcv.struct.image.GrayF32;
+import georegression.struct.packed.PackedArrayPoint2D_I16;
 import georegression.struct.point.Point2D_I16;
 import lombok.Getter;
 import lombok.Setter;
@@ -34,14 +34,14 @@
 /// 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;
+	@Getter NonMaxSuppression<PackedArrayPoint2D_I16> nonmax;
 
 	/// Maximum number of features it can return. If %le; 0 then there will be no limit
 	@Getter @Setter int maxTotalFeatures;
 
 	// Detected minimums and maximums
-	QueueCorner originalMin = new QueueCorner();
-	QueueCorner originalMax = new QueueCorner();
+	PackedArrayPoint2D_I16 originalMin = new PackedArrayPoint2D_I16();
+	PackedArrayPoint2D_I16 originalMax = new PackedArrayPoint2D_I16();
 
 	// Selects features when too many are detected
 	FeatureSelectLimitIntensity<LocalExtreme> selector;
@@ -52,14 +52,15 @@ public class NonMaxLimiter {
 
 	/// Configures the limiter
 	///
-	/// @param nonmax Non-maximum suppression algorithm
+	/// @param nonmax Non-maximum suppression algorithm. Generic type does not matter.
 	/// @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 ) {
 		this.nonmax = nonmax;
 		this.selector = selector;
 		this.maxTotalFeatures = maxTotalFeatures;
+		this.nonmax.storageAccess(PackedArrayPoint2D_I16::append, PackedArrayPoint2D_I16::reset);
 
 		selector.setSampler(new SampleIntensity<>() {
 			@Override
@@ -81,16 +82,16 @@ public void process( GrayF32 intensity ) {
 		nonmax.process(intensity, null, null, originalMin, originalMax);
 
 		foundAll.reset();
-		for (int i = 0; i < originalMin.size; i++) {
-			Point2D_I16 p = originalMin.get(i);
+		for (int i = 0; i < originalMin.size(); i++) {
+			Point2D_I16 p = originalMin.getTemp(i);
 			float val = intensity.unsafe_get(p.x, p.y);
-			foundAll.grow().set(-val, false, p);
+			foundAll.grow().set(-val, false, p.x, p.y);
 		}
 
-		for (int i = 0; i < originalMax.size; i++) {
-			Point2D_I16 p = originalMax.get(i);
+		for (int i = 0; i < originalMax.size(); i++) {
+			Point2D_I16 p = originalMax.getTemp(i);
 			float val = intensity.unsafe_get(p.x, p.y);
-			foundAll.grow().set(val, true, p);
+			foundAll.grow().set(val, true, p.x, p.y);
 		}
 
 		if (maxTotalFeatures > 0) {
@@ -112,12 +113,12 @@ public static class LocalExtreme implements Comparable<LocalExtreme> {
 		public float intensity;
 		/// true if it was a maximum (positive) or minimum (negative intensity)
 		public boolean max;
-		public Point2D_I16 location;
+		public final Point2D_I16 location = new Point2D_I16();
 
-		public LocalExtreme set( float intensity, boolean max, Point2D_I16 location ) {
+		public LocalExtreme set( float intensity, boolean max, int x, int y ) {
 			this.intensity = intensity;
 			this.max = max;
-			this.location = location;
+			this.location.setTo(x, y);
 			return this;
 		}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Peter Abeles. All Rights Reserved.
+ * Copyright (c) 2025, Peter Abeles. All Rights Reserved.
  *
  * This file is part of BoofCV (http://boofcv.org).
  *
@@ -19,7 +19,6 @@
 package boofcv.abst.feature.detect.extract;
 
 import boofcv.struct.ListIntPoint2D;
-import boofcv.struct.QueueCorner;
 import boofcv.struct.image.GrayF32;
 import org.jetbrains.annotations.Nullable;
 
@@ -45,7 +44,10 @@
 /// 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 ≤ x < width-border AND border ≤ y < height-border
-public interface NonMaxSuppression {
+public interface NonMaxSuppression<Storage> {
+
+	/// Specifies how to manipulate the passed in storage objects
+	void storageAccess( Add<Storage> opAdd, Reset<Storage> opReset );
 
 	/// 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.
@@ -59,7 +61,7 @@ public interface NonMaxSuppression {
 	/// @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 );
+				  @Nullable Storage foundMin, @Nullable Storage foundMax );
 
 	/// Returns true if the algorithm requires a candidate list of corners.
 	///
@@ -113,4 +115,14 @@ void process( GrayF32 intensity,
 
 	/// True if it can detect local minimums.
 	boolean canDetectMinimums();
+
+	/// Adds a point to the storage
+	@FunctionalInterface interface Add<Storage> {
+		void add( Storage found, int x, int y );
+	}
+
+	/// Clears and resets the storage
+	@FunctionalInterface interface Reset<Storage> {
+		void reset( Storage found );
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Peter Abeles. All Rights Reserved.
+ * Copyright (c) 2025, Peter Abeles. All Rights Reserved.
  *
  * This file is part of BoofCV (http://boofcv.org).
  *
@@ -20,27 +20,30 @@
 
 import boofcv.alg.feature.detect.extract.NonMaxCandidate;
 import boofcv.struct.ListIntPoint2D;
-import boofcv.struct.QueueCorner;
 import boofcv.struct.image.GrayF32;
 import org.jetbrains.annotations.Nullable;
 
 /// Wrapper around the [boofcv.alg.feature.detect.extract.NonMaxCandidate] class.
-public class WrapperNonMaxCandidate implements NonMaxSuppression {
-	NonMaxCandidate extractor;
+public class WrapperNonMaxCandidate<Storage> implements NonMaxSuppression<Storage> {
+	NonMaxCandidate<Storage> extractor;
 	boolean minimums, maximums;
 
 	public WrapperNonMaxCandidate( NonMaxCandidate.Search search, boolean minimums, boolean maximums ) {
-		this.extractor = new NonMaxCandidate(search);
+		this.extractor = new NonMaxCandidate<>(search);
 		this.minimums = minimums;
 		this.maximums = maximums;
 	}
 
-	public WrapperNonMaxCandidate( NonMaxCandidate extractor, boolean minimums, boolean maximums ) {
+	public WrapperNonMaxCandidate( NonMaxCandidate<Storage> extractor, boolean minimums, boolean maximums ) {
 		this.extractor = extractor;
 		this.minimums = minimums;
 		this.maximums = maximums;
 	}
 
+	@Override public void storageAccess( Add<Storage> opAdd, Reset<Storage> opReset ) {
+		this.extractor.storageAccess(opAdd, opReset);
+	}
+
 	@Override public float getThresholdMinimum() {
 		return extractor.getThresholdMin();
 	}
@@ -66,8 +69,8 @@ public WrapperNonMaxCandidate( NonMaxCandidate extractor, boolean minimums, bool
 	}
 
 	@Override public void process( GrayF32 intensity,
-						 @Nullable ListIntPoint2D candidateMin, @Nullable ListIntPoint2D candidateMax,
-						 @Nullable QueueCorner foundMin, @Nullable QueueCorner foundMax ) {
+								   @Nullable ListIntPoint2D candidateMin, @Nullable ListIntPoint2D candidateMax,
+								   @Nullable Storage foundMin, @Nullable Storage foundMax ) {
 		extractor.process(intensity, candidateMin, candidateMax, foundMin, foundMax);
 	}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Peter Abeles. All Rights Reserved.
+ * Copyright (c) 2025, Peter Abeles. All Rights Reserved.
  *
  * This file is part of BoofCV (http://boofcv.org).
  *
@@ -27,18 +27,22 @@
 /// Wrapper around the [boofcv.alg.feature.detect.extract.NonMaxBlock] class.
 ///
 /// @author Peter Abeles
-public class WrapperNonMaximumBlock implements NonMaxSuppression {
+public class WrapperNonMaximumBlock<Storage> implements NonMaxSuppression<Storage> {
 
 	// specific implementation
-	NonMaxBlock alg;
+	NonMaxBlock<Storage> alg;
 
-	public WrapperNonMaximumBlock( NonMaxBlock alg ) {
+	public WrapperNonMaximumBlock( NonMaxBlock<Storage> alg ) {
 		this.alg = alg;
 	}
 
+	@Override public void storageAccess( Add<Storage> opAdd, Reset<Storage> opReset ) {
+		this.alg.storageAccess(opAdd, opReset);
+	}
+
 	@Override public void process( GrayF32 intensity,
 								   @Nullable ListIntPoint2D candidateMin, @Nullable ListIntPoint2D candidateMax,
-								   @Nullable QueueCorner foundMin, @Nullable QueueCorner foundMax ) {
+								   @Nullable Storage foundMin, @Nullable Storage foundMax ) {
 		alg.process(intensity, foundMin, foundMax);
 	}