GaussianBlur | GaussianBlur for golang go 语言图像处理库——高斯模糊 | Computer Vision library

The cv2 pre-processing is unecessary here, tesseract is able to find the text on its own. See the example below, commented inline:

You can find chessboard and even find it's pose like here. Then you'll able to estimate ellipse shape of piece base. Find ellipses, using, for instance, this project.

Filter out trash ellipses using pose knowledge, and you'll get pieces positions. Then you can find free cells.

Here is one approach in Python/OpenCV.

Input for cv2.recangle was wrong. Try:

You almost have it. You have multiple bounding rectangles on each digit because you are retrieving every contour (external and internal). You are using cv2.findContours in RETR_LIST mode, which retrieves all the contours, but doesn't create any parent-child relationship. The parent-child relationship is what discriminates between inner (child) and outter (parent) contours, OpenCV calls this "Contour Hierarchy". Check out the docs for an overview of all hierarchy modes. Of particular interest is RETR_EXTERNAL mode. This mode fetches only external contours - so you don't get multiple contours and (by extension) multiple bounding boxes for each digit!

Also, it seems that your images have a red border. This will introduce noise while thresholding the image, and this border might be recognized as the top-level outer contour - thus, every other contour (the children of this parent contour) will not be fetched in RETR_EXTERNAL mode. Fortunately, the border position seems constant and we can eliminate it with a simple flood-fill, which pretty much fills a blob of a target color with a substitute color.

Let's check out the reworked code:

Does passing new int(71) as an argument of type int* cause memory leaks as well?

If it is deleted, then there is no leak. If it is not deleted, then there is a leak. Did you delete it?

Could give me smarter solutions?

No. Your solution A seems fine.

I cannot pass nullptr as the 3rd argument as well.

Edit: Documentation says it is "optional", but the implementation doesn't seem to reflect that. I browsed a few implementations, and it null seems to be corretly checked for example in GTK, but not in some other platforms including Windows and QT. That's an opencv bug as far as I can tell.

As fmw42 suggested, you need to restrict the problem more. There are way too many variables to build a "works under all circumstances" solution. A possible, very basic, solution would be to try and get the convex hull of the page.

Another, more robust approach, would be to search for the four vertices of the corners and extrapolate lines to approximate the paper edges. That way you don't need perfect, clean edges, because you would reconstruct them using the four (maybe even three) corners.

To find the vertices you can run Hough Line detector or a Corner Detector on the edges and get at least four discernible clusters of end/starting points. From that you can average the four clusters to get a pair of (x, y) points per corner and extrapolate lines using those points.

That solution would be hypothetical and pretty laborious for a Stack Overflow question, so let me try the first proposal - detection via convex hull. Here are the steps:

1. Threshold the input image
2. Get edges from the input
3. Get the external contours of the edges using a minimum area filter
4. Get the convex hull of the filtered image
5. Get the corners of the convex hull

Let's see the code:

For people that know how to at least install libraries and set things up in Visual Studio 2019, the problem for me was that I was building different versions in different configurations.

I had OpenCV build in Debug Win32 and BgsLibrary I tried to build in Release x64. After what drescherjm said about the problem possibly lying in the OpenCV build I rebuilt OpenCV from scratch but this time in Release Win32 (as bgslibrary requires you to build in Release). After that I built bgslibrary from scratch again as well but this time also in Release Win32. After that it was just linking up all the libraries and adding the .dll locations to my path and it worked!

1st step: I reduced the data with cv2.boundingRect() from contours.

2nd step: I filtered every segments what touched the edge of the image.

3rd step: I sorted the remaining data from top ('y' values).

4th step: I sliced data to lines by the difference of every following 'y's where it's greater than the median of the character's heights.

5th step: I sorted each lines from left.

code: