docs: private void findLocalScaleSpaceMax(int []size, int level, int skip) {
  		int index0 = spaceIndex;
  		int index1 = (spaceIndex + 1) % 3;
  		int index2 = (spaceIndex + 2) % 3;
  
  		ImageBorder_F32 inten0 = (ImageBorder_F32)FactoryImageBorderAlgs.value(intensity[index0], 0);
  		GrayF32 inten1 = intensity[index1];
  		ImageBorder_F32 inten2 = (ImageBorder_F32)FactoryImageBorderAlgs.value(intensity[index2], 0);
  
  		// find local maximums in image 2D space.  Borders need to be ignored since
  		// false positives are found around them as an artifact of pixels outside being
  		// treated as being zero.
  		foundFeatures.reset();
  		extractor.setIgnoreBorder(size[level] / (2 * skip));
  		extractor.process(intensity[index1],null,null,null,foundFeatures);
  
  		// Can't consider feature which are right up against the border since they might not be a true local
  		// maximum when you consider the features on the other side of the ignore border
  		int ignoreRadius = extractor.getIgnoreBorder() + extractor.getSearchRadius();
  		int ignoreWidth = intensity[index1].width-ignoreRadius;
  		int ignoreHeight = intensity[index1].height-ignoreRadius;
  
  		// number of features which can be added
  		int numberRemaining;
  
  		// if configured to do so, only select the features with the highest intensity
  		QueueCorner features;
  		if( sortBest != null ) {
  			sortBest.process(intensity[index1],foundFeatures,true);
  			features = sortBest.getBestCorners();
  			numberRemaining = maxFeaturesPerScale;
  		} else {
  			features = foundFeatures;
  			numberRemaining = Integer.MAX_VALUE;
  		}
  
  		int levelSize = size[level];
  		int sizeStep = levelSize-size[level-1];
  
  		// see if these local maximums are also a maximum in scale-space
  		for( int i = 0; i < features.size && numberRemaining > 0; i++ ) {
  			Point2D_I16 f = features.get(i);
  
  			// avoid false positives.  see above comment
  			if( f.x < ignoreRadius || f.x >= ignoreWidth || f.y < ignoreRadius || f.y >= ignoreHeight )
  				continue;
  
  			float val = inten1.get(f.x,f.y);
  
  			// see if it is a max in scale-space too
  			if( checkMax(inten0,val,f.x,f.y) && checkMax(inten2,val,f.x,f.y) ) {
  
  				// find the feature's location to sub-pixel accuracy using a second order polynomial
  				// NOTE: In the original paper this was done using a quadratic.  See comments above.
  				// NOTE: Using a 2D polynomial for x and y might produce better results.
  				float peakX = polyPeak(inten1.get(f.x-1,f.y),inten1.get(f.x,f.y),inten1.get(f.x+1,f.y));
  				float peakY = polyPeak(inten1.get(f.x,f.y-1),inten1.get(f.x,f.y),inten1.get(f.x,f.y+1));
  				float peakS = polyPeak(inten0.get(f.x,f.y),inten1.get(f.x,f.y),inten2.get(f.x,f.y));
  
  				float interpX = (f.x+peakX)*skip;
  				float interpY = (f.y+peakY)*skip;
  				float interpS = levelSize+peakS*sizeStep;
  
  				double scale =  1.2*interpS/9.0;
  				foundPoints.grow().set(interpX,interpY,scale);
  				numberRemaining--;
  			}
  		}
  	}