title: Detect square using opencv2.4
body: <p>i used a program  to detect square in an image. that is working well with the image that i download from the internet. but what should i do is detect squares of the image which is taken from a camera. first of all i extracted images from video and then i try to detect square from those set of images but the code  is not working for those extracted images(but that is working well with other images ). what should i do to complete that task?</p>
  
  <pre><code>#ifdef _CH_
  #pragma package &lt;opencv&gt;
  #endif
  
  #define CV_NO_BACKWARD_COMPATIBILITY
  
  #include &lt;opencv2/opencv.hpp&gt; 
  #include "stdafx.h"
  #include "cv.h"
  #include "highgui.h"
  #include &lt;stdio.h&gt;
  #include &lt;math.h&gt;
  #include &lt;string.h&gt;
  
  int thresh = 50;
  IplImage* img = 0;
  IplImage* img0 = 0;
  CvMemStorage* storage = 0;
  //const char* wndname = "Square Detection Demo";
  
  // helper function:
  // finds a cosine of angle between vectors
  // from pt0-&gt;pt1 and from pt0-&gt;pt2
  double angle( CvPoint* pt1, CvPoint* pt2, CvPoint* pt0 )
  {
      double dx1 = pt1-&gt;x - pt0-&gt;x;
      double dy1 = pt1-&gt;y - pt0-&gt;y;
      double dx2 = pt2-&gt;x - pt0-&gt;x;
      double dy2 = pt2-&gt;y - pt0-&gt;y;
      return (dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
  }
  
  // returns sequence of squares detected on the image.
  // the sequence is stored in the specified memory storage
  CvSeq* findSquares4( IplImage* img, CvMemStorage* storage )
  {
      CvSeq* contours;
      int i, c, l, N = 11;
      CvSize sz = cvSize( img-&gt;width &amp; -2, img-&gt;height &amp; -2 );
      IplImage* timg = cvCloneImage( img ); // make a copy of input image
      IplImage* gray = cvCreateImage( sz, 8, 1 );
      IplImage* pyr = cvCreateImage( cvSize(sz.width/2, sz.height/2), 8, 3 );
      IplImage* tgray;
      CvSeq* result;
      double s, t;
      // create empty sequence that will contain points -
      // 4 points per square (the square's vertices)
      CvSeq* squares = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvPoint), storage );
  
      // select the maximum ROI in the image
      // with the width and height divisible by 2
      cvSetImageROI( timg, cvRect( 0, 0, sz.width, sz.height ));
  
      // down-scale and upscale the image to filter out the noise
      cvPyrDown( timg, pyr, 7 );
      cvPyrUp( pyr, timg, 7 );
      tgray = cvCreateImage( sz, 8, 1 );
  
      // find squares in every color plane of the image
      for( c = 0; c &lt; 3; c++ )
      {
          // extract the c-th color plane
          cvSetImageCOI( timg, c+1 );
          cvCopy( timg, tgray, 0 );
  
          // try several threshold levels
          for( l = 0; l &lt; N; l++ )
          {
              // hack: use Canny instead of zero threshold level.
              // Canny helps to catch squares with gradient shading
              if( l == 0 )
              {
                  // apply Canny. Take the upper threshold from slider
                  // and set the lower to 0 (which forces edges merging)
                  cvCanny( tgray, gray, 0, thresh, 5 );
                  // dilate canny output to remove potential
                  // holes between edge segments
                  cvDilate( gray, gray, 0, 1 );
              }
              else
              {
                  // apply threshold if l!=0:
                  //     tgray(x,y) = gray(x,y) &lt; (l+1)*255/N ? 255 : 0
                  cvThreshold( tgray, gray, (l+1)*255/N, 255, CV_THRESH_BINARY );
              }
  
              // find contours and store them all as a list
              cvFindContours( gray, storage, &amp;contours, sizeof(CvContour),
                  CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) );
  
              // test each contour
              while( contours )
              {
                  // approximate contour with accuracy proportional
                  // to the contour perimeter
                  result = cvApproxPoly( contours, sizeof(CvContour), storage,
                      CV_POLY_APPROX_DP, cvContourPerimeter(contours)*0.02, 0 );
                  // square contours should have 4 vertices after approximation
                  // relatively large area (to filter out noisy contours)
                  // and be convex.
                  // Note: absolute value of an area is used because
                  // area may be positive or negative - in accordance with the
                  // contour orientation
                  if( result-&gt;total == 4 &amp;&amp;
                      cvContourArea(result,CV_WHOLE_SEQ,0) &gt; 1000 &amp;&amp;
                      cvCheckContourConvexity(result) )
                  {
                      s = 0;
  
                      for( i = 0; i &lt; 5; i++ )
                      {
                          // find minimum angle between joint
                          // edges (maximum of cosine)
                          if( i &gt;= 2 )
                          {
                              t = fabs(angle(
                              (CvPoint*)cvGetSeqElem( result, i ),
                              (CvPoint*)cvGetSeqElem( result, i-2 ),
                              (CvPoint*)cvGetSeqElem( result, i-1 )));
                              s = s &gt; t ? s : t;
                          }
                      }
  
                      // if cosines of all angles are small
                      // (all angles are ~90 degree) then write quandrange
                      // vertices to resultant sequence
                      if( s &lt; 0.3 )
                          for( i = 0; i &lt; 4; i++ )
                              cvSeqPush( squares,
                                  (CvPoint*)cvGetSeqElem( result, i ));
                  }
  
                  // take the next contour
                  contours = contours-&gt;h_next;
              }
          }
      }
  
      // release all the temporary images
      cvReleaseImage( &amp;gray );
      cvReleaseImage( &amp;pyr );
      cvReleaseImage( &amp;tgray );
      cvReleaseImage( &amp;timg );
  
      return squares;
  }
  
  
  // the function draws all the squares in the image
  void drawSquares( IplImage* img, CvSeq* squares )
  {
      CvSeqReader reader;
      IplImage* cpy = cvCloneImage( img );
      int i;
  
      // initialize reader of the sequence
      cvStartReadSeq( squares, &amp;reader, 0 );
  
      // read 4 sequence elements at a time (all vertices of a square)
      for( i = 0; i &lt; squares-&gt;total; i += 4 )
      {
          CvPoint pt[4], *rect = pt;
          int count = 4;
  
          // read 4 vertices
          CV_READ_SEQ_ELEM( pt[0], reader );
          CV_READ_SEQ_ELEM( pt[1], reader );
          CV_READ_SEQ_ELEM( pt[2], reader );
          CV_READ_SEQ_ELEM( pt[3], reader );
  
          // draw the square as a closed polyline
          cvPolyLine( cpy, &amp;rect, &amp;count, 1, 1, CV_RGB(0,255,0), 3, CV_AA, 0 );
      }
  
      // show the resultant image
      cvShowImage( "Square Detection Demo", cpy );
      cvReleaseImage( &amp;cpy );
  }
  
  
  //char* names[] = { "pic1.png", "pic2.png", "pic3.png",
                   // "pic4.png", "pic5.png", "pic6.png", 0 };
  
  int main(int argc, char** argv)
  {
      int i, c;
      // create memory storage that will contain all the dynamic data
      storage = cvCreateMemStorage(0);
  
      //for( i = 0; names[i] != 0; i++ )
      //{
      //    // load i-th image
      //    img0 = cvLoadImage( names[i], 1 );
      //    if( !img0 )
      //    {
      //        printf("Couldn't load %s\n", names[i] );
      //        continue;
      //    }
          img0 = cvLoadImage("frame_21.jpg");
          img = cvCloneImage( img0 );
  
          // create window and a trackbar (slider) with parent "image" and set callback
          // (the slider regulates upper threshold, passed to Canny edge detector)
         // cvNamedWindow( "qq");
  
          // find and draw the squares
          drawSquares( img, findSquares4( img, storage ) );
  
          // wait for key.
          // Also the function cvWaitKey takes care of event processing
          c = cvWaitKey(0);
          // release both images
          cvReleaseImage( &amp;img );
          cvReleaseImage( &amp;img0 );
          // clear memory storage - reset free space position
          cvClearMemStorage( storage );
          /*if( (char)c == 27 )
              break;*/
    /*  }*/
  
  //    cvDestroyWindow( "qq" );
  
      return 0;
  }
  </code></pre>
  
  <p>This is the sample image that extracted from video -----> <img src="https://i.stack.imgur.com/L7TLc.jpg" alt="road sign"></p>