“断言”功能：奇怪的行为

Question

I am developping on Windows 7 in C++ with Qt Creator. I also use the library OpenCV

I came up against a strange problem with the function assert . I developed a function that makes a linear transformation on an image in order to get a better contrast, with the possibility to specify a zone (x1,x2,y1,y2) of the image we want to work on and also a tolerance (Tolmin and Tolmax) : the percentile of the histogram we want to ignore.

I need to make sure that :

• Image is 16bits grayscale (img.type()=CV_16U && img.channels()=1)
• Zone coordinates are correct (positive, do not exceed image size ...)
• Tolmin,Tolmax positive and Tolmin+Tolmax != 1 (if Tolmin+Tolmax=1 there will be a division by 0)

I used the function assert

My code is the following :

void equalizeHist_16U_linear(Mat &img, float Tolmin, float Tolmax, int x1, int x2, int y1, int y2)
{
    assert(img.channels() == 1);
    assert(img.type() == CV_16U);
    assert(x1>=0 && y1>=0 && x2>=x1 && y2>=y1);
    assert(y2<img.rows && x2<img.cols);
    assert(Tolmin>0 && Tolmax>0);
    assert(Tolmin+Tolmax != 1.0);

    ## code ##
    ...

}

The five first assert works fine, but the last one assert(Tolmin+Tolmax != 1.0) does not work. Even when Tolmin+Tolmax=1 , assert does not stop the execution so the program crashes (division by 0). To be sure, I printed Tolmin+Tolmax before the assert call.

void equalizeHist_16U_linear(Mat &img, float Tolmin, float Tolmax, int x1, int x2, int y1, int y2)
{
    cout << endl << "Tolmin+Tolmax = " << Tolmin+Tolmax << endl;

    assert(img.channels() == 1);
    assert(img.type() == CV_16U);
    assert(x1>=0 && y1>=0 && x2>=x1 && y2>=y1);
    assert(y2<img.rows && x2<img.cols);
    assert(Tolmin>0 && Tolmax>0);
    assert(Tolmin+Tolmax != 1.0);

    ## code ##
    ...

}

It displays "Tolmin+Tolmax=1", and this time, assert stopped the execution of the program !

How is it possible ? Why does the display of Tolmin+Tolmax makes assert work ?

I tried to add the following :

void equalizeHist_16U_linear(Mat &img, float Tolmin, float Tolmax, int x1, int x2, int y1, int y2)
{
    float sum = Tolmin+Tolmax;

    assert(img.channels() == 1);
    assert(img.type() == CV_16U);
    assert(x1>=0 && y1>=0 && x2>=x1 && y2>=y1);
    assert(y2<img.rows && x2<img.cols);
    assert(Tolmin>0 && Tolmax>0);*/
    assert(sum != 1.0);

    ## code ##
    ...

}

But it does not work either.

Answer 1

My guess is that a value is being used in your code (as Tolmin or Tolmax) which cannot be represented in a machine's number format. What do I mean? Well there are numbers that you can easily think of which a computer cannot store them exactly as they are. Computers have to store numbers in a finite digit binary formats and as a result some numbers will not be stored exactly as they are. Think about it this way, we can think of the number (2/3) right? but when we have to represent this number in a decimal format with finite digits, we have to round it like this: 0.66666667 hence we cannot exactly write this number as it is. This case can accrue in a machine too for example we cannot have number 0.2 stored in a machine in binary format because its representative digits in binary is infinite, a machine will just round such numbers to the closest it can store. In your case, you are comparing a converted-to-binary number to an absolute value (1.0) and logically they are not the same even if they are very close to each other. So my guess is that the sum of Tolmin and Tolmax will be something very close to 1.0 but not exactly 1.0. So whats the solution? you should check if sum has passed an arbitrary interval to 1.0 or not. Something like this:

assert(abs(sum - 1.0) > 0.0001)

UPDATE: I couldn't reproduce your reported behavior while printing it, both with gcc and MSC++ so all I can do is a weak guess. When you build your code, compiler will revise it in an optimization phase. You are ordering to compute Tolmin+Tolmax in two places, first in cout and second in assert, so compiler will deduce that this computation can be done once and then reuse it's result. As cout reforms the number you order to display, and the value is so close to 1, it will be rounded and get the exact value 1 and then the result will be reused in assert. It can be the case or not, I cannot confirm it as I couldn't reproduce the reported behavior.