title: Regarding a specific Object Detection in OpenCV using WebCam and comparing it with an input Image
body: <p>I am new to OpenCV and want to develop a program which takes the camera input and compares it with a known image of an object which would be input to it as a .jpg image and if the input of the Webcam matches with the fed in image upto a certain level of accuracy, then some message etc should be displayed that the required object has been found. 
  Eg: If I get a Computer Cable before the webcam, it needs to be detected and compared to the image of the Computer cable I have fed into the program.</p>
  
  <p>I've tried many techniques and find Template matching to be effective as mentioned in the foll0wing link---
  <a href="https://stackoverflow.com/questions/20180073/real-time-template-matching-opencv-c">Real-time template matching - OpenCV, C++</a></p>
  
  <p>However after drawing the rectangle and getting the roiImage..I want to compare its likeliness with a known image on my disk(in the opencv working directory). For this I am trying to convert the roiImg and my other images in HSV format and get 4 values according to the Algorithms.</p>
  
  <p>I have tried to combine the 2 codes but it doesn;t seem to work as roiImg is being made at runtime and is not being able to compare with the other 2 Images using imread.</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include "opencv2/opencv.hpp"
  #include &lt;opencv2/imgproc/imgproc.hpp&gt;
  #include &lt;opencv2/highgui/highgui.hpp&gt;
  #include &lt;opencv2/objdetect/objdetect.hpp&gt;
  
  #include &lt;sstream&gt;
  
  
  using namespace cv;
  using namespace std;
  
  Point point1, point2; /* vertical points of the bounding box */
  int drag = 0;
  Rect rect; /* bounding box */
  Mat img, roiImg; /* roiImg - the part of the image in the bounding box */
  int select_flag = 0;
  bool go_fast = false;
  
  Mat mytemplate;
  Mat src_base, hsv_base;
  Mat src_test1, hsv_test1;
  Mat src_test2, hsv_test2;
  Mat hsv_half_down;
  
  
  ///------- template matching -----------------------------------------------------------------------------------------------
  
  Mat TplMatch( Mat &amp;img, Mat &amp;mytemplate )
  {
    Mat result;
  
    matchTemplate( img, mytemplate, result, CV_TM_SQDIFF_NORMED );
    normalize( result, result, 0, 1, NORM_MINMAX, -1, Mat() );
  
    return result;
  }
  
  
  ///------- Localizing the best match with minMaxLoc ------------------------------------------------------------------------
  
  Point minmax( Mat &amp;result )
  {
    double minVal, maxVal;
    Point  minLoc, maxLoc, matchLoc;
  
    minMaxLoc( result, &amp;minVal, &amp;maxVal, &amp;minLoc, &amp;maxLoc, Mat() );
    matchLoc = minLoc;
  
    return matchLoc;
  }
  
  
  ///------- tracking --------------------------------------------------------------------------------------------------------
  
  void track()
  {
      if (select_flag)
      {
          //roiImg.copyTo(mytemplate);
  //         select_flag = false;
          go_fast = true;
      }
  
  //     imshow( "mytemplate", mytemplate ); waitKey(0);
  
      Mat result  =  TplMatch( img, mytemplate );
      Point match =  minmax( result ); 
  
      rectangle( img, match, Point( match.x + mytemplate.cols , match.y + mytemplate.rows ), CV_RGB(255, 255, 255), 0.5 );
  
      std::cout &lt;&lt; "match: " &lt;&lt; match &lt;&lt; endl;
  
      /// latest match is the new template
      Rect ROI = cv::Rect( match.x, match.y, mytemplate.cols, mytemplate.rows );
      roiImg = img( ROI );
      roiImg.copyTo(mytemplate);
      imshow( "roiImg", roiImg ); //waitKey(0);
  
  //Compare the roiImg with a know image to calculate resemblence 
  
  /*Method    Base - Base Base - Half Base - Test 1   Base - Test 2
  
  Correlation     1.000000    0.930766    0.182073    0.120447
  Chi-square      0.000000    4.940466    21.184536   49.273437
  Intersection    24.391548   14.959809   3.889029    5.775088
  Bhattacharyya   0.000000    0.222609    0.646576    0.801869
  
  For the Correlation and Intersection methods, the higher the metric, the more accurate the match. As we can see, 
  the match base-base is the highest of all as expected. Also we can observe that the match base-half is the second best match (as we predicted). 
  For the other two metrics, the less the result, the better the match. We can observe that the matches between the test 1 and test 2 with respect
  to the base are worse, which again, was expected.)*/
  
  
      src_base = imread("roiImg");
      src_test1 = imread("Samarth.jpg");
      src_test2 = imread("Samarth2.jpg");
      //double l2_norm = cvNorm( src_base, src_test1 );
  
      /// Convert to HSV
      cvtColor( src_base, hsv_base, COLOR_BGR2HSV );
      cvtColor( src_test1, hsv_test1, COLOR_BGR2HSV );
      cvtColor( src_test2, hsv_test2, COLOR_BGR2HSV );
  
      hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows - 1 ), Range( 0, hsv_base.cols - 1 ) );
  
      /// Using 50 bins for hue and 60 for saturation
      int h_bins = 50; int s_bins = 60;
      int histSize[] = { h_bins, s_bins };
  
      // hue varies from 0 to 179, saturation from 0 to 255
      float h_ranges[] = { 0, 180 };
      float s_ranges[] = { 0, 256 };
  
      const float* ranges[] = { h_ranges, s_ranges };
  
      // Use the o-th and 1-st channels
      int channels[] = { 0, 1 };
  
  
      /// Histograms
      MatND hist_base;
      MatND hist_half_down;
      MatND hist_test1;
      MatND hist_test2;
  
      /// Calculate the histograms for the HSV images
      calcHist( &amp;hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
      normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );
  
      calcHist( &amp;hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
      normalize( hist_half_down, hist_half_down, 0, 1, NORM_MINMAX, -1, Mat() );
  
      calcHist( &amp;hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
      normalize( hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat() );
  
      calcHist( &amp;hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
      normalize( hist_test2, hist_test2, 0, 1, NORM_MINMAX, -1, Mat() );
  
      /// Apply the histogram comparison methods
      for( int i = 0; i &lt; 4; i++ )
      {
          int compare_method = i;
          double base_base = compareHist( hist_base, hist_base, compare_method );
          double base_half = compareHist( hist_base, hist_half_down, compare_method );
          double base_test1 = compareHist( hist_base, hist_test1, compare_method );
          double base_test2 = compareHist( hist_base, hist_test2, compare_method );
  
          printf( " Method [%d] Perfect, Base-Half, Base-Test(1), Base-Test(2) : %f, %f, %f, %f \n", i, base_base, base_half , base_test1, base_test2 );
      }
  
  
      printf( "Done \n" );
  
  }
  
  
  ///------- MouseCallback function ------------------------------------------------------------------------------------------
  
  void mouseHandler(int event, int x, int y, int flags, void *param)
  {
      if (event == CV_EVENT_LBUTTONDOWN &amp;&amp; !drag)
      {
          /// left button clicked. ROI selection begins
          point1 = Point(x, y);
          drag = 1;
      }
  
      if (event == CV_EVENT_MOUSEMOVE &amp;&amp; drag)
      {
          /// mouse dragged. ROI being selected
          Mat img1 = img.clone();
          point2 = Point(x, y);
          rectangle(img1, point1, point2, CV_RGB(255, 0, 0), 3, 8, 0);
          imshow("image", img1);
      }
  
      if (event == CV_EVENT_LBUTTONUP &amp;&amp; drag)
      {
          point2 = Point(x, y);
          rect = Rect(point1.x, point1.y, x - point1.x, y - point1.y);
          drag = 0;
          roiImg = img(rect);
          roiImg.copyTo(mytemplate);
  //  imshow("MOUSE roiImg", roiImg); waitKey(0);
      }
  
      if (event == CV_EVENT_LBUTTONUP)
      {
          /// ROI selected
          select_flag = 1;
          drag = 0;
      }
  
  }
  
  
  
  ///------- Main() ----------------------------------------------------------------------------------------------------------
  
  int main()
  {
      int k;
  
  ///open webcam
      VideoCapture cap(0);
      if (!cap.isOpened())
        return 1;
  
   /*   ///open video file
      VideoCapture cap;
      cap.open( "Wildlife.wmv" );
      if ( !cap.isOpened() )
      {   cout &lt;&lt; "Unable to open video file" &lt;&lt; endl;    return -1;    }*/
  
      /*    
      /// Set video to 320x240
       cap.set(CV_CAP_PROP_FRAME_WIDTH, 320);
       cap.set(CV_CAP_PROP_FRAME_HEIGHT, 240);*/
  
      cap &gt;&gt; img;
      GaussianBlur( img, img, Size(7,7), 3.0 );
      imshow( "image", img );
  
      while (1)
      {
          cap &gt;&gt; img;
          if ( img.empty() )
              break;
  
      // Flip the frame horizontally and add blur
      cv::flip( img, img, 1 );
      GaussianBlur( img, img, Size(7,7), 3.0 );
  
          if ( rect.width == 0 &amp;&amp; rect.height == 0 )
              cvSetMouseCallback( "image", mouseHandler, NULL );
          else
              track();
  
          imshow("image", img);
  //  waitKey(100);   k = waitKey(75);
      k = waitKey(go_fast ? 30 : 10000);
          if (k == 27)
              break;
      }
  
      return 0;
  </code></pre>
  
  <p>}  </p>