Summary  
This chapter demonstrates how to implement Sobel and Canny edge detection to compute image gradients, suppress noise, and extract object boundaries.  

General domain of usage  
Image processing

Les contours représentent des changements soudains d'intensité des pixels, ce qui correspond généralement aux frontières des objets. La détection des contours aide à la reconnaissance des formes et à la segmentation.

### Détection de contours de Sobel

L'opérateur Sobel calcule les gradients (variations d'intensité) dans les **directions X et Y**, ce qui permet de détecter les contours horizontaux et verticaux.

```
# Convert to grayscale
image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

# Apply Sobel filter
sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=5)  # Detects vertical edges
sobel_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=5)  # Detects horizontal edges
sobel_combined = cv2.magnitude(sobel_x, sobel_y)  # Combines both directions
```

Paramètres clés :
- `src` : image d'entrée (doit être en niveaux de gris) ;
- `ddepth` : profondeur de l'image de sortie (par exemple, `cv2.CV_64F`) ;
- `dx` : ordre de la dérivée dans la direction X (mettre `1` pour les contours horizontaux) ;
- `dy` : ordre de la dérivée dans la direction Y (mettre `1` pour les contours verticaux) ;
- `ksize` : taille du noyau (doit être impaire, par exemple, `3`, `5`, `7`).

Note

### Détection de contours de Canny

Le détecteur de contours de Canny est un algorithme multi-étapes qui **fournit des contours plus précis** en :
1.	Appliquant un flou gaussien pour supprimer le bruit.
2.	Calculant les gradients d'intensité à l'aide des filtres Sobel.
3.	Supprimant les contours faibles.
4.	Utilisant un double seuillage et un suivi des contours.

```
# Apply Canny Edge Detector 
canny_image = cv2.Canny(image, threshold1, threshold2, apertureSize, L2gradient)  
```

- `image`: image d'entrée en niveaux de gris ;
- `threshold1`: seuil inférieur pour la détection des contours (par exemple, `50`) ;
- `threshold2`: seuil supérieur pour la détection des contours (par exemple, `150`) ;
- `apertureSize` (optionnel) : taille du noyau Sobel (par défaut : `3`, doit être impair) ;
- `L2gradient` (optionnel) : utilisation d'un calcul de gradient L2 plus précis (par défaut : `False`).

## Comparaison des méthodes de détection de contours :

import unittest
import numpy as np
import importlib
import cv2

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestEdgeDetection(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        global user_code
        user_code = importlib.import_module("user_code")

    def test_output_types(self):
        gray = getattr(user_code, "gray_image", None)
        sobel = getattr(user_code, "sobel_img", None)
        canny = getattr(user_code, "canny_img", None)
        _dynamic_test(
            self,
            all(isinstance(x, np.ndarray) for x in [gray, sobel, canny]),
            "All edge detection outputs are NumPy arrays.",
            "Grayscale, Sobel, and Canny images should all be NumPy arrays."
        )

    def test_sobel_kernel_parameters(self):
        gray = user_code.gray_image
        sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
        sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
        combined = cv2.magnitude(sobel_x, sobel_y)
        student = user_code.sobel_img

        similarity = np.allclose(student, combined, atol=1e-5)
        _dynamic_test(
            self,
            similarity,
            "Sobel image matches expected output with kernel size of 3 and depth as cv2.CV_64F.",
            "Sobel image does not match expected output using correct parameters (kernel size of 3, depth as cv2.CV_64F)."
        )

    def test_canny_thresholds(self):
        gray = user_code.gray_image
        expected = cv2.Canny(gray, 200, 300)
        student = user_code.canny_img

        similarity = np.array_equal(student, expected)
        _dynamic_test(
            self,
            similarity,
            "Canny edge output matches thresholds 200-300.",
            "Canny edge image should be computed with thresholds 200 and 300."
        )

if __name__ == "__main__":
    unittest.main()


test_code.py

Plongez au cœur de la vision par ordinateur en maîtrisant les réseaux de neurones convolutifs (CNN) avec TensorFlow et Keras. Ce cours avancé couvre les concepts essentiels et les compétences pratiques, notamment le prétraitement d’images, les opérations de convolution et de pooling, la conception et l’entraînement d’architectures CNN, la mise en œuvre de la détection d’objets et l’application de l’apprentissage par transfert pour relever des défis visuels concrets. Acquérez une expérience pratique dans la résolution de problèmes complexes de vision à l’aide d’outils et de techniques reconnus dans l’industrie.

Détection de Contours

Détection de contours de Sobel

Détection de contours de Canny

Comparaison des méthodes de détection de contours :

Solution