Modified and improved the method for chessboard detection. It is now faster and…

Modified and improved the method for chessboard detection. It is now faster and detects chessboards under difficult lighting condition as well as when the chessboard has strong out of plane rotations

modules/calib3d/include/opencv2/calib3d/calib3d.hpp

@@ -46,3 +46,12 @@
 #endif
 
 #include "opencv2/calib3d.hpp"
+// Performs a fast check if a chessboard is in the input image. This is a workaround to
+// a problem of cvFindChessboardCorners being slow on images with no chessboard.
+// This method works using a binary image as input
+// - src: input binary image
+// - size: chessboard size
+// Returns 1 if a chessboard can be in this image and findChessboardCorners should be called,
+// 0 if there is no chessboard, -1 in case of error
+CVAPI(int) cvCheckChessboardBinary(IplImage* src, CvSize size);
+

modules/calib3d/src/checkchessboard.cpp

@@ -59,8 +59,8 @@
 
 static void icvGetQuadrangleHypotheses(CvSeq* contours, std::vector<std::pair<float, int> >& quads, int class_id)
 {
-    const float min_aspect_ratio = 0.3f;
-    const float max_aspect_ratio = 3.0f;
+    const float min_aspect_ratio = 0.2f;
+    const float max_aspect_ratio = 5.0f;
     const float min_box_size = 10.0f;
 
     for(CvSeq* seq = contours; seq != NULL; seq = seq->h_next)
@@ -205,3 +205,97 @@ int cvCheckChessboard(IplImage* src, CvSize size)
 
     return result;
 }
+
+// does a fast check if a chessboard is in the input image. This is a workaround to
+// a problem of cvFindChessboardCorners being slow on images with no chessboard
+// - src: input binary image
+// - size: chessboard size
+// Returns 1 if a chessboard can be in this image and findChessboardCorners should be called,
+// 0 if there is no chessboard, -1 in case of error
+int cvCheckChessboardBinary(IplImage* src, CvSize size)
+{
+    if(src->nChannels > 1)
+    {
+        cvError(CV_BadNumChannels, "cvCheckChessboard", "supports single-channel images only",
+                __FILE__, __LINE__);
+    }
+
+    if(src->depth != 8)
+    {
+        cvError(CV_BadDepth, "cvCheckChessboard", "supports depth=8 images only",
+                __FILE__, __LINE__);
+    }
+
+    CvMemStorage* storage = cvCreateMemStorage();
+
+    IplImage* white = cvCloneImage(src);
+    IplImage* black = cvCloneImage(src);
+    IplImage* thresh = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
+
+    int result = 0;
+
+    for ( int erosion_count = 0; erosion_count <= 3; erosion_count++ )
+    {
+      if ( 1 == result )
+        break;
+
+      if ( 0 != erosion_count ) // first iteration keeps original images
+      {
+        cvErode(white, white, NULL, 1);
+        cvDilate(black, black, NULL, 1);
+      }
+
+      cvThreshold(white, thresh, 128, 255, CV_THRESH_BINARY);
+
+      CvSeq* first = 0;
+      std::vector<std::pair<float, int> > quads;
+      cvFindContours(thresh, storage, &first, sizeof(CvContour), CV_RETR_CCOMP);
+      icvGetQuadrangleHypotheses(first, quads, 1);
+
+      cvThreshold(black, thresh, 128, 255, CV_THRESH_BINARY_INV);
+      cvFindContours(thresh, storage, &first, sizeof(CvContour), CV_RETR_CCOMP);
+      icvGetQuadrangleHypotheses(first, quads, 0);
+
+      const size_t min_quads_count = size.width*size.height/2;
+      std::sort(quads.begin(), quads.end(), less_pred);
+
+      // now check if there are many hypotheses with similar sizes
+      // do this by floodfill-style algorithm
+      const float size_rel_dev = 0.4f;
+
+      for(size_t i = 0; i < quads.size(); i++)
+      {
+          size_t j = i + 1;
+          for(; j < quads.size(); j++)
+          {
+              if(quads[j].first/quads[i].first > 1.0f + size_rel_dev)
+              {
+                  break;
+              }
+          }
+
+          if(j + 1 > min_quads_count + i)
+          {
+              // check the number of black and white squares
+              std::vector<int> counts;
+              countClasses(quads, i, j, counts);
+              const int black_count = cvRound(ceil(size.width/2.0)*ceil(size.height/2.0));
+              const int white_count = cvRound(floor(size.width/2.0)*floor(size.height/2.0));
+              if(counts[0] < black_count*0.75 ||
+                 counts[1] < white_count*0.75)
+              {
+                continue;
+              }
+              result = 1;
+              break;
+          }
+      }
+    }
+
+    cvReleaseImage(&thresh);
+    cvReleaseImage(&white);
+    cvReleaseImage(&black);
+    cvReleaseMemStorage(&storage);
+
+    return result;
+}
\ No newline at end of file