Antonio's profile - activity

You can avoid installing or linking extra libraries by simply checking the DISPLAYenvironment variable: std::getenv("DIS

You can avoid installing or linking extra libraries by simply checking the DISPLAYenvironment variable: std::getenv("DIS

In Linux you should be able to check the display availability by retrieving the environment variable DISPLAY #if __linu

The question in general is: What is the correct way of getting a pointer to an image/cv::Mat row?

Background: I was checking the code of CCStatsOp inside /modules/imgproc/src/connectedcomponents.cpp

I saw that to get a pointer to an image row the following code is used:

int *row = &statsv.at<int>(l, 0);

But I wonder: Wouldn't the following be more efficient?

int *row = statsv.ptr<int>(l);

You need something like this: http://answers.opencv.org/question/12...

As regards MinGW, unless I understand wrongly, nowadays it should be supported by CUDA : http://docs.nvidia.com/cuda/cuda-comp... http://docs.nvidia.com/cuda/cuda-comp...

So, it should be a matter of having the OpenCV developer implement some of the modifications, or become an OpenCV contributor and implement them :)

How to convert Mat to UMat: http://stackoverflow.com/a/27530966/2...

@itay In fact, an UMat might be at some point to the GPU, but the point is more than on runtime an OpenCV method will decide to process an UMat on CPU or GPU depending on the availability, for example, of an OpenCL implementation of that method.

@Tankard Very well! If you problem is solved, can you please accept the answer? (Tag under the answer score)

You can find some useful information here: http://stackoverflow.com/questions/27...

I see... Try instead:

cv::Mat roi(gray, cv::Rect(gray.rows / 2 - 350, gray.cols / 2 - 350, 700, 700));
double minVal, maxVal;
cv::minMaxLoc(roi, &minVal, &maxVal);
gray.convertTo(grayFiltered, grayFiltered.type(), 255.0/(maxVal-minVal), -minVal);

@Tankard Print the value of norm. I would guess that alpha has to be 256/norm, or something proportional to that

If you are looking for a fast solution, you can make norm/normalize use only the center part of the image to compute the multipliers and normalize the entire image. In the bottom part of the documentation of normalize it is explained how this could be done.

Referring to this reported bug http://code.opencv.org/issues/4108#no..., does anybody know on which CMake files to act to change the order in which library are linked for building the tests?

BTW, did you build 32bit or 64bit? In my case, 32bit

@Vit I confirm 100% your findings: OpenCV3 OpenCL implementation of Canny it's buggy. (Although is 4 times faster)

BTW: The answer to: "Why so large threshold" is that when using 5 as kernel size of Canny, at an intermediate stage you get a Sobel image computed with the mask 5 parameters, which has much larger multipliers, and of course convolves a larger number of pixels.

In this case, you can simply use normalize to enhance the contrast.

Can you share on which hardware and driver this happen? Did you test with OpenCV 2.4? The code would be only slightly different, example:

    #include "opencv2/ocl/ocl.hpp"
    cv::Mat input = cv::imread(filename,0 ); //directly grayscale
    cv::ocl::oclMat imgGray(input);
    cv::ocl::oclMat imgGrayEdges3, imgGrayEdges5;

    cv::ocl::Canny(imgGray, imgGrayEdges3, 50, 150, 3);
    cv::ocl::Canny(imgGray, imgGrayEdges5, 300, 2000, 5);

    cv::imshow("img", (cv::Mat) imgGray);
    cv::imshow("canny3", (cv::Mat) imgGrayEdges3);
    cv::imshow("canny5", (cv::Mat) imgGrayEdges5);

Which works correctly for me by the way

I think what you meant was "How can I BLEND 10 images". You want the mean value across the 10 images for each pixel.

I have the following use case.

I preprocess an image so that I know for which parts that I want to do the complete (expensive) processing. I therefore create several cv::Mat from my main cv::Mat and do filtering only on those. However, on boundary pixels I know the filter could very nicely go across the border of the sub-cv::Mat I have created, and compute the exact value for my filtering also for the border pixels. So my question is: Is there among the border handling modes a way to say to simply peak a pixel outside the cv::Mat? It seems only thing like constant, mirror or wrap are available...

Do you already have an efficient way to dilate a contour, with the initial contour in the form of a vector of points?

You can replace

roiImg = alignedImg.adjustROI(0, 0, 0, srcImg.size().width - size.width);

with

roiImg = alignedImg.colRange(0,srcImg.cols);

(Note for colRange from the documentation: Start and end column of the extracted submatrix. The upper boundary is not included)

To have the image loaded directly as you desire, you would have to go one level down to the imdecode method, and test if giving the roiImg created as you did would work as expected, loading the image aligned. Of course, you need to know the image size in advance, otherwise you will have to write your own version of imdecode.

Note: While investigating it finally ended up that this is not really a question, but I think it might be useful to share my findings :)

I wanted to compute the integral image using the function library, in order to implement fast Gaussian filters according to the work published here: http://www.csse.uwa.edu.au/~pk/research/matlabfns/#integral, and also other filters.

I have seen, though, that there's no way I can avoid computing the squared sum if I want to compute the integral image for the tilted image. http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#integral

The rationale of this choice is that the integral image is basically only used in the Haar detection, and that there the sum of squared pixel is used to perform "Fast lighting correction". However this means that if you don't need the squared integral image you have to come up with your own implementation.

BTW, I went to see the implementation on the trunk (integral_ in sumpixels.cpp), and it seems there's no tbb implementation of the integral image computation, while the function could be parallelized to some extent.

Another interesting finding is that integral image might overflow for image sizes >8Mb: taking a completely white image, the overflow happens when 2^8 * W * H > 2^31 (not 32, as one bit is used for keeping the sign, as the integral image could be computed for signed images), that is W * H > 2^23 = 8 * 2^10 * 2^10

This should address your problem: http://stackoverflow.com/q/16767464/2436175