Summary  
This chapter shows how to implement code for histogram equalization to enhance image contrast by redistributing pixel intensities globally and locally using adaptive (CLAHE) methods to limit noise amplification.

General domain of usage  
Digital image processing

## Enkel histogramutjämning

Histogramutjämning är en teknik som används för att **förbättra den globala kontrasten** i en bild. Metoden fungerar genom att omfördela intensitetsvärdena så att de täcker hela det möjliga intervallet (0 till 255 i 8-bitarsbilder). Detta är särskilt användbart för bilder som är för mörka eller för ljusa, eftersom det gör detaljer mer synliga genom att utjämna histogrammet av pixelintensiteter.

```
equalized = cv2.equalizeHist(image)
```

- `cv2.equalizeHist(image)`  
  - `image`: inmatad gråskalebild (måste vara enkelkanalig);
  - Returnerar en ny bild med förbättrad kontrast genom att sträcka ut och platta till histogrammet.

Denna metod är global – den förbättrar kontrasten i hela bilden jämnt, vilket kan leda till överförstärkning i vissa områden och förlust av detaljer i andra.

Notera


## **Adaptiv histogramutjämning (CLAHE)**

CLAHE (Contrast Limited Adaptive Histogram Equalization) är en avancerad version av histogramutjämning som arbetar på små regioner (rutor) av bilden istället för hela bilden. Förbättrar **lokal kontrast** och undviker att förstärka brus för mycket genom att begränsa histogramkontrasten inom varje ruta.

```
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
clahe_equalized = clahe.apply(image)
```

- `cv2.createCLAHE(...)` skapar ett CLAHE-objekt med:
  - `clipLimit`: tröskelvärde för kontrastbegränsning (högre värde = mer kontrast);
  - `tileGridSize`: storlek på rutnätet för att dela upp bilden i rutor (t.ex. 8x8).
- `clahe.apply(image)` applicerar CLAHE på inmatningsbilden.

CLAHE är särskilt effektivt på bilder med varierande ljusförhållanden eller där det är viktigt att bevara lokala detaljer, såsom medicinsk avbildning eller fotografering i svagt ljus.

Notering

import unittest
import numpy as np
import importlib

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 TestHistogramEqualization(unittest.TestCase):

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

    def test_equalized_shape_and_type(self):
        original_shape = user_code.image.shape
        arr = getattr(user_code, "equalized", None)
        _dynamic_test(
            self,
            isinstance(arr, np.ndarray) and arr.shape == original_shape,
            "Equalized image is a NumPy array with correct shape.",
            f"The variable `equalized` should be a NumPy array with shape {original_shape}."
        )

    def test_clahe_equalized_shape_and_type(self):
        original_shape = user_code.image.shape
        arr = getattr(user_code, "clahe_equalized", None)
        _dynamic_test(
            self,
            isinstance(arr, np.ndarray) and arr.shape == original_shape,
            "CLAHE equalized image is a NumPy array with correct shape.",
            f"The variable `clahe_equalized` should be a NumPy array with shape {original_shape}."
        )

    def test_equalized_histogram_change(self):
        original_hist = np.histogram(user_code.image.ravel(), bins=256)[0]
        equalized = getattr(user_code, "equalized", None)
        eq_hist = np.histogram(equalized.ravel(), bins=256)[0] if isinstance(equalized, np.ndarray) else original_hist
        _dynamic_test(
            self,
            isinstance(equalized, np.ndarray) and not np.array_equal(original_hist, eq_hist),
            "Equalized image histogram differs from original.",
            "The variable `equalized` should be a NumPy array with a changed histogram."
        )

    def test_clahe_histogram_change(self):
        original_hist = np.histogram(user_code.image.ravel(), bins=256)[0]
        clahe = getattr(user_code, "clahe_equalized", None)
        clahe_hist = np.histogram(clahe.ravel(), bins=256)[0] if isinstance(clahe, np.ndarray) else original_hist
        _dynamic_test(
            self,
            isinstance(clahe, np.ndarray) and not np.array_equal(original_hist, clahe_hist),
            "CLAHE equalized image histogram differs from original.",
            "The variable `clahe_equalized` should be a NumPy array with a changed histogram."
        )

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


test_code.py

Omfattande introduktion till datorseende med fokus på maskinell perception och tolkning av visuella data. Täcker bildförbehandling, funktionsutvinning, objektdetektering och djupinlärningstekniker som används i moderna visionssystem.

Datorseende möjliggör för maskiner att tolka och analysera visuella data, vilket efterliknar mänsklig perception. Detta avsnitt behandlar grunderna i bildrepresentation, färgmodeller och matematiska grunder som är nödvändiga för att förstå hur datorer bearbetar bilder. Du får utforska tillämpningar i verkliga världen, från autonoma fordon till medicinsk bildbehandling, samt hur datorseende integreras med AI och maskininlärning.

OpenCV är ett kraftfullt bibliotek för bildmanipulation och datorseendeuppgifter. Detta avsnitt behandlar grundläggande tekniker såsom bildfiltrering, transformationer, kantdetektion och segmentering. Du får kunskap om hur man utför suddning, tröskling, konturdetektion och funktionsutvinning för att effektivt förbättra och analysera bilder.

CNN bearbetar visuella data med hjälp av konvolution, pooling och aktiveringslager för att extrahera egenskaper för uppgifter som bildklassificering och objektigenkänning. Viktiga komponenter inkluderar utfyllnad, konvolution för egenskapsutvinning, pooling för komplexitetsreduktion och aktivering för icke-linjäritet. Populära arkitekturer som AlexNet, VGG och ResNet driver AI inom hälso- och sjukvård, autonomi och säkerhet.

Objektdetektering är en grundläggande uppgift inom datorseende som innebär att identifiera och lokalisera objekt i en bild. Till skillnad från bildklassificering, som tilldelar en enda etikett till en hel bild, klassificerar objektdetektering inte bara objekt utan bestämmer även deras positioner med hjälp av avgränsningsrutor. Detta avsnitt behandlar centrala tekniker och algoritmer som används vid objektdetektering, från traditionella metoder till djupinlärningsbaserade tillvägagångssätt som YOLO och U-Net.

Datorseende har utvecklats avsevärt genom åren, från grundläggande bildbehandlingsmetoder till avancerade djupinlärningstekniker. Detta avsnitt behandlar de senaste innovationerna inom datorseende, med fokus på transferinlärning, ansiktsigenkänning och bildgenerering. Vi undersöker fördelarna med förtränade modeller för prestanda, principerna bakom ansiktsigenkänningsteknik samt hur AI skapar bilder med hjälp av djupinlärning.

Histogramutjämning

Enkel histogramutjämning

Adaptiv histogramutjämning (CLAHE)

Lösning