View source for Example Detect Black Polygons


[[File:Detected_black_polygons.jpg|center|border|Red lines outline detected polygons.  Was configured to find objects with 3 to 5 sides.]]

BinaryPolygonDetector is used by most of the fiducials in BoofCV.  What it does is detects black polygons inside the image and then refines that estimate to within subpixel precision.  It does this quickly, robustly, and very accurately. 

Example Code:
* [https://github.com/lessthanoptimal/BoofCV/blob/v0.38/examples/src/main/java/boofcv/examples/features/ExampleDetectBlackPolygon.java ExampleDetectBlackPolygon.java]

Concepts:
* Polygons
* Fiducials

Related Examples
* [[Example_Detect_Black_Ellipses|Black Ellipses]]
* [[Example_Fiducial_Square_Binary| Square Binary Fiducial]]
* [[Example_Fiducial_Square_Image| Square Image Fiducial]]
* [[Example_Detect_Calibration_Target| Calibration Target]]

= Example Code =

<syntaxhighlight lang="java">
/**
 * Example of how to use {@link DetectPolygonFromContour} to find black polygons in an image. This algorithm
 * is the basis for several fiducial detectors in BoofCV and fits the polygon to sub-pixel accuracy and produces
 * reasonable results on blurred images too. It is highly configurable and can even sparsely fit polygons
 * in a distorted image. Meaning the expensive step of undistorting the entire image is not needed.
 *
 * @author Peter Abeles
 */
public class ExampleDetectBlackPolygon {
	public static void main(String[] args) {
		String[] imagesConvex = new String[]{
				"shapes/polygons01.jpg",
				"shapes/shapes02.png",
				"fiducial/image/examples/image01.jpg"};

		String[] imagesConcave = new String[]{
				"shapes/concave01.jpg"};

		ListDisplayPanel panel = new ListDisplayPanel();

		// first configure the detector to only detect convex shapes with 3 to 7 sides
		ConfigPolygonDetector config = new ConfigPolygonDetector(3,7);
		DetectPolygonBinaryGrayRefine<GrayU8> detector = FactoryShapeDetector.polygon(config, GrayU8.class);

		processImages(imagesConvex, detector, panel);

		// now lets detect concave shapes with many sides
		config.detector.contourToPoly.maximumSides = 12;
		config.detector.contourToPoly.convex = false;
		detector = FactoryShapeDetector.polygon(config, GrayU8.class);

		processImages(imagesConcave, detector, panel);

		ShowImages.showWindow(panel,"Found Polygons",true);
	}

	private static void processImages(String[] files,
									  DetectPolygonBinaryGrayRefine<GrayU8> detector,
									  ListDisplayPanel panel)
	{
		for( String fileName : files ) {
			BufferedImage image = UtilImageIO.loadImage(UtilIO.pathExample(fileName));

			GrayU8 input = ConvertBufferedImage.convertFromSingle(image, null, GrayU8.class);
			GrayU8 binary = new GrayU8(input.width,input.height);

			// Binarization is done outside to allows creative tricks. For example, when applied to a chessboard
			// pattern where square touch each other, the binary image is eroded first so that they don't touch.
			// The squares are expanded automatically during the subpixel optimization step.
			int threshold = (int)GThresholdImageOps.computeOtsu(input, 0, 255);
			ThresholdImageOps.threshold(input, binary, threshold, true);

			// it takes in a grey scale image and binary image
			// the binary image is used to do a crude polygon fit, then the grey image is used to refine the lines
			// using a sub-pixel algorithm
			detector.process(input, binary);

			// visualize results by drawing red polygons
			java.util.List<Polygon2D_F64> found = detector.getPolygons(null,null);
			Graphics2D g2 = image.createGraphics();
			g2.setStroke(new BasicStroke(5));
			for (int i = 0; i < found.size(); i++) {
				g2.setColor(Color.RED);
				VisualizeShapes.drawPolygon(found.get(i), true, g2, true);
				g2.setColor(Color.CYAN);
				VisualizeShapes.drawPolygonCorners(found.get(i), 3, g2, true);
			}

			panel.addImage(image,new File(fileName).getName());
		}
	}
}
</syntaxhighlight>