📏 Line Detection in Digital Image Processing

Directional Masks, Convolution, Hough Transform & Beginner Python

📌 1. What is Line Detection?

```

Line detection is an image processing technique used to identify straight-line structures in an image.

A line may be horizontal, vertical, diagonal, or may have an arbitrary orientation.

Simple idea: A line is detected when neighboring pixels show a particular intensity pattern corresponding to a specific direction.

Line detection is especially useful when the image contains roads, document borders, structural components, lanes, cracks, or other approximately straight structures.

```

🎯 2. Why Do We Need Line Detection?

```

🛣️ Road Detection

Straight or approximately straight road markings can be identified.

📄 Document Processing

Borders, tables and text-line structures can be analyzed.

🏭 Industrial Inspection

Linear cracks, edges and structural components can be detected.

🤖 Computer Vision

Line information can provide useful geometric information.

```

🧮 3. Basic Principle of Line Detection

```

A small convolution mask is moved across an image. Different masks are designed to respond strongly to different line orientations.

Consider a 3×3 neighborhood:

z₁   z₂   z₃
z₄   z₅   z₆
z₇   z₈   z₉

A line-detection mask multiplies each pixel by a corresponding mask coefficient and adds the results.

R = ΣΣ w(i,j) × z(i,j)

A large response indicates that the local neighborhood resembles the orientation represented by the mask.

```

➡️ 4. Horizontal Line Detection Mask

```

A commonly used horizontal-line mask is:

-1   -1   -1
+2   +2   +2
-1   -1   -1

The positive middle row responds strongly when the local neighborhood contains a horizontal line.

```

⬇️ 5. Vertical Line Detection Mask

```

A commonly used vertical-line mask is:

-1   +2   -1
-1   +2   -1
-1   +2   -1

The positive middle column responds strongly to vertical structures.

```

↘️ 6. +45° Diagonal Line Detection

```

A diagonal line can be detected using a directional mask such as:

-1   -1   +2
-1   +2   -1
+2   -1   -1

This mask responds strongly to the diagonal pattern represented by its positive diagonal.

```

↙️ 7. −45° Diagonal Line Detection

```

Another diagonal direction can be detected using:

+2   -1   -1
-1   +2   -1
-1   -1   +2

By using different masks, different orientations can be investigated.

```

📊 8. Four Basic Directional Masks

```

Direction	Mask	Main Response
Horizontal	-1 -1 -1 / 2 2 2 / -1 -1 -1	Horizontal structures
Vertical	-1 2 -1 / -1 2 -1 / -1 2 -1	Vertical structures
Diagonal 1	-1 -1 2 / -1 2 -1 / 2 -1 -1	One diagonal orientation
Diagonal 2	2 -1 -1 / -1 2 -1 / -1 -1 2	Opposite diagonal orientation

Important: The exact mask used can vary depending on the image processing method and whether the desired line is represented as a bright or dark structure.

```

🔄 9. Convolution Process

```

Line detection using masks is based on convolution.

1. Select a small mask.
2. Place the mask over an image neighborhood.
3. Multiply corresponding pixels and mask values.
4. Add all products.
5. Store the response.
6. Move the mask to the next pixel.
7. Repeat until the image has been processed.

Response = ΣΣ Image(x+i,y+j) × Mask(i,j)

```

🧠 10. Worked Numerical Example

```

Suppose an image contains the following 3×3 neighborhood:

10   10   10
80   80   80
10   10   10

Use the horizontal line mask:

-1   -1   -1
+2   +2   +2
-1   -1   -1

The response is:

R = (-10-10-10) + (160+160+160) + (-10-10-10)

R = 360

The large positive response indicates a strong horizontal-line pattern.

```

📐 11. Thresholding the Line Response

```

After calculating the convolution response, a threshold can be used to determine whether a line is present.

|R| > T

where:

• R = line detection response
• T = threshold

If the absolute response is greater than the threshold, the location can be considered a possible line point.

```

📏 12. Hough Transform for Line Detection

```

Directional convolution masks are useful for detecting particular local line patterns. For detecting longer straight lines, another important technique is the Hough Transform.

A line can be represented using the polar equation:

ρ = x cos θ + y sin θ

where:

• ρ is the perpendicular distance from the origin.
• θ is the angle of the perpendicular line.
• x,y represent an image point.

Each edge pixel can vote for possible lines in parameter space. Peaks in the accumulator indicate strong line candidates.

Important distinction: A convolution mask detects local line patterns, whereas the Hough Transform is particularly useful for finding longer straight lines and their parameters.

```

🔬 13. Hough Line Detection — Basic Steps

```

1. Convert the image to grayscale.
2. Detect edges, commonly using Canny.
3. Transform edge pixels into Hough parameter space.
4. Accumulate votes for possible lines.
5. Find strong peaks in the accumulator.
6. Convert detected parameters back to image lines.

```

🐍 14. Beginner Python — Directional Line Mask

```

This example demonstrates horizontal line detection using OpenCV.

import cv2 ``` import numpy as np # Read the image image = cv2.imread("image.jpg") # Convert image to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Horizontal line mask kernel = np.array([ [-1, -1, -1], [ 2, 2, 2], [-1, -1, -1] ]) # Apply the mask result = cv2.filter2D( gray, cv2.CV_64F, kernel ) # Convert to displayable image result = cv2.convertScaleAbs(result) # Display images cv2.imshow("Original", image) cv2.imshow("Horizontal Lines", result) cv2.waitKey(0) cv2.destroyAllWindows()

```

Beginner explanation:

np.array() creates the line-detection mask.
cv2.filter2D() applies convolution.
cv2.convertScaleAbs() converts the result into a displayable 8-bit image.
cv2.imshow() displays the result.

```

🐍 15. Beginner Python — Vertical Line Detection

```

import cv2 ``` import numpy as np # Read image image = cv2.imread("image.jpg") # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Vertical line mask kernel = np.array([ [-1, 2, -1], [-1, 2, -1], [-1, 2, -1] ]) # Apply mask result = cv2.filter2D( gray, cv2.CV_64F, kernel ) # Convert result result = cv2.convertScaleAbs(result) # Show result cv2.imshow("Original", image) cv2.imshow("Vertical Lines", result) cv2.waitKey(0) cv2.destroyAllWindows()

🐍 16. Beginner Python — Hough Line Detection

```

The following example first detects edges and then uses the standard Hough Line Transform.

import cv2 ``` import numpy as np # Read image image = cv2.imread("image.jpg") # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Detect edges edges = cv2.Canny( gray, 50, 150 ) # Detect lines lines = cv2.HoughLines( edges, 1, np.pi / 180, 100 ) # Draw detected lines if lines is not None: ``` for line in lines: rho, theta = line[0] a = np.cos(theta) b = np.sin(theta) x0 = a * rho y0 = b * rho x1 = int(x0 + 1000 * (-b)) y1 = int(y0 + 1000 * (a)) x2 = int(x0 - 1000 * (-b)) y2 = int(y0 - 1000 * (a)) cv2.line( image, (x1, y1), (x2, y2), (0, 0, 255), 2 ) ``` cv2.imshow("Detected Lines", image) cv2.waitKey(0) cv2.destroyAllWindows()

📦 17. Install Python Libraries

```

pip install opencv-python ``` pip install numpy

```

Import them using:

import cv2 ``` import numpy as np

🧪 18. Interactive 3×3 Line Detection

```

🎛️ Enter a 3×3 Neighborhood

Try the default values to see a strong horizontal-line response.

Detection Direction: Horizontal Vertical Diagonal 1 Diagonal 2 Threshold:

Enter values and click Detect Line.

3×3 Pixel Neighborhood

```

⚖️ 19. Point Detection vs Line Detection vs Edge Detection

```

Technique	Main Target	Typical Operator
Point Detection	Isolated points	Laplacian-type mask
Line Detection	Straight line structures	Directional masks / Hough Transform
Edge Detection	Boundaries	Sobel / Prewitt / Canny

```

⚠️ 20. Limitations of Line Detection

```

• Noise can produce unwanted responses.
• Threshold selection affects the result.
• Short or broken lines can be difficult to detect.
• Curved structures are not represented by a single straight line.
• Hough Transform can require significant computation for large parameter spaces.
• Different orientations may require different masks or parameters.

```

🎓 21. B.Sc. Computer Science Honours — Exam Points

```

• Define line detection.
• Explain convolution-based line detection.
• Write the horizontal line detection mask.
• Write the vertical line detection mask.
• Explain diagonal line detection masks.
• Solve a numerical line-detection problem.
• Explain thresholding of the line response.
• Define the Hough Transform.
• Explain the polar representation of a straight line.
• Explain the Hough accumulator.
• Differentiate point, line and edge detection.
• Write Python code for line detection using OpenCV.

```

💡 22. Quick Revision

```

Term	Meaning
Line Detection	Detection of straight-line structures
Directional Mask	Kernel designed for a particular line orientation
Convolution	Operation between an image neighborhood and a mask
Response	Output generated by the mask
Threshold	Value used to identify strong responses
Hough Transform	Technique for detecting geometric lines using parameter space
ρ	Distance parameter in polar line representation
θ	Angular parameter in polar line representation

```

CREATED BY BIJAN KRISHNA PAUL