DEV Community

Cover image for πŸš€ Edge Detection with Threads and MiniMagick in Ruby πŸŒ„
Ernane Ferreira
Ernane Ferreira

Posted on

πŸš€ Edge Detection with Threads and MiniMagick in Ruby πŸŒ„

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 ( xx ) and vertical ( yy ) 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|
Enter fullscreen mode Exit fullscreen mode
  • GxG_x detects horizontal changes.
  • GyG_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Γ—NM \times N :

  1. Initialize Matrices:

    • Create three matrices: GxG_x , GyG_y , and GG , each of size MΓ—NM \times N . These will store the horizontal, vertical, and final edge information, respectively.
  2. Convolution Operation:

    • For each pixel, the gradient in the xx -direction ( GxG_x ) and yy -direction ( GyG_y ) is calculated using the convolution matrices.
  3. Combine Results:

    • Finally, the gradient magnitudes are combined to form the final edge-detected image, GG .
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
Enter fullscreen mode Exit fullscreen mode

🧡 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 GxG_x .
  • Another thread handles the vertical edges with GyG_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 xx -direction.
  • Thread 2: Computes the edge detection in the yy -direction.
  • Final step: The results from both threads are combined to produce the final edge map, GG .

πŸ–ΌοΈ 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
Coins Coins
Dog Dog
Lena Lena
UFRN UFRN

🎯 Conclusion

By leveraging the power of Ruby threads, this project demonstrates how to efficiently apply edge detection to images in both the horizontal ( xx ) and vertical ( yy ) 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. πŸŽ‰

Top comments (0)