[Feature]: Add Canny Edge Detection Algorithm

[ana-jiangR]

🚀 Feature Description

Add a Canny edge detection function to kornia-imgproc. Canny is an edge detection algorithm that produces clean 1-pixel-wide binary edge maps from grayscale images.
kornia-rs already has the two main building blocks (Gaussian blur and Sobel) for this algorithm.

📂 Feature Category

Rust Core Library

💡 Motivation

Canny is one of the most widely used edge detection algorithms in computer vision. Having Canny would give new features to kornia-rs that depend on edge detection as input. Right now Kornia already has kornia.filters.Canny, but there's no Rust equivalent in kornia-rs yet.
Also, it is a natural addition to kornia-rs's current image processing pipeline. It can be built directly based on the existing Gaussian blur and Sobel operators.

💭 Proposed Solution

Add canny.rs inside crates/kornia-imgproc/src. The signature is below:

pub fn canny<A1, A2, A3>(
    src: &Image<u8, 1, A1>,
    magnitude: &mut Image<f32, 1, A2>,
    edges: &mut Image<u8, 1, A3>,
    low_threshold: f32,
    high_threshold: f32,
    kernel_size: usize,
    hysteresis: bool,
) -> Result<(), ImageError>

The input is a single-channel u8 grayscale image. The function internally converts to f32 for processing. The edge output is a binary u8 image where edges are 255 and non-edges are 0. The magnitude output is f32 for raw gradient strength.

The implementation follows the standard 5-stage pipeline:

1. Gaussian blur (existing gaussian_blur)
2. Sobel gradients (existing separable_filter + sobel_kernel_1d)
3. Non-maximum suppression along gradient direction
4. Double thresholding
5. BFS-based hysteresis edge tracking

📚 Library Reference

The implementation of this feature is basically based on:

• Kornia: https://github.com/kornia/kornia/blob/main/kornia/filters/canny.py
• OpenCV: https://docs.opencv.org/4.x/dd/d1a/group__imgproc__feature.html#ga04723e007ed888ddf11d9ba04e2232de

🔄 Alternatives Considered

No response

🎯 Use Cases

It will be useful for contour extraction (as kornia-rs already has find_contour), object boundary/edge detection, lane detection, and general feature extraction pipelines.

kornia-rs currently have Sobel gradients, gaussian blur, and binary thresholding. A typical workaround would be to threshold Sobel magnitude.
Here is a comparison between the typical workaround and the demo implementation of canny:

Input grayscale image:

Sobel threshold:

Canny edges:

For this image, canny edge detection algorithm works better than sobel threshold method.

📝 Additional Context

I currently have a working demo implementation.
Happy to submit a PR and continue work on it if approved!

🤝 Contribution Intent

• I plan to submit a PR to implement this feature
• I'm requesting this feature but not planning to implement it

[github-actions]

⚠️ Before Submitting a PR

Please wait for a maintainer to approve and assign this issue to you or someone else before submitting a PR. PRs submitted without prior approval and assignment may be closed. See our Contributing Guide for details.

[ana-jiangR]

Hi @edgarriba , @cjpurackal , @sidd-27 , I would like to work on this if approved! Could you assign this issue to me? I currently have a working demo and would be able to submit a pr soon. Thank you!

[Akarshak51]

Hi @edgarriba @cjpurackal @sidd-27,

I'm very interested in implementing the Canny Edge Detection algorithm for kornia-rs. I have thoroughly analyzed the issue and am confident I can deliver a high-quality implementation.

Understanding of the Task

Based on my analysis, this feature requires implementing a canny() function that:

• Accepts a single-channel u8 grayscale image as input
• Internally converts to f32 for processing
• Outputs a binary u8 image with edges marked as 255 and non-edges as 0
• Includes parameters for low_threshold, high_threshold, and kernel_size

Implementation Plan

The 5-stage pipeline implementation will follow the proven approach already used in OpenCV and the existing Kornia Python implementation:

1. Gaussian Blur - Using the existing gaussian_blur() function to smooth the image
2. Sobel Gradients - Computing magnitude and direction using existing separable_filter and sobel_kernel_id
3. Non-maximum Suppression - Suppressing gradients perpendicular to edge direction
4. Double Thresholding - Classifying pixels as strong/weak edges based on thresholds
5. Hysteresis Edge Tracking - Connecting weak edges to strong edges using BFS

Technical Approach

• Leverage existing building blocks (gaussian_blur, separable_filter) to ensure consistency with the library
• Use the reference implementation from OpenCV and Kornia's Python version as guides
• Follow Rust best practices and kornia-rs code style
• Write comprehensive tests covering edge cases
• Add documentation with examples and references

Why I'm Qualified

• Strong understanding of image processing algorithms and Rust
• Experience implementing complex algorithms with multiple stages
• Committed to following the contribution guidelines and maintaining code quality
• Ready to submit a well-tested, documented PR immediately upon assignment

I'm ready to start implementation right away. Could you please assign this issue to me?

Thank you!

[Akarshak51]

Hi @edgarriba @cjpurackal @sidd-27,

I'm very impressed with this feature proposal and the comprehensive analysis provided by @ana-jiangR. I'm also interested in contributing to the Canny Edge Detection implementation for kornia-rs.

My Expertise:

• Rust programming and image processing algorithms
• Computer vision algorithm implementation
• Strong understanding of the 5-stage Canny pipeline
• Experience with Gaussian blur and Sobel gradient operations
• Able to write efficient, well-tested Rust code

Proposed Contribution:
While I see strong interest from the community (@ana-jiangR ), I'd like to offer my support in the following ways:

1. Code Review & Testing - Review any submitted PR and provide detailed feedback
2. Non-maximum Suppression - Implement this critical stage of the pipeline
3. Hysteresis Edge Tracking - Implement the BFS-based edge tracking module
4. Comprehensive Testing - Create edge case tests and comparison tests with reference implementations
5. Documentation - Write usage examples and algorithm documentation

Understanding of the Task:
Based on the issue description, I understand the need to:

• Create canny.rs in crates/kornia-imgproc/src
• Implement the 5-stage pipeline using existing building blocks (gaussian_blur, separable_filter, sobel_kernel_1d)
• Handle u8 grayscale input, convert to f32 for processing, output binary u8 edges
• Support customizable low/high thresholds and kernel sizes
• Implement optional hysteresis for edge connectivity

I'm ready to collaborate with whoever is assigned to this issue and help accelerate development. The implementation can leverage the excellent references from OpenCV and Kornia's Python implementation.

Looking forward to working on this feature!

Best regards

[ana-jiangR]

Hi @Akarshak51, sorry I already have a working implementation of it, and I would like to submit this as a pr for this issue. Maybe you could find other issues or raise new ones? Thank you!