Example SURF Feature - Revision history

Peter at 20:59, 17 January 2022

2022-01-17T20:59:58Z

← Older revision		Revision as of 20:59, 17 January 2022
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.38/examples/src/main/java/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.40/examples/src/main/java/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:

Peter at 17:45, 12 July 2021

2021-07-12T17:45:48Z

Peter at 20:07, 21 December 2020

2020-12-21T20:07:01Z

← Older revision		Revision as of 20:07, 21 December 2020
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.33/examples/src/main/java/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.37/examples/src/main/java/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:
Line 17:		Line 17:
	*/		*/
	public class ExampleFeatureSurf {		public class ExampleFeatureSurf {

	/**		/**
	* Use generalized interfaces for working with SURF. This removes much of the drudgery, but also reduces flexibility		* Use generalized interfaces for working with SURF. This removes much of the drudgery, but also reduces flexibility
Line 26:		Line 25:
	public static void easy( GrayF32 image ) {		public static void easy( GrayF32 image ) {
	// create the detector and descriptors		// create the detector and descriptors
	DetectDescribePoint<GrayF32,~~BrightFeature~~> surf = FactoryDetectDescribe.		ConfigFastHessian configDetector = new ConfigFastHessian();
	surfStable(~~new ConfigFastHessian(0, 2, 200, 2, 9, 4, 4)~~, null, null,GrayF32.class);		configDetector.extract = new ConfigExtract(2, 0, 5, true);
			configDetector.maxFeaturesPerScale = 200;
			configDetector.initialSampleStep = 2;

			DetectDescribePoint<GrayF32,TupleDesc_F64> surf = FactoryDetectDescribe.
			surfStable(configDetector, null, null,GrayF32.class);

	// specify the image to process		// specify the image to process
Line 38:		Line 42:
	/**		/**
	* Configured exactly the same as the easy example above, but require a lot more code and a more in depth		* Configured exactly the same as the easy example above, but require a lot more code and a more in depth
	* understanding of how SURF works and is configured. ~~Instead of TupleDesc_F64, SurfFeature are computed in~~		* understanding of how SURF works and is configured. Each sub-problem which composes "SURF" is now explicitly
	* this case. They are almost the same as TupleDesc_F64, but contain the Laplacian's sign which ~~can be used~~		* created and configured independently. This allows an advance user to tune it for a specific problem.
	* ~~to speed up association~~. ~~That is~~ an ~~example of how using less generalized interfaces can improve performance~~.
	*		*
	* @param image Input image type. DOES NOT NEED TO BE GrayF32, GrayU8 works too		* @param image Input image type. DOES NOT NEED TO BE GrayF32, GrayU8 works too
Line 49:		Line 52:

	// define the feature detection algorithm		// define the feature detection algorithm
	~~NonMaxSuppression extractor~~ =		ConfigFastHessian config = new ConfigFastHessian();
	~~FactoryFeatureExtractor~~.~~nonmax(~~new ConfigExtract(2, 0, 5, true));		config.extract = new ConfigExtract(2, 0, 5, true);
	FastHessianFeatureDetector<II> detector =		config.maxFeaturesPerScale = 200;
	~~new FastHessianFeatureDetector<>~~(~~extractor, 200, 2, 9, 4, 4, 6~~);		config.initialSampleStep = 2;
			FastHessianFeatureDetector<II> detector = FactoryInterestPointAlgs.fastHessian(config);

	// estimate orientation		// estimate orientation
	OrientationIntegral<II> orientation =		OrientationIntegral<II> orientation = FactoryOrientationAlgs.sliding_ii(null, integralType);
	FactoryOrientationAlgs.sliding_ii(null, integralType);

	DescribePointSurf<II> descriptor = FactoryDescribePointAlgs.~~<II>~~surfStability(null,integralType);		DescribePointSurf<II> descriptor = FactoryDescribePointAlgs.surfStability(null,integralType);

	// compute the integral image of 'image'		// compute the integral image of 'image'
Line 70:		Line 73:
	descriptor.setImage(integral);		descriptor.setImage(integral);

	List<ScalePoint> points = detector.~~getFoundPoints~~();		List<ScalePoint> points = detector.getFoundFeatures();

	List<~~BrightFeature~~> descriptions = new ArrayList<>();		List<TupleDesc_F64> descriptions = new ArrayList<>();

	for( ScalePoint p : points ) {		for( ScalePoint p : points ) {
	// estimate orientation		// estimate orientation
	orientation.setObjectRadius( p.scale*BoofDefaults.SURF_SCALE_TO_RADIUS);		orientation.setObjectRadius( p.scale*BoofDefaults.SURF_SCALE_TO_RADIUS);
	double angle = orientation.compute(p.x,p.y);		double angle = orientation.compute(p.pixel.x,p.pixel.y);

	// extract the SURF description for this region		// extract the SURF description for this region
	~~BrightFeature~~ desc = descriptor.createDescription();		TupleDesc_F64 desc = descriptor.createDescription();
	descriptor.describe(p.x,p.y,angle,p.scale,desc);		descriptor.describe(p.pixel.x,p.pixel.y,angle,p.scale, true, desc);

	// save everything for processing later on		// save everything for processing later on
Line 91:		Line 94:
	}		}

	public static void main( String ~~args~~[] ) {		public static void main( String[] args ) {

	// Need to turn off concurrency since the order in which feature are returned		// Need to turn off concurrency since the order in which feature are returned
	// is not ~~determininistic~~ if turned on		// is not deterministic if turned on
	BoofConcurrency.USE_CONCURRENT = false;		BoofConcurrency.USE_CONCURRENT = false;

Line 104:		Line 106:

	System.out.println("Done!");		System.out.println("Done!");

	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Peter at 13:45, 15 March 2019

2019-03-15T13:45:31Z

← Older revision		Revision as of 13:45, 15 March 2019
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.33/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.33/examples/src/main/java/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:

Peter at 02:57, 15 March 2019

2019-03-15T02:57:31Z

← Older revision		Revision as of 02:57, 15 March 2019
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.27/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.33/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:
Line 92:		Line 92:

	public static void main( String args[] ) {		public static void main( String args[] ) {

			// Need to turn off concurrency since the order in which feature are returned
			// is not determininistic if turned on
			BoofConcurrency.USE_CONCURRENT = false;

	GrayF32 image = UtilImageIO.loadImage(UtilIO.pathExample("particles01.jpg"), GrayF32.class);		GrayF32 image = UtilImageIO.loadImage(UtilIO.pathExample("particles01.jpg"), GrayF32.class);

Peter at 15:40, 17 August 2017

2017-08-17T15:40:14Z

← Older revision		Revision as of 15:40, 17 August 2017
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.25/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.27/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:
Line 44:		Line 44:
	* @param image Input image type. DOES NOT NEED TO BE GrayF32, GrayU8 works too		* @param image Input image type. DOES NOT NEED TO BE GrayF32, GrayU8 works too
	*/		*/
	public static <II extends ImageGray> void harder(GrayF32 image ) {		public static <II extends ImageGray<II>> void harder(GrayF32 image ) {
	// SURF works off of integral images		// SURF works off of integral images
	Class<II> integralType = GIntegralImageOps.getIntegralType(GrayF32.class);		Class<II> integralType = GIntegralImageOps.getIntegralType(GrayF32.class);

Peter at 22:39, 1 December 2016

2016-12-01T22:39:27Z

← Older revision		Revision as of 22:39, 1 December 2016
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.23/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.25/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:
Line 7:		Line 7:
	* Region Descriptor		* Region Descriptor
	* Interest Point		* Interest Point

	~~Relevant Applets:~~
	* [[Applet_Point_Detected\| Detecting Interest Points]]
	* [[Applet_Description_Region\| Visualize Region Descriptors]]

	= Example Code =		= Example Code =
Line 55:		Line 51:
	NonMaxSuppression extractor =		NonMaxSuppression extractor =
	FactoryFeatureExtractor.nonmax(new ConfigExtract(2, 0, 5, true));		FactoryFeatureExtractor.nonmax(new ConfigExtract(2, 0, 5, true));
	FastHessianFeatureDetector<II> detector =		FastHessianFeatureDetector<II> detector =
	new FastHessianFeatureDetector<II>(extractor,200,2, 9,4,4,6);		new FastHessianFeatureDetector<>(extractor, 200, 2, 9, 4, 4, 6);

	// estimate orientation		// estimate orientation
Line 76:		Line 72:
	List<ScalePoint> points = detector.getFoundPoints();		List<ScalePoint> points = detector.getFoundPoints();

	List<BrightFeature> descriptions = new ArrayList<~~BrightFeature~~>();		List<BrightFeature> descriptions = new ArrayList<>();

	for( ScalePoint p : points ) {		for( ScalePoint p : points ) {

Peter at 05:20, 28 March 2016

2016-03-28T05:20:29Z

Peter at 05:03, 24 January 2016

2016-01-24T05:03:38Z

← Older revision		Revision as of 05:03, 24 January 2016
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.20/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.21/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:
Line 30:		Line 30:
	public static void easy( ImageFloat32 image ) {		public static void easy( ImageFloat32 image ) {
	// create the detector and descriptors		// create the detector and descriptors
	DetectDescribePoint<ImageFloat32,~~SurfFeature~~> surf = FactoryDetectDescribe.		DetectDescribePoint<ImageFloat32,BrightFeature> surf = FactoryDetectDescribe.
	surfStable(new ConfigFastHessian(0, 2, 200, 2, 9, 4, 4), null, null,ImageFloat32.class);		surfStable(new ConfigFastHessian(0, 2, 200, 2, 9, 4, 4), null, null,ImageFloat32.class);

Line 56:		Line 56:
	FactoryFeatureExtractor.nonmax(new ConfigExtract(2, 0, 5, true));		FactoryFeatureExtractor.nonmax(new ConfigExtract(2, 0, 5, true));
	FastHessianFeatureDetector<II> detector =		FastHessianFeatureDetector<II> detector =
	new FastHessianFeatureDetector<II>(extractor,200,2, 9,4,4);		new FastHessianFeatureDetector<II>(extractor,200,2, 9,4,4,6);

	// estimate orientation		// estimate orientation
Line 76:		Line 76:
	List<ScalePoint> points = detector.getFoundPoints();		List<ScalePoint> points = detector.getFoundPoints();

	List<~~SurfFeature~~> descriptions = new ArrayList<~~SurfFeature~~>();		List<BrightFeature> descriptions = new ArrayList<BrightFeature>();

	for( ScalePoint p : points ) {		for( ScalePoint p : points ) {
	// estimate orientation		// estimate orientation
	orientation.~~setScale~~(p.scale);		orientation.setObjectRadius( p.scale*BoofDefaults.SURF_SCALE_TO_RADIUS);
	double angle = orientation.compute(p.x,p.y);		double angle = orientation.compute(p.x,p.y);

	// extract the SURF description for this region		// extract the SURF description for this region
	~~SurfFeature~~ desc = descriptor.createDescription();		BrightFeature desc = descriptor.createDescription();
	descriptor.describe(p.x,p.y,angle,p.scale,desc);		descriptor.describe(p.x,p.y,angle,p.scale,desc);

Peter at 16:43, 9 November 2015

2015-11-09T16:43:28Z

← Older revision		Revision as of 16:43, 9 November 2015
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.16/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.20/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:
Line 97:		Line 97:
	public static void main( String args[] ) {		public static void main( String args[] ) {

	ImageFloat32 image = UtilImageIO.loadImage("~~../data/evaluation/~~particles01.jpg",ImageFloat32.class);		ImageFloat32 image = UtilImageIO.loadImage(UtilIO.pathExample("particles01.jpg"), ImageFloat32.class);

	// run each example		// run each example

← Older revision		Revision as of 17:45, 12 July 2021
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.37/examples/src/main/java/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.38/examples/src/main/java/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:
Line 18:		Line 18:
	public class ExampleFeatureSurf {		public class ExampleFeatureSurf {
	/**		/**
	* Use generalized interfaces for working with SURF. This removes much of the drudgery, but also reduces flexibility		* Use generalized interfaces for working with SURF. This removes much of the drudgery, but also reduces flexibility
	* and slightly increases memory and computational requirements.		* and slightly increases memory and computational requirements.
	*		*
Line 37:		Line 37:

	System.out.println("Found Features: "+surf.getNumberOfFeatures());		System.out.println("Found Features: "+surf.getNumberOfFeatures());
	System.out.println("First descriptor's first value: "+surf.getDescription(0).~~value~~[0]);		System.out.println("First descriptor's first value: "+surf.getDescription(0).data[0]);
	}		}

	/**		/**
	* Configured exactly the same as the easy example above, but require a lot more code and a more in depth		* Configured exactly the same as the easy example above, but require a lot more code and a more in depth
	* understanding of how SURF works and is configured. Each sub-problem which composes "SURF" is now explicitly		* understanding of how SURF works and is configured. Each sub-problem which composes "SURF" is now explicitly
	* created and configured independently. This allows an advance user to tune it for a specific problem.		* created and configured independently. This allows an advance user to tune it for a specific problem.
	*		*
	* @param image Input image type. DOES NOT NEED TO BE GrayF32, GrayU8 works too		* @param image Input image type. DOES NOT NEED TO BE GrayF32, GrayU8 works too
	*/		*/
Line 61:		Line 61:
	OrientationIntegral<II> orientation = FactoryOrientationAlgs.sliding_ii(null, integralType);		OrientationIntegral<II> orientation = FactoryOrientationAlgs.sliding_ii(null, integralType);

	DescribePointSurf<II> descriptor = ~~FactoryDescribePointAlgs~~.surfStability(null,integralType);		DescribePointSurf<II> descriptor = FactoryDescribeAlgs.surfStability(null,integralType);

	// compute the integral image of 'image'		// compute the integral image of 'image'
Line 91:		Line 91:

	System.out.println("Found Features: "+points.size());		System.out.println("Found Features: "+points.size());
	System.out.println("First descriptor's first value: "+descriptions.get(0).~~value~~[0]);		System.out.println("First descriptor's first value: "+descriptions.get(0).data[0]);
	}		}

← Older revision		Revision as of 05:20, 28 March 2016
Line 1:		Line 1:
	Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.		Speeded Up Robust Feature (SURF) is a region descriptor and interest point detector. Two different ways of using SURF are demonstrated in this example. The easy way uses a high level interface that is easy to work with, but sacrifices flexibility. The harder way directly creates the SURF classes, is more complex, and requires a better understanding of how the code works.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.21/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.23/examples/src/boofcv/examples/features/ExampleFeatureSurf.java ExampleFeatureSurf.java]

	Concepts:		Concepts:
Line 26:		Line 26:
	* and slightly increases memory and computational requirements.		* and slightly increases memory and computational requirements.
	*		*
	* @param image Input image type. DOES NOT NEED TO BE ~~ImageFloat32~~, ~~ImageUInt8~~ works too		* @param image Input image type. DOES NOT NEED TO BE GrayF32, GrayU8 works too
	*/		*/
	public static void easy( ~~ImageFloat32~~ image ) {		public static void easy( GrayF32 image ) {
	// create the detector and descriptors		// create the detector and descriptors
	DetectDescribePoint<~~ImageFloat32~~,BrightFeature> surf = FactoryDetectDescribe.		DetectDescribePoint<GrayF32,BrightFeature> surf = FactoryDetectDescribe.
	surfStable(new ConfigFastHessian(0, 2, 200, 2, 9, 4, 4), null, null,~~ImageFloat32~~.class);		surfStable(new ConfigFastHessian(0, 2, 200, 2, 9, 4, 4), null, null,GrayF32.class);

	// specify the image to process		// specify the image to process
Line 46:		Line 46:
	* to speed up association. That is an example of how using less generalized interfaces can improve performance.		* to speed up association. That is an example of how using less generalized interfaces can improve performance.
	*		*
	* @param image Input image type. DOES NOT NEED TO BE ~~ImageFloat32~~, ~~ImageUInt8~~ works too		* @param image Input image type. DOES NOT NEED TO BE GrayF32, GrayU8 works too
	*/		*/
	public static <II extends ~~ImageSingleBand~~> void harder( ~~ImageFloat32~~ image ) {		public static <II extends ImageGray> void harder(GrayF32 image ) {
	// SURF works off of integral images		// SURF works off of integral images
	Class<II> integralType = GIntegralImageOps.getIntegralType(~~ImageFloat32~~.class);		Class<II> integralType = GIntegralImageOps.getIntegralType(GrayF32.class);

	// define the feature detection algorithm		// define the feature detection algorithm
Line 97:		Line 97:
	public static void main( String args[] ) {		public static void main( String args[] ) {

	~~ImageFloat32~~ image = UtilImageIO.loadImage(UtilIO.pathExample("particles01.jpg"), ~~ImageFloat32~~.class);		GrayF32 image = UtilImageIO.loadImage(UtilIO.pathExample("particles01.jpg"), GrayF32.class);

	// run each example		// run each example