Detecting squares in an image - c++

Question

I found this square detection code online and I'm trying to understand it, does anyone understand what the line at the end does? it states: "gray = gray0 >= (l+1)*255/N;"
Mat pyr, timg, gray0(image.size(), CV_8U), gray;
// down-scale and upscale the image to filter out the noise
pyrDown(image, pyr, Size(image.cols/2, image.rows/2));
pyrUp(pyr, timg, image.size());
vector<vector<Point> > contours;
// find squares in every color plane of the image
for( int c = 0; c < 3; c++ )
{
int ch[] = {c, 0};
mixChannels(&timg, 1, &gray0, 1, ch, 1);
// try several threshold levels
for( int l = 0; l < 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)
Canny(gray0, gray, 0, thresh, 5);
// dilate canny output to remove potential
// holes between edge segments
dilate(gray, gray, Mat(), Point(-1,-1));
}
else
{
// apply threshold if l!=0:
// tgray(x,y) = gray(x,y) < (l+1)*255/N ? 255 : 0
gray = gray0 >= (l+1)*255/N;
}

Answer 1

This code snipped is a part of the git repository CVSquares. From experience, I know that this library does not work well on real images though works good in computer generated images. Plus this method of detection on RGB without converting to grayscale is very computationally expensive.
Anyways the line of code you are asking about is basically a threshold filter that makes a binary gray Mat array based on the threshold applied to the array gray0 according to the level. If the condition is true, the array contains white pixel at that location else black pixel
A more generic detection code based on the grayscale image would work better like this:
Mat binary_img(color_img.size(),CV_8UC1);
vector<Vec4i> hierarchy;
vector<vector<Point> > contours;
vector<cv::Point> approx;
cv::GaussianBlur(color_img, color_img, cv::Size(9,9), 3);
cv::medianBlur(color_img, color_img, 9);
cv::medianBlur(color_img, color_img, 9);
cvtColor(color_img,binary_img,CV_BGR2GRAY);
IplImage tempBinary=IplImage(binary_img);
cvInRangeS(&tempBinary, Scalar(20), Scalar(100), &tempBinary);
Mat imgMat=Mat(&tempBinary);
findContours( imgMat, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
for(int i = 0; i < contours.size(); i++ )
{
approxPolyDP(Mat(contours[i]), approx, arcLength(Mat(contours[i]), true)*0.0005, true);
if(approx.size()==4)
//draw approx
}

Answer 2

The second half of the line, gray0 >= (l+1)*255/N, is a condition. gray is a variable, which will contain the truth-fullness of this condition, thus it will be a boolean. But it is c/c++ code, and the booleans are integers here.
About this condition:
(l+1)*255/N will move the interval (1,l) to (0,255). Thus, for l=0 it will be 255/N. For l=N it will be exactly 255.

Answer 3

Depending on the value of l+1 (1 added to make the range started from 1 to 256, instead of 0 to 255) multiplied by 255 and integer divided by N being less than or equal to threshold value gray0, gray is set to 0 or 1 (pure black or pure white)
gray = gray0 >= (l+1)*255/N;