Merge pull request #64 from oreillymedia/chap12extras

Added new examples to chapter 12

Author: garybradski

CMakeLists.txt

@@ -55,6 +55,8 @@ add_executable( example_11-02 example_11-02.cpp )
 add_executable( example_11-03 example_11-03.cpp )
 add_executable( example_12-01 example_12-01.cpp )
 add_executable( example_12-02 example_12-02.cpp )
+add_executable( example_12-03 example_12-03.cpp )
+add_executable( example_12-04 example_12-04.cpp )
 add_executable( example_13-01 example_13-01.cpp )
 add_executable( example_13-02 example_13-02.cpp )
 add_executable( example_13-03 example_13-03.cpp )
@@ -133,6 +135,8 @@ target_link_libraries( example_11-02 ${OpenCV_LIBS} )
 target_link_libraries( example_11-03 ${OpenCV_LIBS} )
 target_link_libraries( example_12-01 ${OpenCV_LIBS} )
 target_link_libraries( example_12-02 ${OpenCV_LIBS} )
+target_link_libraries( example_12-03 ${OpenCV_LIBS} )
+target_link_libraries( example_12-04 ${OpenCV_LIBS} )
 target_link_libraries( example_13-01 ${OpenCV_LIBS} )
 target_link_libraries( example_13-02 ${OpenCV_LIBS} )
 target_link_libraries( example_13-03 ${OpenCV_LIBS} )

example_12-01.cpp

@@ -1,61 +1,64 @@
-// Example 12-1. Using cv::dft() and cv::idft() to accelerate the computation of
-// convolutions 
+// Example 12-1. Using cv::dft() and cv::idft() to accelerate
+// the computation of convolutions 
 
-
-#include <opencv2/opencv.hpp>
 #include <iostream>
+#include <opencv2/opencv.hpp>
 
-using namespace std;
+using std::cout;
+using std::endl;
 
 int main(int argc, char** argv) {
+    if (argc != 2) {
+        cout    << "\nExample 12-1. Using cv::dft() and cv::idft() to accelerate the"
+                << "\n computation of convolutions"
+                << "\nFourier Transform\nUsage: "
+                << argv[0] << " <path/imagename>\n" << endl;
+        return -1;
+    }
 
-  if(argc != 2) {
-	cout 	<< "\nExample 12-1. Using cv::dft() and cv::idft() to accelerate the"
-			<< "\n computation of convolutions"
-			<< "\nFourier Transform\nUsage: " <<argv[0] <<" <path/imagename>\n" << endl;
-    return -1;
-  }
-
-  cv::Mat A = cv::imread(argv[1],0);
+    cv::Mat A = cv::imread(argv[1], 0);
 
-  if( A.empty() ) { cout << "Cannot load " << argv[1] << endl; return -1; }
+    if (A.empty()) {
+        cout << "Cannot load " << argv[1] << endl;
+        return -1;
+    }
 
-  cv::Size patchSize( 100, 100 );
-  cv::Point topleft( A.cols/2, A.rows/2 );
-  cv::Rect roi( topleft.x, topleft.y, patchSize.width, patchSize.height );
-  cv::Mat B = A( roi );
+    cv::Size patchSize(100, 100);
+    cv::Point topleft(A.cols / 2, A.rows /2);
+    cv::Rect roi(topleft.x, topleft.y, patchSize.width, patchSize.height);
+    cv::Mat B = A(roi);
 
-  int dft_M = cv::getOptimalDFTSize( A.rows+B.rows-1 );
-  int dft_N = cv::getOptimalDFTSize( A.cols+B.cols-1 );
+    int dft_M = cv::getOptimalDFTSize(A.rows + B.rows - 1);
+    int dft_N = cv::getOptimalDFTSize(A.cols + B.cols - 1);
 
-  cv::Mat dft_A = cv::Mat::zeros( dft_M, dft_N, CV_32F );
-  cv::Mat dft_B = cv::Mat::zeros( dft_M, dft_N, CV_32F );
+    cv::Mat dft_A = cv::Mat::zeros(dft_M, dft_N, CV_32F);
+    cv::Mat dft_B = cv::Mat::zeros(dft_M, dft_N, CV_32F);
 
-  cv::Mat dft_A_part = dft_A( cv::Rect(0, 0, A.cols,A.rows) );
-  cv::Mat dft_B_part = dft_B( cv::Rect(0, 0, B.cols,B.rows) );
+    cv::Mat dft_A_part = dft_A(cv::Rect(0, 0, A.cols, A.rows));
+    cv::Mat dft_B_part = dft_B(cv::Rect(0, 0, B.cols, B.rows));
 
-  A.convertTo( dft_A_part, dft_A_part.type(), 1, -mean(A)[0] );
-  B.convertTo( dft_B_part, dft_B_part.type(), 1, -mean(B)[0] );
+    A.convertTo(dft_A_part, dft_A_part.type(), 1, -mean(A)[0]);
+    B.convertTo(dft_B_part, dft_B_part.type(), 1, -mean(B)[0]);
 
-  cv::dft( dft_A, dft_A, 0, A.rows );
-  cv::dft( dft_B, dft_B, 0, B.rows );
+    cv::dft(dft_A, dft_A, 0, A.rows);
+    cv::dft(dft_B, dft_B, 0, B.rows);
 
-  // set the last parameter to false to compute convolution instead of correlation
-  //
-  cv::mulSpectrums( dft_A, dft_B, dft_A, 0, true );
-  cv::idft( dft_A, dft_A, cv::DFT_SCALE, A.rows + B.rows - 1 );
+    // set the last parameter to false to compute convolution instead of correlation
+    //
+    cv::mulSpectrums(dft_A, dft_B, dft_A, 0, true);
+    cv::idft(dft_A, dft_A, cv::DFT_SCALE, A.rows + B.rows - 1);
 
-  cv::Mat corr = dft_A( cv::Rect(0, 0, A.cols + B.cols - 1, A.rows + B.rows - 1) );
-  cv::normalize( corr, corr, 0, 1, cv::NORM_MINMAX, corr.type() );
-  cv::pow( corr, 3., corr );
+    cv::Mat corr = dft_A(cv::Rect(0, 0, A.cols + B.cols - 1, A.rows + B.rows - 1));
+    cv::normalize(corr, corr, 0, 1, cv::NORM_MINMAX, corr.type());
+    cv::pow(corr, 3.0, corr);
 
-  B ^= cv::Scalar::all( 255 );
+    B ^= cv::Scalar::all(255);
 
-  cv::imshow( "Image", A );
-  cv::imshow( "ROI", B );
+    cv::imshow("Image", A);
+    cv::imshow("ROI", B);
 
-  cv::imshow( "Correlation", corr );
-  cv::waitKey();
+    cv::imshow("Correlation", corr);
+    cv::waitKey();
 
-  return 0;
+    return 0;
 }

example_12-02.cpp

@@ -1,45 +1,54 @@
 // Example 12-2. Using cv::HoughCircles() to return a sequence of circles found in a
 // grayscale image
 
-#include <opencv2/opencv.hpp>
-#include <iostream>
 #include <math.h>
 
-using namespace cv;
-using namespace std;
-
-int main(int argc, char** argv) {
-
-  if(argc != 2) {
-	cout 	<< "\nExample 12-1. Using cv::dft() and cv::idft() to accelerate the computation of convolutions"  
-			<< "\nHough Circle detect\nUsage: " <<argv[0] <<" <path/imagename>\n" << endl;
-  return -1;
-  }
-
-  cv::Mat src, image;
-
-  src = cv::imread( argv[1], 1 );
-  if( src.empty() ) { cout << "Cannot load " << argv[1] << endl; return -1; }
-
-  cv::cvtColor(src, image, cv::COLOR_BGR2GRAY);
-  cv::GaussianBlur(image, image, Size(5,5), 0, 0);
+#include <iostream>
+#include <vector>
 
-  vector<cv::Vec3f> circles;
-  cv::HoughCircles(image, circles, cv::HOUGH_GRADIENT, 2, image.cols/4);
+#include <opencv2/opencv.hpp>
 
-  for( size_t i = 0; i < circles.size(); ++i ) {
-    cv::circle(
-      src,
-      cv::Point(cvRound(circles[i][0]), cvRound(circles[i][1])),
-      cvRound(circles[i][2]),
-      cv::Scalar(0,0,255),
-      2,
-      cv::LINE_AA
-    );
-  }
+using std::cout;
+using std::endl;
+using std::vector;
 
-  cv::imshow( "Hough Circles", src);
-  cv::waitKey(0);
+void help(char** argv) {
+        cout  << "\nExample 12-1. Using cv::dft() and cv::idft() to accelerate the computation of convolutions"  
+              << "\nHough Circle detect\nUsage: " << argv[0] <<" <path/imagename>\n" 
+              << "Example:\n" << argv[0] << " ../stuff.jpg\n" << endl;
+}
 
-  return 0;
+int main(int argc, char** argv) {
+	help(argv);
+    if (argc != 2) {
+        return -1;
+    }
+
+    cv::Mat src, image;
+
+    src = cv::imread(argv[1], 1);
+    if (src.empty()) {
+        cout << "Cannot load " << argv[1] << endl;
+        return -1;
+    }
+
+    cv::cvtColor(src, image, cv::COLOR_BGR2GRAY);
+    cv::GaussianBlur(image, image, cv::Size(5, 5), 0, 0);
+
+    vector<cv::Vec3f> circles;
+    cv::HoughCircles(image, circles, cv::HOUGH_GRADIENT, 2, image.cols/4);
+
+    for (size_t i = 0; i < circles.size(); ++i) {
+        cv::circle(src,
+            cv::Point(cvRound(circles[i][0]), cvRound(circles[i][1])),
+            cvRound(circles[i][2]),
+            cv::Scalar(0, 0, 255),
+            2,
+            cv::LINE_AA);
+    }
+
+    cv::imshow("Hough Circles", src);
+    cv::waitKey(0);
+
+    return 0;
 }

example_12-03.cpp

@@ -0,0 +1,121 @@
+// Example 12-3. Using GrabCut for background removal
+
+#include <iostream>
+#include <string>
+#include <opencv2/opencv.hpp>
+
+using std::cout;
+using std::cerr;
+using std::endl;
+
+cv::Mat img_preview;
+cv::Mat img;
+cv::Mat markers;
+cv::Mat drawRect;
+int x_0 = -1;
+int y_0 = -1; 
+int x_1, y_1;
+int drawr = 0;
+
+bool finished;
+
+void displayResult() {
+    int rows = img.rows;
+    int cols = img.cols;
+    cv::Vec3b blackClr(0, 0, 0);
+    for (int i = 0; i < rows; ++i) {
+        for (int j = 0; j < cols; ++j) {
+            if (markers.at<uchar>(i, j) != cv::GC_FGD && markers.at<uchar>(i, j) != cv::GC_PR_FGD) {
+                img.at<cv::Vec3b>(i, j) = blackClr;
+            }
+        }
+    }
+    cv::imshow("image", img);
+    finished = true;
+}
+
+static void onMouseClick(int event, int x, int y, int, void*) {
+    if (finished) {
+        return;
+    }
+
+    if (event == cv::EVENT_LBUTTONDOWN && drawr == 0) {
+		if(x_0 < 0) {
+			x_0 = x;
+			y_0 = y;
+			cv::ellipse(markers, cv::Point(x, y), cv::Size(1, 1),
+            0, 0, 360, cv::GC_FGD, 3);
+			cv::ellipse(drawRect, cv::Point(x, y), cv::Size(1, 1),
+            0, 0, 360, cv::Scalar(0, 0, 255), 3);
+            drawr = 1;
+		} 
+ 
+        cv::addWeighted(img,0.7,drawRect,0.3, 0, img_preview);
+    
+        cv::imshow("image", img_preview);
+        return;
+    }
+    if( event == cv::EVENT_LBUTTONUP) {
+		drawr = 2;
+	}
+    if(drawr == 1) { //Just moving
+			drawRect.setTo(0);
+			cv::rectangle(drawRect, cv::Point(x_0,y_0), cv::Point(x,y), cv::Scalar(0,0,255), -1);
+ 
+			cv::addWeighted(img,0.7,drawRect,0.3, 0, img_preview);
+			x_1 = x; y_1 = y;    
+			cv::imshow("image", img_preview);
+			return;
+	}
+
+    if (drawr == 2) {
+        cv::Mat bg;
+        cv::Mat fg;
+        cv::rectangle(markers, cv::Point(x_0,y_0), cv::Point(x_1,y_1), cv::GC_PR_FGD, -1);
+        cv::grabCut(img, markers, cv::Rect(0, 0, img.cols - 1, img.rows - 1),
+            bg, fg, 5, cv::GC_EVAL);
+        displayResult();
+        return;
+    }
+}
+
+void help(char** argv) {
+        cout << "\nExample 12-3. Using GrabCut for background removal"
+             << "\n- Use left mouse to drag a rectangle over the object"
+             << "\n- On release of left mouse button, we will perform GrabCut"
+             << "\n- Press any key to terminate program"
+             << "\nUsage: "
+             << argv[0] << " <path/imagename>\n" 
+             << "\nExample:\n" << argv[0] << " ../stuff.jpg\n" << endl;
+}
+
+
+int main(int argc, char** argv) {
+	help(argv);
+    if (argc != 2) {
+        return -1;
+    }
+
+    img = cv::imread(std::string(argv[1]), CV_LOAD_IMAGE_COLOR);
+    if (img.channels() != 3) {
+        cerr << "Input image should have 3 channels" << endl;
+        exit(1);
+    }
+
+    markers = cv::Mat(img.size(), CV_8UC1);
+    markers.setTo(cv::GC_PR_BGD);
+
+    img_preview = img.clone();
+    drawRect = img.clone();
+
+    finished = false;
+
+    cv::namedWindow("image", cv::WINDOW_AUTOSIZE);
+    cv::setMouseCallback("image", onMouseClick, 0);
+
+    cv::imshow("image", img_preview);
+
+    cv::waitKey(0);
+
+    return 0;
+}