kbarni's profile - activity

Another solution that I often use is to create a text file containing the image names and pass that filename as argument

Per-pixel operations in Python I'm working on some image processing algorithm* in Python where I need to do some per-pix

What cmake configuration options did you use? Did you try compiling it without OpenCL support?

But my question now is how do I translate the coordinates of the centroids to the soccerfield image. DO NOT transla

I've been thinking for some time, which is the best method to declare an image processing function?

The function should take an input image and return an output image.

I can think of the following possibilities:

1. using InputArray & OutputArray:

   void foo(InputArray in,OutputArray out)
   {
       Mat inMat=in.getMat();
       out.createSameSize(in,CV_8U);
       Mat outMat=out.getMat();
       // processing code...
   }
   

2. Using two Mat variables as parameters:

   void foo(Mat in,Mat out)
   {
       out.create(in.size(),CV_8U);
       // processing code...
   }
   

   BTW, in this case which parameters should be declared with &? (i.e. Mat &in)

3. One Mat as parameter and return a new Mat:

   Mat foo(Mat in)
   {
       Mat out(in.size(),CV_8U);
       // processing code...
       return out;
   }
   

In classical C++ code, the third method should be normally preferred, but I think the other two can be more optimal in certain cases (i.e. using foo(img,img) vs. img=foo(img) or when the out matrix was already created)?

Concerning the first two solutions, I think they are mostly equivalent, however OpenCV uses systematically InputArray and OutputArray as parameters. Is there a good reason for this, or is it's for better readability? I am also aware that InputArray and OutputArray are more general, they can accept other parameters then Mat variables, too.

...and OpenCV doesn't have its own codecs, it uses 3rd party libraries...so you cannot avoid dependencies to other libra

Use ArUCo markers instead of QR codes. They are better suited for this kind of application. Use at least 3 or 4 markers

What did you try? Did you bother to search for a solution? Hint: the HoughLinesP function is what you are looking for.

What did you try? Did you bother to search for a solution? Hint: the HoughLinesP function is what you are looking for.

Use the so-called gamma correction. The formula is: result = 255 * (image/255)^k With different k exponent values yo

Use the so-called gamma correction. The formula is: result = 255 * (image/255)^k With different kexponent values you

Use the so-called gamma correction. The formula is: result = 255 * (image/255)^k With different k values you can have

PNG compression is computationally expensive. If this is a bottleneck of your application, you should choose another fil

don't use OpenCV 2.4. It's a very outdated version! There is no magic "detectObstaclesToHelpBlindPeople()" function. So

create a new black image for storing the endpoints for the endpoints (points having only one neighbor in the skeleton)

There is no function to extend a line in OpenCV. Fortunately this is a simple geometry problem. The formula for your li

Probably you can tune the parameters of the probabilistic Hough transform to detect all the lines; however it will somet

yes. The mask must be a 8-bit 1-channel (i.e. grayscale) image. What's the problem?

The mask must be 8-bit 1-channel image in function 'icvInpaint' import numpy as np import cv2 from PIL import Im

The mask must be 8-bit 1-channel image in function 'icvInpaint' import numpy as np import cv2 from PIL import Im

The mask must be 8-bit 1-channel image in function 'icvInpaint' import numpy as np import cv2 from PIL import Im

Also, first try to use the official install docs: https://docs.opencv.org/4.5.0/d7/d9f/tutorial_linux_install.html They

This is normal. The color of the green squares is (BGR) 79,155,108, which is outside the lower_green - upper green range

And your problem is...? What did you try? It seems that you didn't invest the minimal effort to solve this.

The article suggested by Eduardo is a great resource. Concerning the implementations, the Gabor filters can be a good s

The article suggested by Eduardo is a great resource. Concerning the implementations, the Gabor filters can be a good s

I think the problem with these stamps is that the degraded image differs a lot from the original. The original can conta

HoughCircles...?

Try the DistanceTransform, it's another good method for circle detection in binary images. This example should help.

Well, this seems as a classical texture analysis problem. There are some robust texture descriptors which can be used t

For a pixel from the left camera PL(X,Y) the corresponding pixel in the disparity map has the same coordinates PD(X,Y).

Windows doesn't run on the Rasp. But Linux (Raspbian) is simple...just get used to the fact that it's different than Win

Curve detection is not simple in image processing. AFAIK there is no standard way for doing it (like the Hough transform

I think Yolo is a bit overkill for ball detection, but you can keep if it works. You might also try HoughCircles. The i

I think Yolo is a bit overkill for ball detection. You might try HoughCircles, or the inRange function and then Connecte

Run the ConnectedComponentsWithStats function on the image. Get the smallest surfaces, as zones to merge. Then, for ea

I'm using Ubuntu and OpenCV 4.3. I have to check on windows...

Yes, the best solution would be to use 4 visible and fixed red balls or points. I also like to use ARUCO markers for cal

A minute of googling could have made you find out that you can use getWindowProperty() to check whether the window is ok

Yes, the best solution would be to use 4 visible and fixed red balls or points. I also like to use ARUCO markers (in oth

You'll need some markers for calibration. Either add some colored points to the field that you can use for calibration o

WarpPerpective will transform a rectangle seen in perspective (like a trapeziod) into a real rectangle. For it to wor

I would like to display a window, and block the program execution until the user decides to continue. This is done normally the following way:

Mat img1,img2;
//...process...
namedWindow("Image1",WINDOW_NORMAL);
imshow("Image1",img1);
waitKey();
destroyAllWindows();
namedWindow("Image2",WINDOW_NORMAL);
imshow("Image2",img2);

The only problem with this approach is if the user instinctively closes the window using the X button. Then, as no HighGUI windows are active, waitKey() will never return and the program blocks.

Is there any solution, so the program waits a keypress OR the window to be closed?

Block until window closed I would like to display a window, and block the program execution until the user decides to co

It's possible that you'll need the OpenCV bindings too, not only the libopencv_java.so (never tried, I don't use Java).

It's possible that you'll need the OpenCV bindings too, not only the libopencv_java.so (never tried, I don't use Java).

Create 2 images, one with the video feed (let's say 640x480), the other one with the text (in this case 160x480). Then u