How to detect a grainy line?

Question

I am trying to detect a grainy printed line on a paper with cv2. I need the angle of the line. I dont have much knowledge in image processing and I only need to detect the line. I tried to play with the parameters but the angle is always detected wrong. Could someone help me. This is my code:

import cv2
import numpy as np
import matplotlib.pylab as plt
from matplotlib.pyplot import figure

img = cv2.imread('CamXY1_1.bmp')
crop_img = img[100:800, 300:900]
blur = cv2.GaussianBlur(crop_img, (1,1), 0)
ret,thresh = cv2.threshold(blur,150,255,cv2.THRESH_BINARY)
gray = cv2.cvtColor(thresh,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 60, 150)

figure(figsize=(15, 15), dpi=150)
plt.imshow(edges, 'gray')

lines = cv2.HoughLines(edges,1,np.pi/180,200)
for rho,theta in lines[0]:
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a*rho
    y0 = b*rho
    x1 = int(x0 + 3000*(-b))
    y1 = int(y0 + 3000*(a))
    x2 = int(x0 - 3000*(-b))
    y2 = int(y0 - 3000*(a))

    cv2.line(img,(x1,y1),(x2,y2),(0, 255, 0),2)

imagetobedetected

Answer 1

Here's a possible solution to estimate the line (and its angle) without using the Hough line transform. The idea is to locate the start and ending points of the line using the reduce function. This function can reduce an image to a single column or row. If we reduce the image we can also get the total SUM of all the pixels across the reduced image. Using this info we can estimate the extreme points of the line and calculate its angle. This are the steps:

1. Resize your image because it is way too big
2. Get a binary image via adaptive thresholding
3. Define two extreme regions of the image and crop them
4. Reduce the ROIs to a column using the SUM mode, which is the sum of all rows
5. Accumulate the total values above a threshold value
6. Estimate the starting and ending points of the line
7. Get the angle of the line

Here's the code:

# imports:
import cv2
import numpy as np
import math

# image path
path = "D://opencvImages//"
fileName = "mmCAb.jpg"

# Reading an image in default mode:
inputImage = cv2.imread(path + fileName)

# Scale your BIG image into a small one:
scalePercent = 0.3

# Calculate the new dimensions
width = int(inputImage.shape[1] * scalePercent)
height = int(inputImage.shape[0] * scalePercent)
newSize = (width, height)

# Resize the image:
inputImage = cv2.resize(inputImage, newSize, None, None, None, cv2.INTER_AREA)

# Deep copy for results:
inputImageCopy = inputImage.copy()

# Convert BGR to grayscale:
grayInput = cv2.cvtColor(inputImage, cv2.COLOR_BGR2GRAY)

# Adaptive Thresholding:
windowSize = 51
windowConstant = 11
binaryImage = cv2.adaptiveThreshold(grayInput, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, windowSize, windowConstant)

The first step is to get the binary image. Note that I previously downscaled your input because it is too big and we don't need all that info. This is the binary mask:

Now, we don't need most of the image. In fact, since the line is across the whole image, we can only "trim" the first and last column and check out where the white pixels begin. I'll crop a column a little bit wider, though, so we can ensure we have enough data and as less noise as possible. I'll define two Regions of Interest (ROIs) and crop them. Then, I'll reduce each ROI to a column using the SUM mode, this will give me the summation of all intensity across each row. After that, I can accumulate the locations where the sum exceeds a certain threshold and approximate the location of the line, like this:

# Define the regions that will be cropped
# from the original image:
lineWidth = 5
cropPoints = [(0, 0, lineWidth, height), (width-lineWidth, 0, lineWidth, height)]

# Store the line points here:
linePoints = []

# Loop through the crop points and 
# crop de ROI:

for p in range(len(cropPoints)):

    # Get the ROI:
    (x,y,w,h) = cropPoints[p]

    # Crop the ROI:
    imageROI = binaryImage[y:y+h, x:x+w]

    # Reduce the ROI to a n row x 1 columns matrix:
    reducedImg = cv2.reduce(imageROI, 1, cv2.REDUCE_SUM, dtype=cv2.CV_32S)

    # Get the height (or lenght) of the arry:
    reducedHeight = reducedImg.shape[0]

    # Define a threshold and accumulate
    # the coordinate of the points:
    threshValue = 100
    pointSum = 0
    pointCount = 0

    for i in range(reducedHeight):
        currentValue = reducedImg[i]

        if currentValue > threshValue:
            pointSum = pointSum + i
            pointCount = pointCount + 1

    # Get average coordinate of the line:
    y = int(accX / pixelCount)
    # Store in list:
    linePoints.append((x, y))

The red rectangles show the regions I cropped from the input image:

Note that I've stored both points in the linePoints list. Let's check out our approximation by drawing a line that connects both points:

# Get the two points:
p0 = linePoints[0]
p1 = linePoints[1]

# Draw the line:
cv2.line(inputImageCopy, (p0[0], p0[1]), (p1[0], p1[1]), (255, 0, 0), 1)
cv2.imshow("Line", inputImageCopy)
cv2.waitKey(0)

Which yields:

Not bad, huh? Now that we have both points, we can estimate the angle of this line:

# Get angle:
adjacentSide = p1[0] - p0[0]
oppositeSide = p0[1] - p1[1]

# Compute the angle alpha:
alpha = math.degrees(math.atan(oppositeSide / adjacentSide))

print("Angle: "+str(alpha))

This prints:

Angle: 0.534210901840831