hough | Skew detection in scanned images

So what I did was I installing another library that's called gcv by vcaesar. There was a method called FindAllImg and what I need just provide two image, one is the source image, in my case a screenshot, and the other is a template image that needed to be searched in the screenshot.

You have 2 choices to find matching circles.

first one: sliding window

smaller windows is a template that you seek for it in input image, here two images with different radii 19 and 21 respectively. First at all, find edge of template and input image, after that, multiplying cropped part of image with template. each region that is near to template should have higher value.

Just do the math on your circle to find the rectangle(square) parallel to the photo(you can support rotated rectangles with more math involved).

X_min_rect = X_circle - R

Y_min_rect = Y_circle - R

Where R is the radious of the circle.

Width and Height is equal to 2*R

The issue stems from the houghpeaks properties being to restrictive to find the smaller lines segments. The approach I used is to:

1. use your current code to obtain the angle that the detected lines are at (I just did [lines.theta] and found that theta will be equal to -84)

2. use again your code but only with that angle included, while relaxing the houghpeaks properties to allow many more lines to be detected.

3. you'll get many more lines detected that overlap, and we'll discard those by setting a similarity threshold based on their coefficients.

here's the implementation

The documentation for dip::FindHoughCircles reads:

Finds circles in 2D binary images using the 2-1 Hough transform. First, circle centers are computed using dip::HoughTransformCircleCenters, and then a radius is calculated for each center. Note that only a single radius is returned per center coordinates.

That is, this function is not able to find concentric circles.

One workaround could be to run the function twice, with different limits for the circle sizes.

In DIPlib, all allocated images (either through the dip::Image constructor, though img.Forge(), through img.Similar(), etc.) are not initialized. You need to explicitly set the pixels to zero before you start drawing in it: detec_img.Fill(0). Your output image has some very nice display of previous memory use in the bottom half, I wonder what computations lead to that! :)

To isolate the coin: HoughCircles is a good approach, even though depending on perspective the coin may not be a perfect circle. You can also try the watershed algorithm to segment all objects, then detect which object is a coin by the color or by how circular it is (e.g., which object has the most similar distances between its centroid and different edge points).

To isolate the drawing: If the drawing is the only object left besides the coin, mask the coin out and threshold (e.g. with Otsu) to convert the image to binary. You will still have holes in the drawing, which you can eliminate using opening.

The code below uses cv2.HoughLinesP() on the thresholded image to produce this:

You can use a 2D FFT to find the general direction in which the crop is aligned (as proposed by mozway in the comments). The idea is that the general direction can be easily extracted from centred beaming rays appearing in the magnitude spectrum when the input contains many lines in the same direction. You can find more information about how it works in this previous post. It works directly with the input image, but it is better to apply the Gaussian + Canny filters.

Here is the interesting part of the magnitude spectrum of the filtered gray image:

The main beaming ray can be easily seen. You can extract its angle by iterating over many lines with an increasing angle and sum the magnitude values on each line as in the following figure:

Here is the magnitude sum of each line plotted against the angle (in radian) of the line:

Based on that, you just need to find the angle that maximize the computed sum.

Here is the resulting code:

After several experiments (based on these examples) and tests, I ended up with this code: