samples/cpp/geometry.cpp

An example program illustrates the use of cv::convexHull, cv::fitEllipse, cv::minEnclosingTriangle, cv::minEnclosingCircle and cv::minAreaRect.

/*******************************************************************************
 *
 * This program demonstrates various shape fitting techniques using OpenCV.
 * It reads an image, applies binary thresholding, and then detects contours.
 *
 * For each contour, it fits and draws several geometric shapes including
 * convex hulls, minimum enclosing circles, rectangles, triangles, and ellipses
 * using different fitting methods:
 *  1: OpenCV's original method fitEllipse which implements Fitzgibbon 1995 method.
 *  2: The Approximate Mean Square (AMS) method fitEllipseAMS  proposed by Taubin 1991
 *  3: The Direct least square (Direct) method fitEllipseDirect proposed by Fitzgibbon1999
 *
 * The results are displayed with unique colors
 * for each shape and fitting method for clear differentiation.
 *
 *
 *********************************************************************************/
 
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
#include <vector>
 
using namespace cv;
using namespace std;
 
const string hot_keys =
    "\n\nHot keys: \n"
    "\tESC - quit the program\n"
    "\tq - quit the program\n"
    "\tc - make the circle\n"
    "\tr - make the rectangle\n"
    "\th - make the convexhull\n"
    "\tt - make the triangle\n"
    "\te - make the ellipse\n"
    "\ta - make all shapes\n"
    "\t0 - use OpenCV's method for ellipse fitting\n"
    "\t1 - use Approximate Mean Square (AMS) method for ellipse fitting \n"
    "\t2 - use Direct least square (Direct) method for ellipse fitting\n";
 
static void help(char** argv)
{
    cout << "\nThis program demonstrates various shape fitting techniques on a set of points using functions: \n"
         << "minAreaRect(), minEnclosingTriangle(), minEnclosingCircle(), convexHull(), and ellipse().\n\n"
         << "Usage: " << argv[0] << " [--image_name=<image_path> Default: ellipses.jpg]\n\n";
    cout << hot_keys << endl;
}
 
void processImage(int, void*);
void drawShapes(Mat &img, const vector<Point> &points, int ellipseMethod, string shape);
void drawConvexHull(Mat &img, const vector<Point> &points);
void drawMinAreaRect(Mat &img, const vector<Point> &points);
void drawFittedEllipses(Mat &img, const vector<Point> &points, int ellipseMethod);
void drawMinEnclosingCircle(Mat &img, const vector<Point> &points);
void drawMinEnclosingTriangle(Mat &img, const vector<Point> &points);
 
// Shape fitting options
Mat image;
enum EllipseFittingMethod {
    OpenCV_Method,
    AMS_Method,
    Direct_Method
};
 
struct UserData {
    int sliderPos = 70;
    string shape = "--all";
    int ellipseMethod = OpenCV_Method;
};
 
const char* keys =
    "{help h          |            | Show help message }"
    "{@image          |ellipses.jpg| Path to input image file }";
 
int main(int argc, char** argv) {
 
    cv::CommandLineParser parser(argc, argv, keys);
    help(argv);
 
    if (parser.has("help"))
    {
        return 0;
    }
 
    UserData userData; // variable to pass all the necessary values to trackbar callback
 
    string filename = parser.get<string>("@image");
    image = imread(samples::findFile(filename), IMREAD_COLOR);  // Read the image from the specified path
 
    if (image.empty()) {
        cout << "Could not open or find the image" << endl;
        return -1;
    }
 
    namedWindow("Shapes", WINDOW_AUTOSIZE);  // Create a window to display the results
    createTrackbar("Threshold", "Shapes", NULL, 255, processImage, &userData);  // Create a threshold trackbar
    setTrackbarPos("Threshold", "Shapes", userData.sliderPos);
 
    for(;;) {
        char key = (char)waitKey(0);  // Listen for a key press
        if (key == 'q' || key == 27) break;  // Exit the loop if 'q' or ESC is pressed
 
        switch (key) {
            case 'h': userData.shape = "--convexhull"; break;
            case 'a': userData.shape = "--all"; break;
            case 't': userData.shape = "--triangle"; break;
            case 'c': userData.shape = "--circle"; break;
            case 'e': userData.shape = "--ellipse"; break;
            case 'r': userData.shape = "--rectangle"; break;
            case '0': userData.ellipseMethod = OpenCV_Method; break;
            case '1': userData.ellipseMethod = AMS_Method; break;
            case '2': userData.ellipseMethod = Direct_Method; break;
            default: break;  // Do nothing for other keys
        }
 
        processImage(userData.sliderPos, &userData);  // Process the image with the current settings
    }
 
    return 0;
}
 
// Function to draw the minimum enclosing circle around given points
void drawMinEnclosingCircle(Mat &img, const vector<Point> &points) {
    Point2f center;
    float radius = 0;
    minEnclosingCircle(points, center, radius);  // Find the enclosing circle
    // Draw the circle
    circle(img, center, cvRound(radius), Scalar(0, 0, 255), 2, LINE_AA);
}
 
// Function to draw the minimum enclosing triangle around given points
void drawMinEnclosingTriangle(Mat &img, const vector<Point> &points) {
    vector<Point> triangle;
    minEnclosingTriangle(points, triangle);  // Find the enclosing triangle
 
    if (triangle.size() != 3) {
        return;
    }
    // Use polylines to draw the triangle. The 'true' argument closes the triangle.
    polylines(img, triangle, true, Scalar(255, 0, 0), 2, LINE_AA);
 
}
 
// Function to draw the minimum area rectangle around given points
void drawMinAreaRect(Mat &img, const vector<Point> &points) {
    RotatedRect box = minAreaRect(points);  // Find the minimum area rectangle
    Point2f vtx[4];
    box.points(vtx);
    // Convert Point2f to Point because polylines expects a vector of Point
    vector<Point> rectPoints;
    for (int i = 0; i < 4; i++) {
        rectPoints.push_back(Point(cvRound(vtx[i].x), cvRound(vtx[i].y)));
    }
 
    // Use polylines to draw the rectangle. The 'true' argument closes the loop, drawing a rectangle.
    polylines(img, rectPoints, true, Scalar(0, 255, 0), 2, LINE_AA);
}
 
// Function to draw the convex hull of given points
void drawConvexHull(Mat &img, const vector<Point> &points) {
    vector<Point> hull;
    convexHull(points, hull, false);  // Find the convex hull
    // Draw the convex hull
    polylines(img, hull, true, Scalar(255, 255, 0), 2, LINE_AA);
}
 
inline static bool isGoodBox(const RotatedRect& box) {
    //size.height >= size.width awalys,only if the pts are on a line or at the same point,size.width=0
    return (box.size.height <= box.size.width * 30) && (box.size.width > 0);
}
 
// Function to draw fitted ellipses using different methods
void drawFittedEllipses(Mat &img, const vector<Point> &points, int ellipseMethod) {
    switch (ellipseMethod) {
        case OpenCV_Method: // Standard ellipse fitting
            {
                RotatedRect fittedEllipse = fitEllipse(points);
                if (isGoodBox(fittedEllipse)) {
                    ellipse(img, fittedEllipse, Scalar(255, 0, 255), 2, LINE_AA);
                }
                putText(img, "OpenCV", Point(img.cols - 80, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 0, 255), 2, LINE_AA);
            }
            break;
        case AMS_Method: // AMS ellipse fitting
            {
                RotatedRect fittedEllipseAMS = fitEllipseAMS(points);
                if (isGoodBox(fittedEllipseAMS)) {
                    ellipse(img, fittedEllipseAMS, Scalar(255, 0, 255), 2, LINE_AA);
                }
                putText(img, "AMS", Point(img.cols - 80, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 0, 255), 2, LINE_AA);
            }
            break;
        case Direct_Method: // Direct ellipse fitting
            {
                RotatedRect fittedEllipseDirect = fitEllipseDirect(points);
                if (isGoodBox(fittedEllipseDirect)) {
                    ellipse(img, fittedEllipseDirect, Scalar(255, 0, 255), 2, LINE_AA);
                }
                putText(img, "Direct", Point(img.cols - 80, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 0, 255), 2, LINE_AA);
            }
            break;
        default: // Default case falls back to OpenCV method
            {
                RotatedRect fittedEllipse = fitEllipse(points);
                if (isGoodBox(fittedEllipse)) {
                    ellipse(img, fittedEllipse, Scalar(255, 0, 255), 2, LINE_AA);
                }
                putText(img, "OpenCV (default)", Point(img.cols - 80, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 0, 255), 2, LINE_AA);
                cout << "Warning: Invalid ellipseMethod value. Falling back to default OpenCV method." << endl;
            }
        break;
    }
}
 
// Function to draw shapes
void drawShapes(Mat &img, const vector<Point> &points, int ellipseMethod, string shape) {
    if (shape == "--circle") {
        drawMinEnclosingCircle(img, points);
    } else if (shape == "--triangle") {
        drawMinEnclosingTriangle(img, points);
    } else if (shape == "--rectangle") {
        drawMinAreaRect(img, points);
    } else if (shape == "--convexhull") {
        drawConvexHull(img, points);
    } else if (shape == "--ellipse"){
        drawFittedEllipses(img, points, ellipseMethod);
    }
    else if (shape == "--all") {
        drawMinEnclosingCircle(img, points);
        drawMinEnclosingTriangle(img, points);
        drawMinAreaRect(img, points);
        drawConvexHull(img, points);
        drawFittedEllipses(img, points, ellipseMethod);
    }
}
 
// Main function to process the image based on the current trackbar position
void processImage(int position, void* userData){
 
    UserData* data = static_cast<UserData*>(userData);
 
    data->sliderPos = position;
 
    Mat processedImg = image.clone();  // Clone the original image for processing
    Mat gray;
    cvtColor(processedImg, gray, COLOR_BGR2GRAY);  // Convert to grayscale
    threshold(gray, gray, data->sliderPos, 255, THRESH_BINARY);  // Apply binary threshold
 
    Mat filteredImg;
    medianBlur(gray, filteredImg, 3);
 
    vector<vector<Point>> contours;
    findContours(filteredImg, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);  // Find contours
 
    if (contours.empty()) {
        return;
    }
 
    imshow("Mask", filteredImg);  // Show the mask
    for (size_t i = 0; i < contours.size(); ++i) {
        if (contours[i].size() < 5) {  // Check if the contour has enough points
            continue;
        }
        drawShapes(processedImg, contours[i], data->ellipseMethod, data->shape);
    }
 
    imshow("Shapes", processedImg);  // Display the processed image with fitted shapes
}