Learning OpenCV Lecture 4 (Transforming Images with Morphological Operations)

In this chapter, we will cover:

• Eroding and dilating images using morphological filters
• Opening and closing images using morphological filters
• Detecting edges and corners using morphological filters
• Segmenting images using watersheds 分水岭算法
• Extracting foreground objects with the GrabCut algorithm

Eroding、dilating、Opening、closing

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

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

    // Display the image
     cv::namedWindow( "Image");
     cv::imshow( "Image",image);

      // Erode the image
     cv::Mat eroded;
     cv::erode(image,eroded,cv::Mat());

    // Display the eroded image
     cv::namedWindow( "Eroded Image");
     cv::imshow( "Eroded Image",eroded);

      // Dilate the image
     cv::Mat dilated;
     cv::dilate(image,dilated,cv::Mat());

    // Display the dialted image
     cv::namedWindow( "Dilated Image");
     cv::imshow( "Dilated Image",dilated);

      // Erode the image with a larger s.e.
     cv::Mat element(7,7,CV_8U,cv::Scalar(1));
     cv::erode(image,eroded,element);

    // Display the eroded image
     cv::namedWindow( "Eroded Image (7x7)");
     cv::imshow( "Eroded Image (7x7)",eroded);

      // Erode the image 3 times.
     cv::erode(image,eroded,cv::Mat(),cv::Point(-1,-1),3);

    // Display the eroded image
     cv::namedWindow( "Eroded Image (3 times)");
     cv::imshow( "Eroded Image (3 times)",eroded);

      // Close the image
     cv::Mat element5(5,5,CV_8U,cv::Scalar(1));
     cv::Mat closed;
     cv::morphologyEx(image,closed,cv::MORPH_CLOSE,element5);

    // Display the opened image
     cv::namedWindow( "Closed Image");
     cv::imshow( "Closed Image",closed);

      // Open the image
     cv::Mat opened;
     cv::morphologyEx(image,opened,cv::MORPH_OPEN,element5);

    // Display the opened image
     cv::namedWindow( "Opened Image");
     cv::imshow( "Opened Image",opened);

      // Close and Open the image
     cv::morphologyEx(image,image,cv::MORPH_CLOSE,element5);
     cv::morphologyEx(image,image,cv::MORPH_OPEN,element5);

    // Display the close/opened image
     cv::namedWindow( "Closed and Opened Image");
     cv::imshow( "Closed and Opened Image",image);
     cv::imwrite( "binaryGroup.bmp",image);

      // Read input image
     image= cv::imread("../binary.bmp");

      // Open and Close the image
     cv::morphologyEx(image,image,cv::MORPH_OPEN,element5);
     cv::morphologyEx(image,image,cv::MORPH_CLOSE,element5);

    // Display the close/opened image
     cv::namedWindow( "Opened and Closed Image");
     cv::imshow( "Opened and Closed Image",image);

     cv::waitKey();
      return 0;
}

　　results：

Detecting edges and corners using morphological filters

morphoFeatures.h

#if !defined MORPHOF
#define MORPHOF

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

class MorphoFeatures {
private:
      // threshold to produce binary image
      int threshold;
      // structuring elements used in corner detection
     cv::Mat cross;
     cv::Mat diamond;
     cv::Mat square;
     cv::Mat x;

public:

     MorphoFeatures() : threshold(-1),
                 cross(5, 5, CV_8U, cv::Scalar(0)),
                 diamond(5, 5, CV_8U, cv::Scalar(0)),
                 square(5, 5, CV_8U, cv::Scalar(0)),
                 x(5, 5, CV_8U, cv::Scalar(0)) {

            // Creating the cross-shaped structuring element
            for (int i = 0; i < 5; i++) {
                 cross.at<uchar>(2, i) = 1;
                 cross.at<uchar>(i, 2) = 1;
            }

            // Creating the diamond-shaped structuring element
            diamond.at<uchar>(0, 0) = 0;
            diamond.at<uchar>(0, 1) = 0;
            diamond.at<uchar>(1, 0) = 0;
            diamond.at<uchar>(4, 4) = 0;
            diamond.at<uchar>(3, 4) = 0;
            diamond.at<uchar>(4, 3) = 0;
            diamond.at<uchar>(4, 0) = 0;
            diamond.at<uchar>(4, 1) = 0;
            diamond.at<uchar>(3, 0) = 0;
            diamond.at<uchar>(0, 4) = 0;
            diamond.at<uchar>(0, 3) = 0;
            diamond.at<uchar>(1, 4) = 0;

            // Creating the x-shaped structuring element
            for (int i = 0; i < 5; i++) {
                 x.at<uchar>(i, i) = 1;
                 x.at<uchar>(4 - i, i) = 1;
            }
     }

      void setThreshold(int t) {
            if (t > 0)
                 threshold = t;
     }

      int getThreshold() const {
            return threshold;
     }

     cv::Mat getEdges(const cv::Mat &image) {
            // Get the gradient image
            cv::Mat result;
            cv::morphologyEx(image, result, cv::MORPH_GRADIENT, cv::Mat());

            // Apply threshold to obtain a binary image
            applyThreshold(result);
            return result;
     }

      void applyThreshold(cv::Mat &result) {
            // Apply threshold on result
            if (threshold > 0) {
                 cv::threshold(result, result, threshold, 255, cv::THRESH_BINARY_INV);
            }
     }

     cv::Mat getCorners(const cv::Mat &image) {

            cv::Mat result;

            // Dilate with a cross
            cv::dilate(image, result, cross);

            // Erode with a diamond
            cv::erode(result, result, diamond);

            cv::Mat result2;
            // Dilate with a x
            cv::dilate(image, result2, x);

            // Erode with a square
            cv::erode(result2, result2, square);

            // Corners are obtained by differencing
            // the two closed images
            cv::absdiff(result2, result, result);

            // Apply threshold to obtain a binary image
            applyThreshold(result);

            return result;
     }

      void drawOnImage(const cv::Mat &binary, cv::Mat &image) {
            cv::Mat_<uchar>::const_iterator it = binary.begin<uchar>();
            cv::Mat_<uchar>::const_iterator itend = binary.end<uchar>();

            // for each pixel
            for (int i = 0; it != itend; ++it, ++i) {
                 if (!*it) {
                      cv::circle(image,
                            cv::Point(i%image.step, i/image.step),
                            5, cv::Scalar(255, 0, 0));
                 }
            }
     }

};

#endif

　　morph.cpp

#include <iostream>

#include "morphoFeatures.h"

int main() {

     cv::Mat image = cv::imread( "../building.jpg");
     cv::cvtColor(image, image, CV_BGR2GRAY);

      // Create the morphological features instance
     MorphoFeatures morpho;
     morpho.setThreshold(40);

      // Get the edges
     cv::Mat edges;
     edges = morpho.getEdges(image);

     cv::namedWindow( "Edges Image", CV_WINDOW_AUTOSIZE);
     cv::imshow( "Edges Image", edges);

      // Get the corners
     cv::Mat corners;
     corners = morpho.getCorners(image);
      // Display the corner on the image
     morpho.drawOnImage(corners, image);
     cv::namedWindow( "Corners on Image", CV_WINDOW_AUTOSIZE);
     cv::imshow( "Corners on Image", image);

     cv::waitKey(0);

      return 0;

}

　　results:

Segmenting images using watersheds

watershedSegment.h

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

class WatershedSegmenter {
private:

     cv::Mat markers;

public:

      void setMarkers(const cv::Mat &markerImage) {
           
            // Convert to image of ints
            markerImage.convertTo(markers, CV_32S);
     }

     cv::Mat process(const cv::Mat &image) {

            // Apply watershed
            cv::watershed(image, markers);

            return markers;
     }

      // Return result in the form of an image
     cv::Mat getSegmentation() {

            cv::Mat tmp;
            // all segment with label higher than 255
            // will be assigned value 255
            markers.convertTo(tmp, CV_8U);

            return tmp;
     }

      // Return watershed in the form of an image
     cv::Mat getWatersheds() {
           
            cv::Mat tmp;
            // Each pixel p is transform into
            // 255p + 255 befor conversion
            markers.convertTo(tmp, CV_8U, 255, 255);

            return tmp;
     }
};

　　

// Read input image
     cv::Mat image = cv::imread( "../group.jpg");
      if (!image.data) {
            return 0;
     }

      // Display the image
     cv::namedWindow( "Original Image");
     cv::imshow( "Original Image", image);

      // Get the binary image
     cv::Mat binary;
     binary = cv::imread( "../binary.bmp", 0);

      // Display the binary image
     cv::namedWindow( "Binary Image");
     cv::imshow( "Binary Image", binary);

      // Eliminate noise and smaller objects
     cv::Mat fg;
     cv::erode(binary, fg, cv::Mat(), cv::Point(-1, -1), 6);

      // Display the foreground image
     cv::namedWindow( "Foreground Image");
     cv::imshow( "Foreground Image", fg);

　　results:

// Identify image pixels without objects
     cv::Mat bg;
     cv::dilate(binary, bg, cv::Mat(), cv::Point(-1, -1), 6);
     cv::threshold(bg, bg, 1, 128, cv::THRESH_BINARY_INV);

      // Display the backgroud image
     cv::namedWindow( "Background Image");
     cv::imshow( "Background Image", bg);

　　results:

// Show markers image
     cv::Mat markers(binary.size(), CV_8U, cv::Scalar(0));
     markers = fg + bg;
     cv::namedWindow( "Markers");
     cv::imshow( "Markers", markers);

　　

// Create watershed segmentation object
     WatershedSegmenter segmenter;

      // Set markers and process
     segmenter.setMarkers(markers);
     segmenter.process(image);

      // Display segmentation result
     cv::namedWindow( "Segmentation");
     cv::imshow( "Segmentation", segmenter.getSegmentation());

      // Display watersheds
     cv::namedWindow( "Watershed");
     cv::imshow( "Watershed", segmenter.getWatersheds());

　　

// Open another image------------------------------------
     image = cv::imread( "../tower.jpg");

      // Identify background pixels
     cv::Mat imageMask(image.size(), CV_8U, cv::Scalar(0));
     cv::rectangle(imageMask, cv::Point(5, 5), cv::Point(image.cols - 5, image.rows - 5), cv::Scalar(255), 3);
      // Identify forground pixels (in the middle of the image)
     cv::rectangle(imageMask, cv::Point(image.cols / 2 - 10, image.rows / 2 - 10),
                                      cv::Point(image.cols / 2 + 10, image.rows / 2 + 10), cv::Scalar(1), 10);

      // Set markers and process
     segmenter.setMarkers(imageMask);
     segmenter.process(image);

      // Display the image with markers
     cv::rectangle(image, cv::Point(5, 5), cv::Point(image.cols - 5, image.rows - 5), cv::Scalar(255, 255, 255), 3);
     cv::rectangle(image, cv::Point(image.cols / 2 - 10, image.rows / 2 - 10),
                                 cv::Point(image.cols / 2 + 10, image.rows / 2 + 10), cv::Scalar(1, 1, 1), 10);
     cv::namedWindow( "Image with marker");
     cv::imshow( "Image with marker", image);

      // Display watersheds
     cv::namedWindow( "Watersheds of foreground object");
     cv::imshow( "Watersheds of foreground object", segmenter.getWatersheds());

　　results:

Extracting foreground objects with the GrabCut algorithm

// Open another image
     image = cv::imread( "../tower.jpg");

      // define bounding rectange
     cv::Rect rectangle(50, 70, image.cols - 150, image.rows - 180);

     cv::Mat result;  // segmentation result (4 possible values)
     cv::Mat bgModel, fgModel; // the models (internally used)
      // GrabCut segmentation
     cv::grabCut(image,          // input image
            result,                     // segmentation result
            rectangle,            // rectangle containing foreground
            bgModel, fgModel,     // models
            1,                          //number of iterations
            cv::GC_INIT_WITH_RECT// use rectangle
            );

      // Get the pixles marked as likely foreground
     cv::compare(result, cv::GC_PR_FGD, result, cv::CMP_EQ);
      // Generate output image
     cv::Mat foreground(image.size(), CV_8UC3, cv::Scalar(255, 255, 255));
     image.copyTo(foreground, result); // bg pixels not copied

      // draw rectangle on original image
     cv::rectangle(image, rectangle, cv::Scalar(255,255,255),1);
     cv::namedWindow( "Image");
     cv::imshow( "Image",image);

      // display result
     cv::namedWindow( "Segmented Image");
     cv::imshow( "Segmented Image",foreground);

　　

// Open another image
     image= cv::imread("../group.jpg");

      // define bounding rectangle
     cv::Rect rectangle2(10,100,380,180);

     cv::Mat bkgModel,fgrModel; // the models (internally used)
      // GrabCut segmentation
     cv::grabCut(image,   // input image
            result, // segmentation result
           rectangle2,bkgModel,fgrModel,5,cv::GC_INIT_WITH_RECT);
      // Get the pixels marked as likely foreground
      //   cv::compare(result,cv::GC_PR_FGD,result,cv::CMP_EQ);
     result= result&1;
     foreground.create(image.size(),CV_8UC3);
     foreground.setTo(cv::Scalar(255,255,255));
     image.copyTo(foreground,result); // bg pixels not copied

      // draw rectangle on original image
     cv::rectangle(image, rectangle2, cv::Scalar(255,255,255),1);
     cv::namedWindow( "Image 2");
     cv::imshow( "Image 2",image);

      // display result
     cv::namedWindow( "Foreground objects");
     cv::imshow( "Foreground objects",foreground);