Comment supprimer ou rendre opaques les pixels semi-transparents dans des images de personnage rendues

Dans une image RGBA 8 bits, chaque pixel possède des composantes rouge, vert, bleu et alpha. Une valeur alpha de 0 signifie une transparence totale ; 255, une opacité totale. Les valeurs de 1 à 254 correspondent à une transparence partielle. Pillow décrit le format RGBA comme quatre canaux de 8 bits avec un masque de transparence. Pillow : Concepts

Une image peut donc sembler presque opaque tout en contenant de nombreux pixels partiellement transparents. Avant toute modification, examinez une copie à sa taille d’affichage prévue et en agrandissant les pixels. Placez temporairement derrière l’image des fonds clairs et foncés. Repérez les pixels périphériques peu visibles, les détails fins manquants et les franges de couleur.

Décidez si la transparence partielle doit être conservée dans l’illustration finale. Un accessoire translucide ou une ombre douce changera considérablement si on le transforme en masque opaque ou transparent. Si seul le contour du personnage doit être corrigé, isolez cette zone ou ce calque avant d’appliquer une opération globale.

Conservez les images rendues originales. Le seuillage réduit de nombreuses valeurs alpha à deux valeurs extrêmes ; le fichier traité ne permet donc pas de retrouver le degré de transparence initial de ces pixels.

Utilisez une règle explicite unique pour toute la séquence d’images. Dans le tableau ci-dessous, C est la valeur alpha minimale à conserver, et chaque pixel conservé devient totalement opaque. Ces règles s’appliquent aux entrées 8 bits.

Résultat souhaité	Règle	Principal compromis visuel
Supprimer tous les pixels semi-transparents	Ne conserver que l’alpha 255	Les détails fins composés entièrement de pixels partiels disparaissent
Rendre opaque chaque pixel visible	Conserver l’alpha de 1 à 255	Les pixels périphériques peu visibles deviennent partie intégrante de la silhouette opaque
Choisir un seuil intermédiaire pour le contour	Conserver alpha ≥ C ; supprimer alpha < C	Le seuil détermine quels pixels du bord sont conservés

Par exemple, considérons les valeurs alpha illustratives 0, 1, 64, 127, 128, 254, 255. Avec C = 128, le résultat devient 0, 0, 0, 0, 255, 255, 255. Avec C = 255, seul le dernier pixel est conservé. Avec C = 1, chaque pixel initialement visible devient opaque.

Commencez par comparer avec C = 128, puis examinez le personnage lui-même. C’est un point médian pratique, pas un réglage optimal établi. Augmentez-le si des pixels peu visibles indésirables subsistent ; diminuez-le si des détails utiles disparaissent. Pour chaque comparaison, repartez de l’image originale.

Si l’augmentation du seuil supprime une frange mais brise aussi un détail essentiel, un seuil global unique ne peut pas répondre aux deux objectifs. Corrigez ce détail localement ou séparez-le dans son propre masque avant de traiter le reste du contour.

GIMP 3 propose Calque → Transparence → Seuil alpha…. Cette commande s’applique à un seul calque, nécessite un canal alpha et n’a aucun effet lorsque Verrouiller le canal alpha est activé. Le seuil va de 0 à 1 : les valeurs supérieures au seuil deviennent opaques, tandis que celles qui lui sont égales ou inférieures deviennent transparentes. GIMP : Seuil alpha

1. Ouvrez une copie de l’image et sélectionnez le calque du personnage.
2. Vérifiez qu’il possède un canal alpha et désactivez Verrouiller le canal alpha.
3. Ouvrez Calque → Transparence → Seuil alpha….
4. Prévisualisez un seuil de 0,5 pour une coupe médiane, ou de 0 pour rendre opaque chaque pixel dont l’alpha est non nul.
5. Vérifiez les petits détails et le contour extérieur avant d’appliquer l’opération.
6. Exportez le résultat dans un fichier PNG distinct.

Pour une entrée 8 bits, un seuil de 254/255, soit environ 0,996078, ne conserve que les pixels dont l’alpha initial était de 255. Évitez de régler le seuil sur 1 à cette fin : selon la comparaison stricte documentée, même un alpha de 1 atteint le seuil et devient transparent. GIMP : Seuil alpha

Veillez à ce que les fonds d’inspection temporaires ne figurent pas dans le fichier du personnage exporté. Rouvrez le PNG ensuite afin d’évaluer aussi bien le résultat exporté que le document modifiable.

Pour traiter plusieurs images, utilisez un mappage alpha fixe plutôt que de régler chaque image séparément. Le programme Python complet ci-dessous traite directement les fichiers PNG d’un dossier, conserve leurs noms et dimensions et écrit les résultats dans un nouveau dossier.

Installez Pillow avec python -m pip install Pillow, puis enregistrez le programme sous alpha_clean.py. Fournissez des images PNG RGBA 8 bits statiques, distinctes les unes des autres. Avant d’utiliser ce flux de travail, exportez délibérément les images indexées, les rendus de précision supérieure ou les autres types d’images dans ce format.

Le programme extrait l’alpha avec getchannel, le mappe au moyen d’une table de correspondance avec point et ne remplace que le canal alpha avec putalpha. Ces opérations sont documentées dans la référence du module Image de Pillow.

import argparse
from pathlib import Path
from PIL import Image


def threshold_alpha(image, cutoff):
    result = image.copy()
    table = [255 if value >= cutoff else 0 for value in range(256)]
    result.putalpha(image.getchannel("A").point(table))
    return result


def partial_count(image):
    return sum(image.getchannel("A").histogram()[1:255])


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("source", type=Path)
    parser.add_argument("destination", type=Path)
    parser.add_argument("--cutoff", type=int, default=128)
    parser.add_argument("--demo", action="store_true")
    args = parser.parse_args()

    if not 1 <= args.cutoff <= 255:
        parser.error("--cutoff must be between 1 and 255")

    if args.demo:
        values = [0, 1, 64, 127, 128, 254, 255]
        sample = Image.new("RGBA", (len(values), 1))
        sample.putdata([(80, 160, 220, a) for a in values])
        result = threshold_alpha(sample, args.cutoff)
        print([result.getpixel((x, 0))[3] for x in range(len(values))])
        return

    if not args.source.is_dir():
        parser.error("Source must be an existing folder")
    if args.destination.exists():
        parser.error("Destination must be a new folder")

    files = sorted(
        p for p in args.source.iterdir()
        if p.is_file() and p.suffix.lower() == ".png"
    )
    if not files:
        parser.error("No PNG frames found directly inside source")

    args.destination.mkdir(parents=True)
    for path in files:
        with Image.open(path) as image:
            if image.format != "PNG" or image.mode != "RGBA":
                raise ValueError(f"{path.name}: expected RGBA PNG")
            if getattr(image, "n_frames", 1) != 1:
                raise ValueError(f"{path.name}: expected a single frame")
            before = partial_count(image)
            result = threshold_alpha(image, args.cutoff)
            target = args.destination / path.name
            result.save(target, format="PNG")

        with Image.open(target) as saved:
            after = partial_count(saved)
            if saved.size != result.size or after != 0:
                raise RuntimeError(f"{target.name}: verification failed")
        print(f"{path.name}: partial pixels {before} -> {after}")


if __name__ == "__main__":
    main()

Commencez par exécuter l’exemple autonome. En mode démo, les deux arguments de dossier sont acceptés, mais aucun des deux dossiers n’est lu ni créé :

python alpha_clean.py unused_input unused_output --demo --cutoff 128

Le programme affiche [0, 0, 0, 0, 255, 255, 255]. Les mappages sous-jacents pour les seuils 1, 128 et 255, les valeurs RGB inchangées et le comportement d’enregistrement et de réouverture des PNG ont été vérifiés avec un échantillon en mémoire à l’aide de Pillow 13.0.0.

Pour traiter de vraies images, placez vos fichiers PNG dans un dossier nommé frames, puis exécutez :

python alpha_clean.py frames frames_clean --cutoff 128

Utilisez --cutoff 255 pour supprimer chaque pixel semi-transparent, ou --cutoff 1 pour rendre opaque chaque pixel visible. Choisissez un nouveau dossier de destination pour chaque comparaison.

Ce programme s’arrête si l’entrée n’est pas prise en charge ou si une vérification échoue. Les fichiers traités avant une erreur restent dans le dossier de destination ; celui-ci correspond alors à une exécution incomplète. Corrigez l’entrée et relancez le traitement dans un autre nouveau dossier. Le programme ne parcourt pas les sous-dossiers, ne conserve pas le minutage des animations et n’est pas conçu pour préserver les métadonnées de façon générale.

Le nettoyage de l’alpha modifie la couverture. La couleur du contour doit être examinée séparément. Microsoft distingue l’alpha droit, où RGB et alpha sont indépendants, de l’alpha prémultiplié, où RGB inclut déjà la multiplication par alpha. Microsoft Learn : alpha prémultiplié

À titre d’exemple, un rouge droit (200, 0, 0) avec un alpha de 0,25 correspond au RGB prémultiplié (50, 0, 0). Si ces valeurs de couleur prémultipliées sont traitées à tort comme des valeurs RGB droites et que l’alpha est simplement porté à 1, le pixel obtenu est rouge foncé. Cela découle directement de la relation de conversion documentée. Microsoft Learn : alpha prémultiplié

Le flux de travail Python suppose que les images PNG RGBA d’entrée utilisent un alpha droit correctement encodé. Il ne peut ni détecter des couleurs encodées incorrectement ni reconstituer la couleur prévue du contour. Si rendre les pixels opaques révèle une frange, vérifiez d’abord comment l’alpha a été interprété lors du rendu ou de l’exportation original. Si la couleur elle-même est altérée par un ancien assemblage sur un arrière-plan, repartez d’un rendu transparent propre ou repeignez le bord affecté.

Comparez l’image nettoyée sur des fonds clairs et foncés. Un nombre nul de pixels partiels confirme que l’alpha est binaire ; cela ne garantit pas que les couleurs du contour conviennent au personnage.

Effectuez les changements de taille avant le nettoyage final de l’alpha. Le rééchantillonnage par interpolation peut créer des valeurs intermédiaires entre les pixels transparents et opaques. Pillow indique que le rééchantillonnage bilinéaire calcule les valeurs par interpolation, tandis que le rééchantillonnage au plus proche voisin sélectionne un pixel d’entrée existant. Par conséquent, le redimensionnement au plus proche voisin d’un canal alpha binaire préserve ses deux valeurs extrêmes. Pillow : Concepts — Filtres

Utilisez le plus proche voisin lorsque le rendu souhaité repose sur une grille de pixels distincts. Pour un autre style visuel, redimensionnez d’abord avec le filtre souhaité, puis appliquez un seuil aux images obtenues et réexaminez leurs contours. Toute mise à l’échelle ou opération de composition ultérieure doit entraîner une nouvelle vérification du résultat final.

Examinez la séquence complète avec le même seuil. Un détail fin peut passer sous le seuil d’une image à l’autre et sembler clignoter, même si chaque image paraît acceptable prise isolément. Dans ce cas, examinez les images originales autour du changement et corrigez le détail de façon cohérente dans ces images.

Avant d’utiliser la séquence, vérifiez les points suivants :

• Toutes les images attendues sont présentes, avec leur nom de fichier et leurs dimensions de canevas d’origine.
• Chaque image enregistrée contient zéro pixel dont l’alpha est compris entre 1 et 254.
• Les petits détails restent lisibles à la taille d’affichage prévue.
• Les aperçus sur fonds clairs et foncés ne révèlent aucune frange indésirable.
• La lecture conserve une silhouette cohérente tout au long du mouvement.

Choisissez la règle alpha qui préserve la forme voulue du personnage, appliquez-la de manière cohérente et examinez la séquence exportée. Conservez les rendus originaux avec les images nettoyées afin de pouvoir effectuer les ajustements ultérieurs à partir des informations complètes sur la transparence.

• 7.40. Seuil alpha — Manuel utilisateur de GIMP
• Module Image — Documentation de Pillow
• Concepts — Documentation de Pillow
• Alpha prémultiplié — Microsoft Learn