Blog SIG & Territoires

Sous l’eau, les différentes longueurs d’onde sont progressivement absorbées : le rouge disparaît en premier, puis l’orange et le jaune. Même à faible profondeur, les photos présentent souvent une dominante bleu-cyan. Résultat : les photos paraissent bleutées ou verdâtres et les coraux perdent leurs couleurs naturelles. Heureusement, on peut corriger cela assez facilement.

À faible profondeur (<2-3m), la perte de rouge est faible mais l’image est souvent dominée par le bleu/cyan.
Pour un traitement automatique (avant CoralReef, par exemple), la meilleure approche est :

1. balance des blancs automatique
2. renforcement léger du rouge
3. réduction du bleu
4. augmentation du contraste

On peut faire cela facilement avec Python + OpenCV sur tout un répertoire.

En traitement scientifique d’images sous-marines, plusieurs méthodes issues de la vision par ordinateur sont couramment utilisées :

• Gray World / White Balance adaptatif
• Red Channel Compensation (RCC) pour reconstruire le rouge perdu
• CLAHE (contrast enhancement)
• parfois Retinex pour corriger l’illumination

Cette combinaison est utilisée dans plusieurs travaux de recherche sur les récifs coralliens et les robots sous-marins.

Je vous propose ici un script Python robuste qui applique :

1️⃣ compensation du canal rouge
2️⃣ balance des blancs Gray-World
3️⃣ amélioration du contraste (CLAHE)
4️⃣ traitement batch d’un dossier

C’est nettement plus performant que les scripts simples.

Script Python

Ce script :

• lit toutes les images d’un dossier
• corrige la balance des blancs
• rééquilibre les canaux couleur
• enregistre les images corrigées dans un nouveau dossier

import cv2
import numpy as np
import os
from pathlib import Path

input_dir = "photos_brutes"
output_dir = "photos_corrigees"

Path(output_dir).mkdir(exist_ok=True)

# -----------------------------
# Red Channel Compensation
# -----------------------------
def red_channel_compensation(img):

    b,g,r = cv2.split(img)

    b_mean = np.mean(b)
    g_mean = np.mean(g)

    r = r + (g_mean - np.mean(r))*0.6
    r = r + (b_mean - np.mean(r))*0.3

    r = np.clip(r,0,255)

    return cv2.merge([b,g,r.astype(np.uint8)])


# -----------------------------
# Gray World White Balance
# -----------------------------
def gray_world(img):

    img = img.astype(np.float32)

    avg_b = np.mean(img[:,:,0])
    avg_g = np.mean(img[:,:,1])
    avg_r = np.mean(img[:,:,2])

    avg = (avg_b + avg_g + avg_r) / 3

    img[:,:,0] *= avg/avg_b
    img[:,:,1] *= avg/avg_g
    img[:,:,2] *= avg/avg_r

    img = np.clip(img,0,255)

    return img.astype(np.uint8)


# -----------------------------
# CLAHE Contrast Enhancement
# -----------------------------
def enhance_contrast(img):

    lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)

    l,a,b = cv2.split(lab)

    clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8,8))
    l = clahe.apply(l)

    lab = cv2.merge((l,a,b))

    return cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)


# -----------------------------
# Pipeline complet
# -----------------------------
def process(img):

    img = red_channel_compensation(img)
    img = gray_world(img)
    img = enhance_contrast(img)

    return img


# -----------------------------
# Batch processing
# -----------------------------
for file in os.listdir(input_dir):

    if file.lower().endswith((".jpg",".jpeg",".png",".tif",".tiff")):

        path = os.path.join(input_dir,file)

        img = cv2.imread(path)

        if img is None:
            print("image ignorée:", file)
            continue

        corrected = process(img)

        outpath = os.path.join(output_dir,file)

        cv2.imwrite(outpath,corrected)

        print("processed:",file)

print("Terminé")

Installation

Dans un fenêtre shell OsGeo4W:

pip install opencv-python numpy

Structure des dossiers

projet/
   script.py
   photos_brutes/
        img1.jpg
        img2.jpg
   photos_corrigees/

Pourquoi cette méthode est utilisée en recherche

Elle corrige les trois problèmes majeurs des images sous-marines :

Résultat :

• couleurs plus naturelles
• textures des coraux plus visibles
• segmentation automatique plus stable

Ce qui est très utile pour les outils d’analyse de récifs

Pourquoi ce script marche bien pour CoralReef

Les outils d’analyse de récifs utilisent souvent :

• segmentation couleur
• classification des coraux

Le script améliore :

• la séparation corail / eau
• la visibilité des textures
• la cohérence colorimétrique

ce qui peut améliorer la détection automatique.

NOTA: Si les images sont faites à très faible profondeur (~1m), vous pouvez réduire légèrement la compensation rouge :

r = r + (g_mean - np.mean(r))*0.4

Ce script Python peut être utilisé comme étape de pré-traitement des images pour l’analyse automatique des récifs coralliens, par exemple avant l’utilisation d’outils de classification ou de segmentation.

Si cet article vous a intéressé et que vous pensez qu'il pourrait bénéficier à d'autres personnes, n'hésitez pas à le partager sur vos réseaux sociaux en utilisant les boutons ci-dessous. Votre partage est apprécié !

Atilio Francois