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

Randen vertegenwoordigen plotselinge veranderingen in pixelintensiteit, wat meestal overeenkomt met objectgrenzen. Het detecteren van randen helpt bij vormherkenning en segmentatie.

### Sobel-randdetectie

De Sobel-operator berekent gradiënten (veranderingen in intensiteit) in zowel de **X- als Y-richting**, waardoor horizontale en verticale randen kunnen worden gedetecteerd.

```
# 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
```

Belangrijke parameters:
- `src`: invoerafbeelding (moet grijswaarden zijn);
- `ddepth`: diepte van de uitvoerafbeelding (bijv. `cv2.CV_64F`);
- `dx`: orde van de afgeleide in de X-richting (stel in op `1` voor horizontale randen);
- `dy`: orde van de afgeleide in de Y-richting (stel in op `1` voor verticale randen);
- `ksize`: kernelgrootte (moet oneven zijn, bijv. `3`, `5`, `7`).

Opmerking

### Canny-randdetectie

De Canny Edge Detector is een meerstapsalgoritme dat **nauwkeurigere randen oplevert** door:
1.	Het toepassen van een Gaussiaanse vervaging om ruis te verwijderen.
2.	Het vinden van intensiteitsgradiënten met Sobel-filters.
3.	Het onderdrukken van zwakke randen.
4.	Het gebruik van dubbele drempelwaarden en randtracering.

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

- `image`: invoer grijswaardenafbeelding;
- `threshold1`: onderste drempelwaarde voor randdetectie (bijv. `50`);
- `threshold2`: bovenste drempelwaarde voor randdetectie (bijv. `150`);
- `apertureSize` (optioneel): grootte van de Sobel-kernel (standaard: `3`, moet oneven zijn);
- `L2gradient` (optioneel): gebruik nauwkeurigere L2-norm gradiëntberekening (standaard: `False`).

## Een vergelijking van randdetectiemethoden:

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

Verdiep je in computer vision door het beheersen van convolutionele neurale netwerken (CNN's) met TensorFlow en Keras. Deze gevorderde cursus behandelt essentiële concepten en praktische vaardigheden, waaronder beeldvoorbewerking, convolutie- en poolingoperaties, het opbouwen en trainen van CNN-architecturen, het implementeren van objectdetectie en het toepassen van transfer learning om visuele uitdagingen uit de praktijk aan te pakken. Doe praktijkervaring op met het oplossen van complexe vision-problemen met behulp van industriestandaard tools en technieken.

Randdetectie

Sobel-randdetectie

Canny-randdetectie

Een vergelijking van randdetectiemethoden:

Oplossing