Come rimuovere o rendere opachi i pixel semitrasparenti nei fotogrammi renderizzati di un personaggio

In un’immagine RGBA a 8 bit, ogni pixel ha componenti rosso, verde, blu e alfa. Alfa 0 significa completamente trasparente; alfa 255 significa completamente opaco. I valori da 1 a 254 indicano una trasparenza parziale. Pillow documenta RGBA come quattro canali a 8 bit con una maschera di trasparenza. Pillow: concetti

Un fotogramma può quindi sembrare quasi opaco e contenere comunque molti pixel parzialmente trasparenti. Prima di modificarlo, controllane una copia alle dimensioni di visualizzazione previste e con una vista ingrandita dei pixel. Inserisci temporaneamente sotto l’immagine uno sfondo chiaro e uno scuro. Cerca pixel esterni appena visibili, dettagli sottili mancanti e aloni di colore.

Decidi se la trasparenza parziale deve rimanere nell’illustrazione finale. Un accessorio traslucido o un’ombra sfumata cambierà molto se viene forzato in una maschera opaca o trasparente. Se devi correggere soltanto il contorno del personaggio, isola quella regione o quel livello prima di applicare un’operazione globale.

Conserva i fotogrammi renderizzati originali. La sogliatura riduce molti valori alfa a due soli estremi, quindi il file elaborato non può indicare quanto fossero trasparenti in origine quei pixel.

Applica una regola esplicita e uniforme all’intera sequenza di fotogrammi. Nella tabella seguente, C è il valore alfa minimo da mantenere e ogni pixel mantenuto diventa completamente opaco. Queste regole si riferiscono a immagini a 8 bit.

Risultato desiderato	Regola	Principale compromesso visivo
Rimuovere tutti i pixel semitrasparenti	Mantenere solo alfa 255	I dettagli sottili composti interamente da pixel parziali scompaiono
Rendere opaco ogni pixel visibile	Mantenere alfa 1–255	I pixel esterni appena visibili entrano a far parte della sagoma opaca
Scegliere un contorno intermedio	Mantenere alfa ≥ C; eliminare alfa < C	La soglia determina quali pixel del bordo sopravvivono

Per esempio, considera i valori alfa illustrativi 0, 1, 64, 127, 128, 254, 255. Con C = 128, il risultato diventa 0, 0, 0, 0, 255, 255, 255. Con C = 255, sopravvive soltanto l’ultimo pixel. Con C = 1, ogni pixel originariamente visibile diventa opaco.

Inizia da C = 128 come termine di confronto, poi esamina il personaggio effettivo. È un valore intermedio comodo, non un’impostazione ottimale dimostrata. Aumentalo se rimangono pixel deboli indesiderati; diminuiscilo se scompaiono dettagli utili. Per ogni confronto, riparti dal fotogramma originale.

Se aumentando la soglia elimini un alone ma interrompi anche un dettaglio essenziale, una sola soglia globale non può soddisfare entrambi gli obiettivi. Correggi localmente quel dettaglio o separalo in una maschera propria prima di elaborare il resto del contorno.

GIMP 3 include Livello → Trasparenza → Soglia alfa…. Agisce su un singolo livello, richiede un canale alfa e non ha effetto quando Blocca il canale alfa è attivo. La soglia varia da 0 a 1: i valori superiori alla soglia diventano opachi, mentre quelli uguali o inferiori diventano trasparenti. GIMP: Soglia alfa

1. Apri una copia del fotogramma e seleziona il livello del personaggio.
2. Verifica che abbia un canale alfa e disattiva Blocca il canale alfa.
3. Apri Livello → Trasparenza → Soglia alfa….
4. Visualizza l’anteprima con una soglia di 0.5 per un taglio intermedio, oppure 0 per rendere opaco ogni pixel con alfa diverso da zero.
5. Prima di applicare l’operazione, controlla i dettagli piccoli e il contorno esterno.
6. Esporta il risultato come PNG separato.

Con un input a 8 bit, una soglia di 254/255, circa 0.996078, mantiene soltanto i pixel che in origine avevano alfa 255. Evita di impostare la soglia a 1 per questo scopo: secondo il confronto rigoroso descritto nella documentazione, anche alfa 1 è pari alla soglia e diventa trasparente. GIMP: Soglia alfa

Non includere nel file esportato del personaggio gli sfondi temporanei usati per l’ispezione. Riapri il PNG dopo l’esportazione per valutare sia il risultato esportato sia il documento modificabile.

Per più fotogrammi, usa una mappatura alfa fissa invece di regolare ogni immagine individualmente. Il programma Python completo seguente elabora direttamente i file PNG contenuti in una cartella, ne mantiene i nomi e le dimensioni e scrive i risultati in una nuova cartella.

Installa Pillow con python -m pip install Pillow, poi salva il programma come alpha_clean.py. Usa fotogrammi PNG RGBA a 8 bit, statici e separati. Prima di usare questo flusso di lavoro, converti deliberatamente in quel formato le immagini indicizzate, i rendering a precisione superiore o altri tipi di immagine.

Il programma estrae l’alfa con getchannel, lo mappa tramite una tabella di ricerca con point e sostituisce soltanto l’alfa con putalpha. Queste operazioni sono documentate nella guida di riferimento del modulo Image di 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()

Esegui prima l’esempio autonomo. In modalità demo, i due argomenti relativi alle cartelle vengono accettati, ma nessuna delle due cartelle viene letta o creata:

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

Il programma stampa [0, 0, 0, 0, 255, 255, 255]. Le mappature sottostanti per le soglie 1, 128 e 255, i valori RGB invariati e il comportamento di salvataggio e riapertura del PNG sono stati verificati con un esempio in memoria usando Pillow 13.0.0.

Per elaborare i fotogrammi effettivi, inserisci i PNG in una cartella chiamata frames, poi esegui:

python alpha_clean.py frames frames_clean --cutoff 128

Usa --cutoff 255 per eliminare ogni pixel semitrasparente oppure --cutoff 1 per rendere opaco ogni pixel visibile. Scegli una nuova cartella di destinazione per ogni confronto.

Il programma si interrompe in caso di input non supportato o verifica non riuscita. I file completati prima dell’errore rimangono nella cartella di destinazione, che rappresenta un’elaborazione incompleta. Correggi l’input e ripeti l’esecuzione in un’altra nuova cartella. Il programma non elabora le sottocartelle in modo ricorsivo, non conserva i tempi dell’animazione e non è uno strumento generico per preservare i metadati.

La pulizia dell’alfa modifica la copertura. Il colore del bordo va esaminato a parte. Microsoft distingue l’alfa diretta, in cui RGB e alfa sono indipendenti, dall’alfa premoltiplicata, in cui RGB include già la moltiplicazione per alfa. Microsoft Learn: alfa premoltiplicata

Come esempio di calcolo, il rosso diretto (200, 0, 0) con alfa 0.25 corrisponde all’RGB premoltiplicato (50, 0, 0). Se quei valori di colore premoltiplicati vengono trattati per errore come RGB diretto e l’alfa viene semplicemente portata a 1, il risultato è un pixel rosso scuro. È una conseguenza diretta della relazione di conversione documentata. Microsoft Learn: alfa premoltiplicata

Il flusso di lavoro Python presuppone un input PNG RGBA ad alfa diretto codificato correttamente. Non può diagnosticare colori codificati in modo errato né ricostruire il colore previsto del contorno. Se rendere opachi i pixel rivela un alone, controlla prima come è stata interpretata l’alfa nel rendering o nell’esportazione originale. Se il colore stesso è contaminato da una precedente composizione con uno sfondo, riparti da un rendering trasparente pulito o ridipingi il bordo interessato.

Confronta il fotogramma ripulito su sfondi chiari e scuri. Un conteggio pari a zero dei pixel parziali dimostra che l’alfa è binario; non dimostra che i colori del bordo siano adatti al personaggio.

Ridimensiona prima di eseguire la pulizia finale dell’alfa. Il ricampionamento con interpolazione può introdurre valori intermedi tra pixel trasparenti e opachi. Pillow descrive il ricampionamento bilineare come un calcolo dei valori tramite interpolazione, mentre quello nearest-neighbor seleziona un pixel esistente dell’immagine di input. Di conseguenza, il ridimensionamento nearest-neighbor di un canale alfa binario ne conserva i due valori estremi. Pillow: concetti—filtri

Usa il nearest-neighbor quando lo stile desiderato prevede una griglia di pixel discreti. Per un altro stile visivo, ridimensiona prima con il filtro desiderato, poi applica la soglia ai fotogrammi risultanti e ricontrollane i contorni. Un’ulteriore operazione di ridimensionamento o composizione richiede un nuovo controllo dell’output finale.

Esamina l’intera sequenza usando la stessa soglia. Un dettaglio sottile può superare la soglia tra due fotogrammi vicini e sembrare intermittente, anche se ciascun fotogramma, considerato singolarmente, sembra accettabile. In tal caso, controlla i fotogrammi originali intorno al cambiamento e correggi il dettaglio in modo uniforme in quei fotogrammi.

Prima di usare la sequenza, verifica queste condizioni concrete:

• Sono presenti tutti i fotogrammi previsti, con i nomi file e le dimensioni della tela originali.
• Ogni fotogramma salvato ha zero pixel con alfa da 1 a 254.
• I dettagli piccoli restano leggibili alle dimensioni di visualizzazione previste.
• Le anteprime su sfondo chiaro e scuro non rivelano aloni indesiderati.
• Durante il movimento, la riproduzione mantiene una sagoma coerente.

Scegli la regola alfa che preserva la forma prevista del personaggio, applicala in modo uniforme e controlla la sequenza esportata. Conserva i rendering originali insieme ai fotogrammi ripuliti, così potrai apportare modifiche successive partendo da tutte le informazioni sulla trasparenza.

• 7.40. Soglia alfa — Manuale utente di GIMP
• Modulo Image — documentazione di Pillow
• Concetti — documentazione di Pillow
• Alfa premoltiplicata — Microsoft Learn