Oui. La structure générale est déjà saine : séparation détection/validation/homographie, fallback Hough, rapport CSV et dossier de contrôle manuel. Les gains les plus importants viendront surtout de la sélection du meilleur quadrilatère, de la robustesse géométrique et du diagnostic, plutôt que d’ajouter davantage de seuils fixes.

J’ai repéré deux points qui peuvent fausser vos résultats sans provoquer d’erreur visible : votre CSV ne contient actuellement aucune des métriques diagnostiques pourtant calculées, et les champs contour_tente / hough_tente restent à False lorsque la méthode a bien été exécutée mais n’a trouvé aucun candidat. Ce sont de bons premiers correctifs, car ils rendent ensuite le réglage des seuils beaucoup plus fiable.

Oui. Votre pipeline est bien découpé, mais plusieurs améliorations peuvent augmenter nettement la robustesse sans passer à un modèle IA.

1. Il y a un petit bug dans le diagnostic des angles

Ici :

python
if max_angle_deviation > ANGLE_TOLERANCE_DEG:
    return False, f"angle_aberrant ({max_angle_deviation + 90:.0f}°)", metrics

max_angle_deviation est une distance à 90°, pas l'angle lui-même.

Par exemple, si l'angle problématique vaut 30°, l'écart vaut 60°, et votre message indiquera 150°.

Il vaut mieux conserver l'angle réellement problématique :

python
deviations = [abs(a - 90) for a in angles]
worst_index = int(np.argmax(deviations))
max_angle_deviation = deviations[worst_index]
worst_angle = angles[worst_index]

metrics = {
    "area_ratio": round(area_ratio, 3),
    "max_angle_deviation": round(max_angle_deviation, 1),
    "worst_angle": round(worst_angle, 1),
    "aspect_ratio": round(aspect_ratio, 2),
}

if max_angle_deviation > ANGLE_TOLERANCE_DEG:
    return False, f"angle_aberrant ({worst_angle:.1f}°)", metrics

Mais je recommande en réalité d'aller plus loin : ne plus vérifier que les angles ressemblent à 90°.

Une projection perspective d'un rectangle peut produire des angles très éloignés de 90°. Ce que vous voulez réellement éliminer, ce sont les quadrilatères quasi dégénérés, avec par exemple des angles de 3° ou 177°.

Je remplacerais donc :

python
ANGLE_TOLERANCE_DEG = 55

par :

python
MIN_INTERNAL_ANGLE = 12
MAX_INTERNAL_ANGLE = 168

puis :

python
if min(angles) < MIN_INTERNAL_ANGLE:
    return False, f"angle_trop_aigu ({min(angles):.1f}°)", metrics

if max(angles) > MAX_INTERNAL_ANGLE:
    return False, f"angle_trop_plat ({max(angles):.1f}°)", metrics

C'est beaucoup plus cohérent avec votre problème.

2. order_points() peut se tromper sous forte perspective

La technique x+y / x-y est très courante, mais elle peut produire des doublons ou un mauvais ordre sur des quadrilatères très déformés.

Je la remplacerais par un ordre circulaire autour du centre :

python
def order_points(pts):
    """
    Ordonne les points TL, TR, BR, BL de manière plus robuste,
    même lorsque le quadrilatère est fortement déformé.
    """
    pts = np.asarray(pts, dtype=np.float32).reshape(4, 2)

    hull = cv2.convexHull(pts).reshape(-1, 2)

    if len(hull) != 4:
        raise ValueError("Les 4 points ne forment pas un quadrilatère convexe")

    center = hull.mean(axis=0)

    angles = np.arctan2(
        hull[:, 1] - center[1],
        hull[:, 0] - center[0],
    )

    ordered = hull[np.argsort(angles)]

    # Commencer par le point le plus proche du haut-gauche
    start = np.argmin(ordered[:, 0] + ordered[:, 1])
    ordered = np.roll(ordered, -start, axis=0)

    # On veut TL, TR, BR, BL et non TL, BL, BR, TR
    if ordered[1, 0] < ordered[3, 0]:
        ordered = ordered[[0, 3, 2, 1]]

    return ordered.astype(np.float32)

Cela évite un certain nombre de quadrilatères auto-croisés ou mal ordonnés.

3. Ajoutez une vraie validation de convexité et de longueur des côtés

Actuellement, un quadrilatère peut théoriquement passer plusieurs tests tout en étant géométriquement très mauvais.

Je renforcerais validate_quadrilateral() avec :

python
MIN_EDGE_RATIO = 0.03
MAX_OUTSIDE_MARGIN = 0.15
MIN_INTERNAL_ANGLE = 12
MAX_INTERNAL_ANGLE = 168

Puis :

python
def validate_quadrilateral(rect, image_shape):
    h_img, w_img = image_shape[:2]
    image_area = h_img * w_img

    rect = np.asarray(rect, dtype=np.float32).reshape(4, 2)

    # --------------------------------------------------
    # 1. Convexité
    # --------------------------------------------------
    contour = rect.reshape(-1, 1, 2)

    if not cv2.isContourConvex(contour):
        return False, "quadrilatere_non_convexe", {}

    # --------------------------------------------------
    # 2. Aire
    # --------------------------------------------------
    poly_area = abs(cv2.contourArea(contour))
    area_ratio = poly_area / max(image_area, 1)

    # --------------------------------------------------
    # 3. Longueurs
    # --------------------------------------------------
    tl, tr, br, bl = rect

    edge_lengths = [
        np.linalg.norm(tr - tl),
        np.linalg.norm(br - tr),
        np.linalg.norm(bl - br),
        np.linalg.norm(tl - bl),
    ]

    image_diagonal = math.hypot(w_img, h_img)
    min_edge_ratio = min(edge_lengths) / max(image_diagonal, 1)

    # --------------------------------------------------
    # 4. Angles
    # --------------------------------------------------
    angles = [
        _angle_at_point(bl, tl, tr),
        _angle_at_point(tl, tr, br),
        _angle_at_point(tr, br, bl),
        _angle_at_point(br, bl, tl),
    ]

    # --------------------------------------------------
    # 5. Ratio apparent
    # --------------------------------------------------
    width = (
        np.linalg.norm(tr - tl)
        + np.linalg.norm(br - bl)
    ) / 2

    height = (
        np.linalg.norm(bl - tl)
        + np.linalg.norm(br - tr)
    ) / 2

    aspect_ratio = width / max(height, 1e-6)

    metrics = {
        "area_ratio": round(area_ratio, 4),
        "min_angle": round(min(angles), 1),
        "max_angle": round(max(angles), 1),
        "min_edge_ratio": round(min_edge_ratio, 4),
        "aspect_ratio": round(aspect_ratio, 3),
    }

    # --------------------------------------------------
    # Validation
    # --------------------------------------------------
    if area_ratio < MIN_AREA_RATIO:
        return False, f"aire_trop_petite ({area_ratio:.3f})", metrics

    if area_ratio > MAX_AREA_RATIO:
        return False, f"aire_trop_grande ({area_ratio:.3f})", metrics

    if min_edge_ratio < MIN_EDGE_RATIO:
        return False, "cote_trop_court", metrics

    if min(angles) < MIN_INTERNAL_ANGLE:
        return False, f"angle_trop_aigu ({min(angles):.1f}°)", metrics

    if max(angles) > MAX_INTERNAL_ANGLE:
        return False, f"angle_trop_plat ({max(angles):.1f}°)", metrics

    # Autoriser légèrement les intersections Hough hors image.
    margin_x = MAX_OUTSIDE_MARGIN * w_img
    margin_y = MAX_OUTSIDE_MARGIN * h_img

    for x, y in rect:
        if (
            x < -margin_x
            or x > w_img + margin_x
            or y < -margin_y
            or y > h_img + margin_y
        ):
            return False, "coins_trop_loin_hors_image", metrics

    return True, "ok", metrics

Je supprimerais dans un premier temps le rejet strict :

python
MIN_ASPECT_RATIO
MAX_ASPECT_RATIO

ou je l'élargirais énormément.

La raison est importante : le width / height que vous calculez est le ratio du quadrilatère projeté dans l'image, et non le vrai ratio physique du panneau. Sous forte perspective, il peut être très différent.

4. Ne retournez pas le premier contour à 4 côtés

C'est probablement l'amélioration qui aura le plus d'impact.

Votre code fait actuellement :

python
for contour in contours:
    ...
    if len(approx) == 4:
        return approx.reshape(4, 2)

Ainsi, le premier quadrilatère gagne, même si le deuxième ou troisième correspond beaucoup mieux au panneau.

Je chercherais plutôt tous les candidats, puis je sélectionnerais le meilleur :

python
def detect_corners_contour(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    clahe = cv2.createCLAHE(
        clipLimit=2.0,
        tileGridSize=(8, 8)
    )
    gray = clahe.apply(gray)

    blurred = cv2.GaussianBlur(gray, (5, 5), 0)

    median = np.median(blurred)

    lower = int(max(20, 0.66 * median))
    upper = int(min(255, max(lower + 30, 1.33 * median)))

    edges = cv2.Canny(blurred, lower, upper)

    kernel = cv2.getStructuringElement(
        cv2.MORPH_RECT,
        (3, 3)
    )

    edges = cv2.morphologyEx(
        edges,
        cv2.MORPH_CLOSE,
        kernel,
        iterations=1,
    )

    contours, _ = cv2.findContours(
        edges,
        cv2.RETR_LIST,
        cv2.CHAIN_APPROX_SIMPLE,
    )

    candidates = []

    for contour in sorted(
        contours,
        key=cv2.contourArea,
        reverse=True,
    )[:20]:

        perimeter = cv2.arcLength(contour, True)

        if perimeter <= 0:
            continue

        # Plusieurs epsilon plutôt qu'une seule valeur magique
        for epsilon_ratio in (0.01, 0.015, 0.02, 0.03, 0.04):
            approx = cv2.approxPolyDP(
                contour,
                epsilon_ratio * perimeter,
                True,
            )

            if len(approx) != 4:
                continue

            points = approx.reshape(4, 2)

            try:
                rect = order_points(points)
            except ValueError:
                continue

            valid, _, metrics = validate_quadrilateral(
                rect,
                image.shape,
            )

            if not valid:
                continue

            # Pour commencer : favoriser les grands quadrilatères.
            # Ce score pourra ensuite incorporer le support des bords.
            score = metrics["area_ratio"]

            candidates.append((score, rect))

    if not candidates:
        return None

    candidates.sort(
        key=lambda item: item[0],
        reverse=True,
    )

    return candidates[0][1]

Le passage de :

python
cv2.RETR_EXTERNAL

à :

python
cv2.RETR_LIST

est également intéressant : un panneau peut être entouré par un autre grand contour correspondant au toit ou au bord de l'image.

5. Mieux encore : mesurer si les quatre côtés correspondent réellement à des arêtes

Le plus grand quadrilatère n'est pas forcément le panneau. On peut donc regarder combien de pixels Canny existent le long de ses quatre côtés.

Par exemple :

python
def edge_support_score(rect, edges, thickness=5):
    """
    Pourcentage du périmètre du quadrilatère qui est soutenu
    par des pixels de contour.
    """
    dilated = cv2.dilate(
        edges,
        np.ones((thickness, thickness), dtype=np.uint8),
        iterations=1,
    )

    mask = np.zeros_like(edges)

    pts = rect.astype(np.int32)

    for i in range(4):
        p1 = tuple(pts[i])
        p2 = tuple(pts[(i + 1) % 4])

        cv2.line(
            mask,
            p1,
            p2,
            255,
            1,
        )

    perimeter_pixels = mask > 0

    count = np.count_nonzero(perimeter_pixels)

    if count == 0:
        return 0.0

    supported = np.count_nonzero(
        (dilated > 0) & perimeter_pixels
    )

    return supported / count

Et votre score peut devenir par exemple :

python
support = edge_support_score(rect, edges)

score = (
    0.75 * support
    + 0.25 * min(metrics["area_ratio"] / 0.6, 1.0)
)

Cela permet de préférer :

un quadrilatère dont les quatre côtés suivent réellement le châssis du panneau

plutôt que :

simplement le plus grand quadrilatère de l'image.

C'est particulièrement intéressant sur des photos de toitures.

6. Contour et Hough devraient être mis en concurrence

Actuellement :

text
Contour valide ?
    oui → on arrête
    non → Hough

Mais vous pouvez avoir :

text
Contour : candidat acceptable mais médiocre
Hough   : candidat excellent

Le contour gagnera malgré tout.

Je transformerais la logique en :

text
Contour → candidat + score
Hough   → candidat + score

       ↓

prendre le candidat ayant
le meilleur score/confiance

Conceptuellement :

python
candidates = []

contour = detect_corners_contour(image)
if contour is not None:
    ...
    if valid:
        candidates.append({
            "rect": rect,
            "method": "contour",
            "score": score,
        })

hough = detect_corners_hough(image)
if hough is not None:
    ...
    if valid:
        candidates.append({
            "rect": rect,
            "method": "hough",
            "score": score,
        })

if not candidates:
    return None, ...

best = max(candidates, key=lambda x: x["score"])

À mon avis, c'est préférable au concept de fallback.

7. Vos flags *_tente sont actuellement inexacts

Vous faites :

python
corners = detect_corners_contour(image)

if corners is not None:
    diag["contour_tente"] = True

Cela signifie en réalité :

contour_tente = True seulement si la détection a trouvé quelque chose.

Alors que la méthode a bien été tentée.

Corrigez avec :

python
diag["contour_tente"] = True
corners = detect_corners_contour(image)

if corners is None:
    diag["contour_raison"] = "aucun_candidat"
else:
    ...

Même chose pour Hough :

python
diag["hough_tente"] = True
corners = detect_corners_hough(image)

if corners is None:
    diag["hough_raison"] = "aucun_candidat"
else:
    ...

8. Vous calculez beaucoup de diagnostics… puis vous ne les écrivez pas dans le CSV

C'est dommage, car votre commentaire indique justement :

« permettre une analyse quantitative globale ».

Votre CSV ne contient actuellement que :

python
"dossier"
"fichier"
"statut"
"methode"
"raison"

J'ajouterais au minimum :

python
def get_metric(diag, method, metric):
    metrics = diag.get(f"{method}_metrics")
    if not metrics:
        return None
    return metrics.get(metric)

Et :

python
diag = result.get("diag", {})

report_rows.append({
    "dossier": relative_path,
    "fichier": filename,
    "statut": result["status"],
    "methode": result["method"],
    "raison": result["reason"],

    "contour_raison": diag.get("contour_raison"),
    "contour_area_ratio":
        get_metric(diag, "contour", "area_ratio"),
    "contour_min_angle":
        get_metric(diag, "contour", "min_angle"),
    "contour_max_angle":
        get_metric(diag, "contour", "max_angle"),
    "contour_aspect_ratio":
        get_metric(diag, "contour", "aspect_ratio"),

    "hough_raison": diag.get("hough_raison"),
    "hough_area_ratio":
        get_metric(diag, "hough", "area_ratio"),
    "hough_min_angle":
        get_metric(diag, "hough", "min_angle"),
    "hough_max_angle":
        get_metric(diag, "hough", "max_angle"),
    "hough_aspect_ratio":
        get_metric(diag, "hough", "aspect_ratio"),
})

C'est ce CSV qui vous permettra ensuite de répondre à des questions comme :

text
80 % des échecs sont-ils dus à l'aire ?
aux intersections Hough ?
à un angle dégénéré ?
à la taille des côtés ?

9. Attention au ratio de votre image redressée

Ce commentaire est légèrement trompeur :

python
# ratio largeur/hauteur RÉEL détecté

Le ratio que vous calculez avec :

python
width = (...)
height = (...)
aspect_ratio = width / height

n'est pas le ratio réel physique du panneau.

C'est son ratio apparent dans la photographie après projection perspective.

Imaginez un rectangle vu presque de côté : un de ses côtés est énormément raccourci par la perspective.

Donc l'homographie peut parfaitement remettre ses quatre coins dans un rectangle, mais le choix de la largeur et de la hauteur de ce rectangle reste à déterminer.

Si vous connaissez les dimensions du panneau ou de l'ensemble de modules, la meilleure solution est :

python
KNOWN_PANEL_ASPECT_RATIO = 1.65

ou par exemple, si la grille est connue :

python
CELL_WIDTH = 156
CELL_HEIGHT = 156

NB_COLUMNS = 6
NB_ROWS = 10

KNOWN_PANEL_ASPECT_RATIO = (
    NB_COLUMNS * CELL_WIDTH
    / (NB_ROWS * CELL_HEIGHT)
)

Puis :

python
def compute_canonical_size(
    rect,
    long_side=CANONICAL_LONG_SIDE,
    known_aspect_ratio=None
):
    if known_aspect_ratio is not None:
        ratio = known_aspect_ratio
    else:
        tl, tr, br, bl = rect

        width = (
            np.linalg.norm(tr - tl)
            + np.linalg.norm(br - bl)
        ) / 2

        height = (
            np.linalg.norm(bl - tl)
            + np.linalg.norm(br - tr)
        ) / 2

        ratio = width / max(height, 1e-6)

    if ratio >= 1:
        target_w = long_side
        target_h = round(long_side / ratio)
    else:
        target_h = long_side
        target_w = round(long_side * ratio)

    return (
        max(int(target_w), CANONICAL_MIN_SIDE),
        max(int(target_h), CANONICAL_MIN_SIDE),
    )

Si votre objectif suivant est la segmentation des cellules photovoltaïques, un ratio connu constitue une grosse amélioration.

10. Pour les grandes images, détectez sur une miniature et redressez l'original

Si vos photos font par exemple 4000×3000 ou 6000×4000, Canny + contours + Hough travaillent inutilement sur des millions de pixels.

Ajoutez :

python
DETECTION_MAX_SIDE = 1600

et :

python
def resize_for_detection(image, max_side=DETECTION_MAX_SIDE):
    h, w = image.shape[:2]

    scale = min(
        1.0,
        max_side / max(h, w)
    )

    if scale == 1.0:
        return image, 1.0

    resized = cv2.resize(
        image,
        None,
        fx=scale,
        fy=scale,
        interpolation=cv2.INTER_AREA,
    )

    return resized, scale

Puis :

python
work_image, scale = resize_for_detection(image)

corners = detect_corners_contour(work_image)

if corners is not None:
    corners = corners / scale

La détection est donc rapide sur 1600 px, mais :

python
cv2.warpPerspective(...)

est toujours appliqué sur l'original.

C'est généralement le meilleur compromis.

11. Hough : pondérez l'histogramme par la longueur des lignes

Votre histogramme fait actuellement :

python
hist, bin_edges = np.histogram(
    angles,
    bins=18,
    range=(0, 180)
)

Une petite ligne parasite de 20 pixels compte autant qu'une bordure de panneau de 900 pixels.

Calculez :

python
lengths = np.array([
    math.hypot(
        line[2] - line[0],
        line[3] - line[1],
    )
    for line in lines
])

Puis :

python
hist, bin_edges = np.histogram(
    angles,
    bins=36,
    range=(0, 180),
    weights=lengths,
)

J'utiliserais également 36 bins plutôt que 18 :

text
18 bins → résolution 10°
36 bins → résolution 5°

Pour la géométrie du châssis, 5° me paraît plus approprié.

12. Ajoutez un try/except par image

Une seule image atypique ne devrait jamais arrêter 5 000 traitements.

python
for filename in sorted(image_files):
    image_path = os.path.join(current_root, filename)

    try:
        result = process_single_image(image_path)

    except Exception as exc:
        result = {
            "status": "erreur_traitement",
            "method": None,
            "reason": f"{type(exc).__name__}: {exc}",
            "warped": None,
            "debug": None,
            "diag": {},
        }

Il faut alors prévoir :

python
counts = {
    "succes": 0,
    "echec": 0,
    "erreur_lecture": 0,
    "erreur_traitement": 0,
}

13. Vérifiez aussi cv2.imwrite()

OpenCV ne lève pas nécessairement une exception :

python
cv2.imwrite(...)

renvoie un booléen.

Donc :

python
output_path = os.path.join(
    success_sub_folder,
    filename,
)

saved = cv2.imwrite(
    output_path,
    result["warped"],
)

if not saved:
    raise IOError(
        f"Impossible d'écrire {output_path}"
    )

Ça évite de comptabiliser un succès alors qu'aucun fichier n'a été produit.

Architecture que je viserais

Je ferais évoluer votre pipeline vers ceci :

text
                   IMAGE
                     │
            réduction pour détection
                     │
         ┌───────────┴────────────┐
         │                        │
    CONTOURS                    HOUGH
         │                        │
 plusieurs candidats      plusieurs candidats
         │                        │
         └───────────┬────────────┘
                     │
              validation géométrique
                     │
              score de confiance
                     │
             meilleur candidat
                     │
          confiance suffisante ?
             │               │
            oui             non
             │               │
         homographie      à vérifier
             │
       image originale
             │
       image redressée

Et non plus simplement :

text
contour → oui ? stop
             ↓ non
           Hough

Les 5 changements que je ferais en premier

Dans votre cas, je commencerais par (1) supprimer le test « proche de 90° » au profit d'un test de dégénérescence 12°–168°, (2) sélectionner le meilleur contour au lieu du premier quadrilatère, (3) mettre contour et Hough en concurrence, (4) exporter toutes les métriques dans le CSV, et (5) si la géométrie des panneaux est connue, imposer le vrai ratio de sortie plutôt que le ratio apparent de la photographie.

Ces cinq changements devraient améliorer à la fois le taux de détection, la qualité des redressements et surtout votre capacité à comprendre automatiquement pourquoi les images restantes échouent.