Subversion Repositories OpenCV2-Cookbook

/*------------------------------------------------------------------------------------------*\
   This file contains material supporting chapter 7 of the cookbook:  
   Computer Vision Programming using the OpenCV Library.
   by Robert Laganiere, Packt Publishing, 2011.

   This program is free software; permission is hereby granted to use, copy, modify,
   and distribute this source code, or portions thereof, for any purpose, without fee,
   subject to the restriction that the copyright notice may not be removed
   or altered from any source or altered source distribution.
   The software is released on an as-is basis and without any warranties of any kind.
   In particular, the software is not guaranteed to be fault-tolerant or free from failure.
   The author disclaims all warranties with regard to this software, any use,
   and any consequent failure, is purely the responsibility of the user.
 
   Copyright (C) 2010-2011 Robert Laganiere, www.laganiere.name
\*------------------------------------------------------------------------------------------*/

#include <iostream>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

int main()
{
        // Read input binary image
        cv::Mat image= cv::imread("../binaryGroup.bmp",0);
        if (!image.data)
                return 0;

        cv::namedWindow("Binary Image");
        cv::imshow("Binary Image",image);

        // Get the contours of the connected components
        std::vector<std::vector<cv::Point>> contours;
        cv::findContours(image,
                contours, // a vector of contours
                CV_RETR_EXTERNAL, // retrieve the external contours
                CV_CHAIN_APPROX_NONE); // retrieve all pixels of each contours

        // Print contours' length
        std::cout << "Contours: " << contours.size() << std::endl;
        std::vector<std::vector<cv::Point>>::const_iterator itContours= contours.begin();
        for ( ; itContours!=contours.end(); ++itContours) {

                std::cout << "Size: " << itContours->size() << std::endl;
        }

        // draw black contours on white image
        cv::Mat result(image.size(),CV_8U,cv::Scalar(255));
        cv::drawContours(result,contours,
                -1, // draw all contours
                cv::Scalar(0), // in black
                2); // with a thickness of 2

        cv::namedWindow("Contours");
        cv::imshow("Contours",result);

        // Eliminate too short or too long contours
        int cmin= 100;  // minimum contour length
        int cmax= 1000; // maximum contour length
        std::vector<std::vector<cv::Point>>::const_iterator itc= contours.begin();
        while (itc!=contours.end()) {

                if (itc->size() < cmin || itc->size() > cmax)
                        itc= contours.erase(itc);
                else
                        ++itc;
        }

        // draw contours on the original image
        cv::Mat original= cv::imread("../group.jpg");
        cv::drawContours(original,contours,
                -1, // draw all contours
                cv::Scalar(255,255,255), // in white
                2); // with a thickness of 2

        cv::namedWindow("Contours on Animals");
        cv::imshow("Contours on Animals",original);

        // Let's now draw black contours on white image
        result.setTo(cv::Scalar(255));
        cv::drawContours(result,contours,
                -1, // draw all contours
                cv::Scalar(0), // in black
                1); // with a thickness of 1
        image= cv::imread("../binaryGroup.bmp",0);

        // testing the bounding box
        cv::Rect r0= cv::boundingRect(cv::Mat(contours[0]));
        cv::rectangle(result,r0,cv::Scalar(0),2);

        // testing the enclosing circle
        float radius;
        cv::Point2f center;
        cv::minEnclosingCircle(cv::Mat(contours[1]),center,radius);
        cv::circle(result,cv::Point(center),static_cast<int>(radius),cv::Scalar(0),2);

//      cv::RotatedRect rrect= cv::fitEllipse(cv::Mat(contours[1]));
//      cv::ellipse(result,rrect,cv::Scalar(0),2);

        // testing the approximate polygon
        std::vector<cv::Point> poly;
        cv::approxPolyDP(cv::Mat(contours[2]),poly,5,true);

        std::cout << "Polygon size: " << poly.size() << std::endl;

        // Iterate over each segment and draw it
        std::vector<cv::Point>::const_iterator itp= poly.begin();
        while (itp!=(poly.end()-1)) {
                cv::line(result,*itp,*(itp+1),cv::Scalar(0),2);
                ++itp;
        }
        // last point linked to first point
        cv::line(result,*(poly.begin()),*(poly.end()-1),cv::Scalar(20),2);

        // testing the convex hull
        std::vector<cv::Point> hull;
        cv::convexHull(cv::Mat(contours[3]),hull);

        // Iterate over each segment and draw it
        std::vector<cv::Point>::const_iterator it= hull.begin();
        while (it!=(hull.end()-1)) {
                cv::line(result,*it,*(it+1),cv::Scalar(0),2);
                ++it;
        }
        // last point linked to first point
        cv::line(result,*(hull.begin()),*(hull.end()-1),cv::Scalar(20),2);

        // testing the moments

        // iterate over all contours
        itc= contours.begin();
        while (itc!=contours.end()) {

                // compute all moments
                cv::Moments mom= cv::moments(cv::Mat(*itc++));

                // draw mass center
                cv::circle(result,
                        // position of mass center converted to integer
                        cv::Point(mom.m10/mom.m00,mom.m01/mom.m00),
                        2,cv::Scalar(0),2); // draw black dot
        }

        cv::namedWindow("Some Shape descriptors");
        cv::imshow("Some Shape descriptors",result);

        // New call to findContours but with CV_RETR_LIST flag
        image= cv::imread("../binaryGroup.bmp",0);

        // Get the contours of the connected components
        cv::findContours(image,
                contours, // a vector of contours
                CV_RETR_LIST, // retrieve the external and internal contours
                CV_CHAIN_APPROX_NONE); // retrieve all pixels of each contours

        // draw black contours on white image
        result.setTo(cv::Scalar(255));
        cv::drawContours(result,contours,
                -1, // draw all contours
                cv::Scalar(0), // in black
                2); // with a thickness of 2
        cv::namedWindow("All Contours");
        cv::imshow("All Contours",result);

        cv::waitKey();
        return 0;
}