Digital image processing is a fascinating field where computers are used to transform, enhance, and interpret images. It plays a crucial role in numerous applications, from medical imaging to computer vision and machine learning. One of the foundational techniques in this domain is edge detection ✨— a method used to identify significant transitions in pixel intensities, enabling us to detect objects and boundaries within images.

🔍 Why Edge Detection Matters

Edges are essentially where the most critical information of an image lies. They represent boundaries between different objects, colors, or textures, making them vital for tasks like segmentation and object recognition. Without edge detection, computers would struggle to differentiate between regions in an image.

🔨 How Edge Detection Works

Edge detection is primarily achieved through mathematical operations called convolutions. By applying convolution filters, we can detect changes in pixel intensities in both the horizontal ( $x$ ) and vertical ( $y$ ) directions. The most commonly used filters for edge detection are the Prewitt, Sobel, and Canny operators. In this project, we focus on using the Prewitt operator to perform this task.

Consider the following convolution matrices for detecting edges in both directions:

Gx = |-1  0  1|    Gy = |-1 -1 -1|
     |-1  0  1|        |  0  0  0|
     |-1  0  1|        |  1  1  1|

• $G_x$ detects horizontal changes.
• $G_y$ detects vertical changes.

By applying these matrices across the image, we extract valuable edge information for each pixel. The final edge map is generated by combining both directional components.

📋 Step-by-Step Process

Let's walk through the basic algorithm to detect edges in a grayscale image of size $M \times N$ :

1. Initialize Matrices:

   • Create three matrices: $G_x$ , $G_y$ , and $G$ , each of size $M \times N$ . These will store the horizontal, vertical, and final edge information, respectively.

2. Convolution Operation:

   • For each pixel, the gradient in the $x$ -direction ( $G_x$ ) and $y$ -direction ( $G_y$ ) is calculated using the convolution matrices.

3. Combine Results:

   • Finally, the gradient magnitudes are combined to form the final edge-detected image, $G$ .

For i from 1 to M-2
  For j from 1 to N-2
    Gx(i, j) = [ I(i+1, j-1) + I(i+1, j) + I(i+1, j+1) ] - [ I(i-1, j-1) + I(i-1, j) + I(i-1, j+1) ]
    If Gx(i, j) < 0, Gx(i, j) = 0
    If Gx(i, j) > 255, Gx(i, j) = 255
  end-for
end-for

For i from 0 to M-1
  For j from 0 to N-1
    G(i, j) = Gx(i, j) + Gy(i, j)
    If G(i, j) > 255, G(i, j) = 255
  end-for
end-for

🧵 Multi-Threaded Implementation in Ruby

A key feature of this project is its use of multi-threading to parallelize the edge detection process 🧑‍💻. Instead of processing the entire image in a single thread, the work is divided into two threads:

• One thread calculates the horizontal edges using $G_x$ .
• Another thread handles the vertical edges with $G_y$ .

This approach significantly speeds up the computation, especially for large images.

• Main thread: Reads the input image, initializes matrices, and spawns two threads.
• Thread 1: Computes the edge detection in the $x$ -direction.
• Thread 2: Computes the edge detection in the $y$ -direction.
• Final step: The results from both threads are combined to produce the final edge map, $G$ .

🖼️ Results

Here are examples of processed images using this method. The left column shows the original images, and the right column presents the edge-detected outputs:

Original	Processed

🎯 Conclusion

By leveraging the power of Ruby threads, this project demonstrates how to efficiently apply edge detection to images in both the horizontal ( $x$ ) and vertical ( $y$ ) directions. The results show how edge detection enhances the structural details of images, making them more suitable for tasks like object recognition and segmentation. This approach not only speeds up the processing but also makes it scalable for larger datasets.

For more details and to explore the code, visit the GitHub repository. 🎉