Antialiasing dell'immagine

Le immagini sono rappresentate da pixel discreti, sullo schermo o in un file immagine. Quando i dati che compongono l'immagine hanno una risoluzione diversa dalla sua rappresentazione sullo schermo vedremo effetti di aliasing. Quanto sono evidenti questi dipende da quanto down-sampling avviene nel cambio di risoluzione (se presente).

Quando si esegue il sottocampionamento dei dati, l'aliasing viene ridotto prima smussando e poi sottocampionando i dati smussati. In Matplotlib, possiamo eseguire lo smoothing prima di mappare i dati sui colori, oppure possiamo eseguire lo smoothing sui dati RGB(A) nell'immagine finale. La differenza tra questi è mostrata di seguito e controllata con l' argomento della parola chiave interpolation_stage .

L'interpolazione dell'immagine predefinita in Matplotlib è "antialiased" e viene applicata ai dati. Questo utilizza un'interpolazione hanning sui dati forniti dall'utente per ridurre l'aliasing nella maggior parte delle situazioni. Solo quando è presente un sovracampionamento di un fattore 1, 2 o >=3 viene utilizzata l'interpolazione del vicino più vicino.

È possibile specificare altri filtri anti-alias Axes.imshowutilizzando l' argomento della parola chiave interpolazione .

import numpy as np
import matplotlib.pyplot as plt

Per prima cosa generiamo un'immagine di 450x450 pixel con contenuto di frequenza variabile:

N = 450
x = np.arange(N) / N - 0.5
y = np.arange(N) / N - 0.5
aa = np.ones((N, N))
aa[::2, :] = -1

X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
f0 = 5
k = 100
a = np.sin(np.pi * 2 * (f0 * R + k * R**2 / 2))
# make the left hand side of this
a[:int(N / 2), :][R[:int(N / 2), :] < 0.4] = -1
a[:int(N / 2), :][R[:int(N / 2), :] < 0.3] = 1
aa[:, int(N / 3):] = a[:, int(N / 3):]
a = aa

Le seguenti immagini sono sottocampionate da 450 pixel di dati a 125 pixel o 250 pixel (a seconda del display). I modelli Moire nell'interpolazione "più vicina" sono causati dal sottocampionamento dei dati ad alta frequenza. Anche l'immagine "antialiased" ha ancora alcuni modelli Moiré, ma sono notevolmente ridotti.

Esistono differenze sostanziali tra l'interpolazione 'dati' e l'interpolazione 'rgba'. Le bande alternate di rosso e blu sul terzo sinistro dell'immagine sono sottocampionate. Interpolando nello spazio "dati" (impostazione predefinita) il filtro antialiasing rende le strisce vicine al bianco, perché la media di -1 e +1 è zero e zero è bianco in questa mappa di colori.

Al contrario, quando l'anti-aliasing si verifica nello spazio 'rgba', il rosso e il blu vengono combinati visivamente per creare il viola. Questo comportamento è più simile a un tipico pacchetto di elaborazione delle immagini, ma si noti che il viola non è nella mappa dei colori originale, quindi non è più possibile invertire i singoli pixel al loro valore di dati.

fig, axs = plt.subplots(2, 2, figsize=(5, 6), constrained_layout=True)
axs[0, 0].imshow(a, interpolation='nearest', cmap='RdBu_r')
axs[0, 0].set_xlim(100, 200)
axs[0, 0].set_ylim(275, 175)
axs[0, 0].set_title('Zoom')

for ax, interp, space in zip(axs.flat[1:],
                             ['nearest', 'antialiased', 'antialiased'],
                             ['data', 'data', 'rgba']):
    ax.imshow(a, interpolation=interp, interpolation_stage=space,
              cmap='RdBu_r')
    ax.set_title(f"interpolation='{interp}'\nspace='{space}'")
plt.show()

Anche l'up-sampling di un'immagine con l'interpolazione "più vicina" porterà a modelli Moire quando il fattore di upsampling non è intero. L'immagine seguente esegue l'upsampling di 500 pixel di dati a 530 pixel di rendering. Puoi notare una griglia di 30 artefatti simili a linee che derivano dai 524 - 500 = 24 pixel extra che dovevano essere inventati. Poiché l'interpolazione è "la più vicina", sono uguali a una linea vicina di pixel e quindi allungano l'immagine localmente in modo che appaia distorta.

fig, ax = plt.subplots(figsize=(6.8, 6.8))
ax.imshow(a, interpolation='nearest', cmap='gray')
ax.set_title("upsampled by factor a 1.048, interpolation='nearest'")
plt.show()

Migliori algoritmi di antialiasing possono ridurre questo effetto:

fig, ax = plt.subplots(figsize=(6.8, 6.8))
ax.imshow(a, interpolation='antialiased', cmap='gray')
ax.set_title("upsampled by factor a 1.048, interpolation='antialiased'")
plt.show()

A parte l'antialiasing 'hanning' predefinito, imshowsupporta un numero di diversi algoritmi di interpolazione, che possono funzionare meglio o peggio a seconda del modello.

fig, axs = plt.subplots(1, 2, figsize=(7, 4), constrained_layout=True)
for ax, interp in zip(axs, ['hanning', 'lanczos']):
    ax.imshow(a, interpolation=interp, cmap='gray')
    ax.set_title(f"interpolation='{interp}'")
plt.show()

Riferimenti

L'uso delle seguenti funzioni, metodi, classi e moduli è mostrato in questo esempio:

• matplotlib.axes.Axes.imshow