Summary  
This chapter covers implementing gradient-based edge detection using Sobel operators and a multi-stage Canny algorithm to locate sudden changes in pixel intensity.  

General domain of usage  
Computer vision

## Randdetectie

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-randdetector 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 gebruiken 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

Uitgebreide introductie tot computer vision, met nadruk op machinewaarneming en interpretatie van visuele data. Behandelt beeldvoorbewerking, feature-extractie, objectdetectie en deep learning-technieken die worden gebruikt in moderne vision-systemen.

Computer vision stelt machines in staat om visuele gegevens te interpreteren en analyseren, vergelijkbaar met menselijke waarneming. Deze sectie behandelt de basisprincipes van beeldrepresentatie, kleurmodellen en wiskundige fundamenten die essentieel zijn voor het begrijpen van hoe computers beelden verwerken. U verkent toepassingen in de praktijk, van autonome voertuigen tot medische beeldvorming, en ontdekt hoe computer vision integreert met AI en machine learning.

OpenCV is een krachtige bibliotheek voor beeldmanipulatie en computervisie-taken. Deze sectie behandelt essentiële technieken zoals beeldfiltering, transformaties, randdetectie en segmentatie. U leert hoe u vervaging, drempelbepaling, contourdetectie en kenmerkextractie uitvoert om beelden efficiënt te verbeteren en te analyseren.

CNN's verwerken visuele data met behulp van convolutie-, pooling- en activatielagen om kenmerken te extraheren voor taken zoals beeldclassificatie en objectdetectie. Belangrijke componenten zijn padding, convolutie voor kenmerkextractie, pooling voor complexiteitsreductie en activatie voor niet-lineariteit. Populaire architecturen zoals AlexNet, VGG en ResNet ondersteunen AI in de gezondheidszorg, autonomie en beveiliging.

Objectdetectie is een fundamentele taak binnen computer vision waarbij objecten in een afbeelding worden geïdentificeerd en gelokaliseerd. In tegenstelling tot beeldclassificatie, waarbij één label aan een volledige afbeelding wordt toegekend, classificeert objectdetectie niet alleen objecten, maar bepaalt ook hun posities met behulp van begrenzingskaders. Deze sectie behandelt belangrijke technieken en algoritmen die worden gebruikt bij objectdetectie, variërend van traditionele methoden tot deep learning-gebaseerde benaderingen zoals YOLO en U-Net.

Computer vision heeft zich in de loop der jaren aanzienlijk ontwikkeld, van eenvoudige beeldverwerkingsmethoden tot complexe deep learning-technieken. Deze sectie behandelt de nieuwste innovaties binnen computer vision, met de nadruk op transfer learning, gezichtsherkenning en beeldgeneratie. We onderzoeken de voordelen van voorgetrainde modellen voor de prestaties, de principes van gezichtsherkenningstechnologie en de wijze waarop AI beelden genereert via deep learning.

Randdetectie

Randdetectie

Sobel-randdetectie

Canny-randdetectie

Een vergelijking van randdetectiemethoden:

Oplossing