Questo capitolo approfondisce l’elaborazione delle immagini nel dominio spaziale, partendo dalla manipolazione diretta dei pixel e degli istogrammi per l’enfatizzazione del contrasto, fino all’applicazione di filtri locali tramite convoluzione per la smussatura, la riduzione del rumore e il rilevamento dei bordi. L’obiettivo è sviluppare l’intuizione matematica e computazionale alla base di gran parte degli algoritmi moderni della Visione Artificiale.
Al termine di questo capitolo, sarai in grado di:
mm.addm, mm.subm) e logiche bit a bit (mm.band, mm.bor, mm.bnot) per la combinazione e la selezione di regioni di interesse (ROI), e applicare l’alpha blending (mm.blend) per la fusione ponderata di immagini;mm.equalize); nel percorso Python, anche l’equalizzazione adattiva (CLAHE) e la specifica dell’istogramma per il trasferimento del profilo tonale tra immagini;mm.pad) e la differenza tra correlazione incrociata (mm.conv) e convoluzione — inclusa la ragione per cui kernel asimmetrici come quello di Sobel producono risultati diversi nelle due operazioni;mm.blur, oppure mm.conv con kernel uniforme) e il filtro Gaussiano (mm.gaussian) per la riduzione del rumore, comprendendo il vantaggio della ponderazione radiale e della separabilità Gaussiana;mm.laplacian) per l’accentuazione isotropica dei bordi, l’operatore di Sobel (mm.sobel) per la magnitudine del gradiente — e, nel percorso Python, la decomposizione direzionale \(G_x\), \(G_y\) e l’angolo —, e l’Unsharp Masking (mm.usm) per l’amplificazione delle alte frequenze controllata dal parametro \(k\);mm.median) per la rimozione del rumore sale e pepe, comprendendo perché la sua natura non lineare e la robustezza agli outlier lo rendano superiore ai filtri lineari in questo scenario;morph (mm.conv, mm.histImg, mm.equalize, mm.drawImgKernel) per l’analisi e la visualizzazione didattica di ogni fase.Il livello più elementare di elaborazione delle immagini agisce direttamente sui valori dei pixel, senza considerare il vicinato. Queste operazioni — chiamate trasformazioni puntuali (point operations) — sono le più veloci dal punto di vista computazionale e costituiscono la base per tecniche più complesse.
Formalmente, una trasformazione puntuale può essere descritta come:
\[ g(x,y) = T[f(x,y)] \tag{3.1}\]
dove \(f(x,y)\) è l’immagine di ingresso, \(g(x,y)\) è l’uscita e \(T\) è una funzione applicata a ciascun pixel individualmente.
Il blocco seguente carica la libreria morph dal repository (il modulo morph.py e, nel percorso C++, anche la morph.hpp utilizzata nel #include delle celle compilate).
import os, urllib.request
url = "https://raw.githubusercontent.com/fzampirolli/pdi-vc/master/morph/config.py"
if not os.path.exists("config.py"):
urllib.request.urlretrieve(url, "config.py")
import config
config.setup()
from morph import mm
import numpy as np
import cv2✅ Ambiente pronto. Morph: 1.1.9 | OpenCV: 5.0.0Come oggetto di studio lungo questo capitolo, utilizzeremo le immagini di vita selvatica presentate nelle Figura 3.1 e Figura 3.3. A partire da esse, esploreremo operazioni spaziali sull’intensità, istogrammi e filtraggio, analizzando i loro effetti sull’amplificazione, sulla levigatura, sulla riduzione del rumore e sulla rilevazione dei bordi, in modo da comprendere i fondamenti matematici e computazionali dell’elaborazione digitale delle immagini (PDI).
import os
base = "https://upload.wikimedia.org/wikipedia/commons"
arquivo = "Carlos_Guilherme_Rodrigues_%2876515283%29.jpeg"
url = f"{base}/9/9b/{arquivo}"
caminho = "imagens/mandrill-exif.jpg"
if not os.path.exists(caminho):
os.makedirs("imagens", exist_ok=True)
mm.write(mm.read(url), caminho)
img_color = mm.read(caminho)
img_gray = mm.gray(img_color)
mm.show(img_color)
Le operazioni aritmetiche tra immagini sono ampiamente utilizzate nell’elaborazione digitale delle immagini (PDI) per combinare, confrontare o migliorare le informazioni. La sottrazione di immagini è particolarmente efficace per rilevare differenze tra due fotogrammi — ad esempio, nella rimozione dello sfondo statico nelle telecamere di sorveglianza:
\[ g(x,y) = f_1(x,y) - f_2(x,y) \tag{3.2}\]
L’addizione saturata limita il risultato all’intervallo \([0, 255]\): i valori superiori a 255 vengono fissati a 255, evitando l’overflow silenzioso del tipo uint8 (es.: \(200 + 100 = 44\) anziché 300). La sottrazione saturata applica lo stesso principio sul lato inferiore: i valori negativi vengono fissati a 0.
Le operazioni aritmetiche su uint8 subiscono un overflow silenzioso: \(200 + 100 = 44\) (non 300). mm.addm e mm.subm eseguono la saturazione automatica, fissando il risultato in \([0, 255]\). Il blending utilizza pesi frazionari: mm.blend opera internamente in virgola mobile e solo successivamente arrotonda e satura a uint8.
La Figura 3.2 dimostra l’addizione di una costante (schiarimento) e la sottrazione di una costante (scurimento con saturazione a 0).
fundo = 60
img_add = mm.addm(img_gray, fundo)
img_sub = mm.subm(img_gray, fundo)
mm.show(
[img_gray, img_add, img_sub],
titles=["Originale", "addm (+60)", "subm (−60)"],
cols=3
)
La miscelazione ponderata (alpha blending) combina due immagini utilizzando pesi complementari \(\alpha\) e \((1-\alpha)\):
\[ g(x,y) = \alpha\,f_1(x,y) + (1-\alpha)\,f_2(x,y), \quad \alpha \in [0,1] \tag{3.3}\]
Quando \(\alpha = 1\), si ottiene soltanto l’immagine \(f_1\); quando \(\alpha = 0\), soltanto \(f_2\). I valori intermedi producono una transizione fluida tra le due, essendo ampiamente utilizzati nella composizione di immagini, sovrapposizione di livelli, filigrane ed effetti di fusione visiva.
Affinché la combinazione produca un risultato coerente, è necessario allineare preventivamente le regioni di interesse. Nella Figura 3.4, si ritaglia il volto del leopardo con mm.crop(img_leop_gray, 250, H-300, 100, W-200) e la regione facciale del mandrillo con mm.crop(img_gray, 100, 400, 380, 530), in modo che occhi e struttura facciale risultino approssimativamente allineati. Il ritaglio del leopardo viene quindi ridimensionato (mm.resize) alle dimensioni del mandrillo prima della miscelazione.
mm.blend esegue l’operazione in virgola mobile — evitando overflow nei calcoli con pesi frazionari — e solo successivamente arrotonda e satura il risultato in uint8.
import os
base = "https://upload.wikimedia.org/wikipedia/commons"
arquivo = "Leopard_%28Panthera_pardus%29_portrait.jpg"
url = f"{base}/9/92/{arquivo}"
caminho = "imagens/leopardo.jpg"
if not os.path.exists(caminho):
os.makedirs("imagens", exist_ok=True)
mm.write(mm.read(url), caminho)
img_leop = mm.read(caminho)
img_leop_gray = mm.gray(img_leop)
mm.show(img_leop)
# ritagli allineati: volto del leopardo e regione facciale del mandrillo
leo = mm.crop(img_leop_gray, 250, img_leop_gray.shape[0] - 300, 100, img_leop_gray.shape[1] - 200)
mandrill = mm.crop(img_gray, 100, 400, 380, 530)
leo_r = mm.resize(leo, (mandrill.shape[1], mandrill.shape[0]), method="bilinear")
mm.show(
[mm.blend(mandrill, leo_r, alpha=1.0), mm.blend(mandrill, leo_r, alpha=0.8),
mm.blend(mandrill, leo_r, alpha=0.6), mm.blend(mandrill, leo_r, alpha=0.4),
mm.blend(mandrill, leo_r, alpha=0.2), mm.blend(mandrill, leo_r, alpha=0.0)],
titles=["α=1.0", "α=0.8", "α=0.6", "α=0.4", "α=0.2", "α=0.0"],
cols=6
)
Le operazioni logiche bit a bit (AND, OR e NOT) agiscono direttamente sui bit di ciascun pixel e costituiscono la base per la creazione e l’applicazione di maschere (masks) — immagini binarie con solo 0 (nero) e 255 (bianco) utilizzate per isolare Regioni di Interesse (ROI).
Il comportamento di ciascuna operazione deriva dalla rappresentazione binaria del 255 (11111111) e dello 0 (00000000):
La Figura 3.5 illustra le tre operazioni applicate all’immagine del mandrillo con una maschera circolare.
h, w = img_gray.shape
# Maschera circolare piena, centrata sull'immagine (mm.circle disegna il
# disco; la versione didattica, test del raggio pixel per pixel, è mm.circle0).
mask_circ = mm.circle(np.zeros((h, w), dtype=np.uint8),
(w // 2, h // 2), min(h, w) // 3 - 10, 255, -1)
# Operazioni tramite morph
img_not = mm.bnot(img_gray) # NOT: negativo fotografico
img_and = mm.band(img_gray, mask_circ) # preserva solo la ROI circolare
img_or = mm.bor(img_gray, mask_circ) # illumina la regione della maschera
mm.show(
[img_gray, img_and, img_or, img_not],
titles=["Originale", "AND (ROI circolare)", "OR (illumina ROI)", "NOT (negativo)"],
cols=4
)
L’istogramma di un’immagine in scala di grigi è una funzione discreta che descrive la distribuzione delle frequenze delle intensità:
\[ h(r_k) = n_k, \quad k = 0, 1, \ldots, L-1 \tag{3.5}\]
dove \(r_k\) è il \(k\)-esimo livello di intensità, \(n_k\) è il numero di pixel con tale intensità e \(L\) è il totale dei livelli (tipicamente 256 per 8 bit). L’istogramma normalizzato stima la probabilità di ciascun livello:
\[ p(r_k) = \frac{n_k}{MN} \tag{3.6}\]
dove \(MN\) è il totale dei pixel. Essendo una statistica globale, l’istogramma non contiene informazioni posizionali, ma rivela caratteristiche essenziali come luminosità media, contrasto e distribuzione tonale. In pratica, mm.hist(img) restituisce il vettore delle occorrenze \(h(r_k)\), che serve sia per la visualizzazione (tramite mm.histImg) sia per calcoli come la funzione di distribuzione cumulativa (CDF) e l’equalizzazione.
La Figura 3.6 presenta l’istogramma dell’immagine del mandrillo, nonché versioni scurita (mm.subm) e schiarita (mm.addm). Si osserva lo spostamento della distribuzione delle intensità rispettivamente verso sinistra e verso destra. Si noti che l’intervallo rappresentato sull’asse \(x\) non corrisponde necessariamente all’intera gamma da 0 a 255.
img_dark = mm.subm(img_gray, 80)
img_high = mm.addm(img_gray, 80)
mm.show(
[img_gray, img_dark, img_high,
mm.histImg(img_gray), mm.histImg(img_dark), mm.histImg(img_high)],
titles=["Originale", "Scurita (-80)", "Schiarita (+80)",
"Istogramma - originale", "Istogramma - scurita", "Istogramma - schiarita"],
cols=3
)
L’equalizzazione dell’istogramma ridistribuisce le intensità affinché l’istogramma risultante sia il più uniforme possibile. La mappatura è data dalla funzione di distribuzione cumulativa (CDF):
\[ s_k = T(r_k) = (L-1)\sum_{j=0}^{k} p(r_j) = \frac{L-1}{MN}\sum_{j=0}^{k} n_j \tag{3.7}\]
La trasformazione è monotòna: i livelli frequenti ricevono intervalli più ampi nel dominio di uscita (maggiore separazione → maggiore contrasto), mentre i livelli rari vengono compressi.
L’algoritmo completo, in cinque fasi, è presentato nella Tabella 3.1.
| Fase | Operazione | Formula |
|---|---|---|
| 1 | Istogramma | \(h[k] \leftarrow\) numero di pixel con intensità \(k\), \(k=0\ldots L-1\) |
| 2 | Probabilità | \(p[k] \leftarrow h[k] / MN\) |
| 3 | CDF | \(\text{cdf}[k] \leftarrow \sum_{j=0}^{k} p[j]\) (somma cumulativa) |
| 4 | Look-Up Table (mappatura) | \(\text{lut}[k] \leftarrow \text{round}(\text{cdf}[k] \times (L-1))\) |
| 5 | Applicazione | \(g[i,j] \leftarrow \text{lut}[f[i,j]]\) (per ogni pixel) |
Si noti nella Figura 3.7 che l’equalizzazione ridistribuisce i toni esistenti in posizioni più distanziate lungo l’intervallo \([0, L-1]\), ma non crea nuovi toni — l’immagine equalizzata continua ad avere esattamente 3 toni distinti, ora in \(\{1, 5, 7\}\) invece di \(\{2, 3, 4\}\).
img5 = np.array([[3, 4, 2, 3, 4],
[4, 3, 3, 4, 3],
[2, 3, 4, 3, 2],
[3, 4, 3, 2, 3],
[4, 3, 2, 3, 4]], dtype=np.uint8)
L = 8 # 3 bit: livelli 0..7
# 1. Istogramma con dimensione garantita fino a L
h = mm.hist(img5, 3) # B=3 → 2³=8 livelli, dimensione garantita
p = h / h.sum() # 2. Probabilità di ogni livello p[k] = h[k] / MN
cdf = np.cumsum(p) # 3. CDF normalizzata o
# cdf = np.zeros(len(p))
# cdf[0] = p[0]
# for k in range(1, len(p)):
# cdf[k] = cdf[k-1] + p[k] # cdf[k] = Σ p[j], j=0..k
lut = np.round(cdf * (L - 1)).astype(np.uint8) # 4. LUT: mappatura a [0, L-1]
img5_eq = lut[img5] # 5. Applica LUT pixel per pixel o, equivalentemente a:
# l, c = img5.shape
# img5_eq = np.zeros((l, c), dtype=np.uint8)
# for i in range(l):
# for j in range(c):
# img5_eq[i, j] = lut[img5[i, j]] # g[i,j] = lut[f[i,j]]
print("Immagine originale (5×5, 3 bit):")
print(img5)
print()
header = f"{'k':>3} {'h[k]':>6} {'p[k]':>7} {'CDF[k]':>8} {'lut[k]':>7}"
print(header)
print("-" * len(header))
for k in range(L):
print(f"{k:>3} {h[k]:>6} {p[k]:>7.4f} {cdf[k]:>8.4f} {lut[k]:>7}")
print()
print("Immagine equalizzata (5×5):")
print(img5_eq)
# Conta toni distinti
tons_orig = len(np.unique(img5))
tons_eq = len(np.unique(img5_eq))
mm.show(
[img5, img5_eq, mm.histImg(img5, L-1), mm.histImg(img5_eq, L-1)],
titles=[f"Originale ({tons_orig} toni: {sorted(np.unique(img5).tolist())})",
f"Equalizzata ({tons_eq} toni: {sorted(np.unique(img5_eq).tolist())})",
"Istogramma — Originale",
"Istogramma — Equalizzata"],
rows=2, cols=2, figsize=(5, 4), dpi=100
)Immagine originale (5×5, 3 bit):
[[3 4 2 3 4]
[4 3 3 4 3]
[2 3 4 3 2]
[3 4 3 2 3]
[4 3 2 3 4]]
k h[k] p[k] CDF[k] lut[k]
-----------------------------------
0 0 0.0000 0.0000 0
1 0 0.0000 0.0000 0
2 5 0.2000 0.2000 1
3 12 0.4800 0.6800 5
4 8 0.3200 1.0000 7
5 0 0.0000 1.0000 7
6 0 0.0000 1.0000 7
7 0 0.0000 1.0000 7
Immagine equalizzata (5×5):
[[5 7 1 5 7]
[7 5 5 7 5]
[1 5 7 5 1]
[5 7 5 1 5]
[7 5 1 5 7]]
Limitazione: l’equalizzazione globale può enfatizzare eccessivamente il rumore e produrre contrasto eccessivo nelle regioni omogenee. Il CLAHE (Contrast Limited Adaptive Histogram Equalization) riduce questo problema applicando l’equalizzazione a blocchi locali (tiles) e limitando l’altezza dei picchi dell’istogramma prima dell’equalizzazione.
La Figura 3.8 confronta l’immagine originale, l’equalizzazione globale tramite mm.equalize e il CLAHE di OpenCV, mostrando anche gli istogrammi risultanti. Diversamente dall’equalizzazione globale, che utilizza una singola trasformazione basata sulla CDF dell’intera immagine, il CLAHE adatta il contrasto a ciascuna regione, essendo particolarmente utile in immagini con illuminazione non uniforme.
Nell’esempio sono stati utilizzati clipLimit=2.0 e tileGridSize=(32,32). Il parametro clipLimit definisce quanto i picchi dell’istogramma locale possono crescere prima di essere tagliati (clipped). In OpenCV, questo valore è un fattore relativo: il limite effettivo è approssimativamente calcolato come clipLimit × (numero di pixel del blocco / numero di livelli di grigio). Ad esempio, in un blocco con 4096 pixel e un’immagine a 8 bit (256 livelli di grigio), la frequenza media per livello è \(4096/256=16\). Pertanto, clipLimit=2.0 consente picchi di circa \(2\times16=32\) occorrenze prima del taglio. Le occorrenze eccedenti non vengono scartate: vengono ridistribuite tra gli altri livelli di grigio dell’istogramma, riducendo la concentrazione eccessiva in pochi livelli ed evitando un’amplificazione esagerata del contrasto locale. Valori minori limitano maggiormente il contrasto e riducono l’amplificazione del rumore, mentre valori maggiori consentono un miglioramento più intenso ma possono introdurre artefatti.
clipLimit=1.0: miglioramento morbido e conservativo;clipLimit=2.0: buon equilibrio tra contrasto e naturalezza;clipLimit=4.0: maggiore evidenziazione dei dettagli locali;clipLimit=8.0: contrasto aggressivo, con possibile amplificazione del rumore.Pertanto, il CLAHE tende a produrre risultati più naturali rispetto all’equalizzazione globale, specialmente in immagini con ombre, riflessi o illuminazione disomogenea.
img_eq = mm.equalize(img_gray)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(32, 32))
img_clahe = clahe.apply(img_gray)
images = [img_gray, img_eq, img_clahe]
titles = ["Original", "mm.equalize (CDF)", "CLAHE"]
mm.show(
images + [mm.histImg(img) for img in images],
titles=titles + [f"Histograma — {t}" for t in titles],
rows=2, cols=3,
figsize=(14, 8)
)
Mentre l’equalizzazione impone una distribuzione uniforme, la specifica dell’istogramma (histogram matching) consente che l’istogramma dell’immagine di uscita segua una distribuzione arbitraria — ad esempio, l’istogramma di un’altra immagine di riferimento.
La procedura prevede tre fasi:
\[ T(r_k) = \arg\min_{z}\,|P_z(z) - P_r(r_k)| \tag{3.8}\]
Nella Figura 3.9, trasferiamo il profilo tonale del leopardo (Figura 3.3) all’immagine del mandrillo — un’applicazione diretta del concetto visto nel blending: invece di fondere i pixel, qui fondiamo le distribuzioni tonali.
# mappa src sul profilo tonale di ref tramite CDF
def hist_specify(src, ref):
cdf_src = np.cumsum(mm.hist(src) / src.size)
cdf_ref = np.cumsum(mm.hist(ref) / ref.size)
lut = np.array([np.argmin(np.abs(cdf_ref - v)) for v in cdf_src], dtype=np.uint8)
return lut[src]
img_spec = hist_specify(img_gray, img_leop_gray)
mm.show(
[img_gray, img_leop_gray, img_spec,
mm.histImg(img_gray), mm.histImg(img_leop_gray), mm.histImg(img_spec)],
titles=["Mandrillo (originale)", "Leopardo (riferimento)", "Mandrillo → profilo del leopardo",
"Istogramma — Mandrillo", "Istogramma — Leopardo", "Istogramma — risultato"],
rows=2, cols=3, figsize=(12, 9)
)
Le operazioni di filtraggio spaziale non agiscono su un singolo pixel isolato, ma su un intorno che lo circonda. A tale scopo, si utilizza una piccola matrice di coefficienti denominata kernel (o maschera), che percorre l’intera immagine attraverso una finestra scorrevole (sliding window).
Le finestre più comuni sono 3×3, 5×5 e 7×7. In una finestra 3×3, ad esempio, il pixel centrale viene elaborato insieme ai suoi otto vicini immediati. In ogni posizione della finestra, i valori dei pixel vengono combinati con i coefficienti del kernel, producendo un nuovo valore per il pixel centrale.
Si consideri una finestra 3×3 centrata sul pixel \((x,y)\):
\[ \begin{bmatrix} (x-1,y-1) & (x,y-1) & (x+1,y-1) \\ (x-1,y) & (x,y) & (x+1,y) \\ (x-1,y+1) & (x,y+1) & (x+1,y+1) \end{bmatrix} \tag{3.9}\]
In generale, una finestra di dimensioni \((2a+1)\times(2b+1)\) comprende tutti i pixel situati fino a \(a\) posizioni in orizzontale e fino a \(b\) posizioni in verticale rispetto al pixel centrale. Pertanto, una finestra 3×3 corrisponde a \(a=b=1\), una finestra 5×5 a \(a=b=2\), e così via.
Matematicamente, l’intorno è definito da
\[ \mathcal{V}(x,y)= \{(x+s,\,y+t): -a\le s\le a,\,-b\le t\le b\} \tag{3.10}\]
I pixel vicini ai bordi hanno parte del loro intorno al di fuori dell’immagine. Per applicare filtri in queste regioni, è necessario definire come verranno ottenuti i valori esterni. Le tre strategie più comuni (con la costante equivalente di OpenCV tra parentesi) sono:
BORDER_CONSTANT): completa la regione esterna con zeri.BORDER_REPLICATE): ripete il valore del pixel del bordo.BORDER_REFLECT_101): rispecchia i pixel vicini, senza ripetere quello del bordo.mm.conv utilizza la riflessione per impostazione predefinita, poiché preserva meglio la continuità dei livelli di grigio e riduce gli artefatti nel trattamento dei bordi.
L’esempio seguente confronta le tre strategie con mm.pad su una matrice 3×3. Osserva come ciascuna riempie i pixel esterni necessari per applicare un filtro 3×3 anche agli angoli.
img = np.array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
], dtype=np.uint8)
bordas = ["constant", "replicate", "reflect101"]
print("Immagine originale:")
print(mm.drawImg(img))
for k in [3, 5]:
b = k // 2
print(f"=== Kernel {k}x{k} (padding b={b}) ===")
for nome in bordas:
print(nome)
print(mm.drawImg(mm.pad(img, b, border=nome)))Immagine originale:
1 2 3
4 5 6
7 8 9
=== Kernel 3x3 (padding b=1) ===
constant
0 0 0 0 0
0 1 2 3 0
0 4 5 6 0
0 7 8 9 0
0 0 0 0 0
replicate
1 1 2 3 3
1 1 2 3 3
4 4 5 6 6
7 7 8 9 9
7 7 8 9 9
reflect101
5 4 5 6 5
2 1 2 3 2
5 4 5 6 5
8 7 8 9 8
5 4 5 6 5
=== Kernel 5x5 (padding b=2) ===
constant
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 1 2 3 0 0
0 0 4 5 6 0 0
0 0 7 8 9 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
replicate
1 1 1 2 3 3 3
1 1 1 2 3 3 3
1 1 1 2 3 3 3
4 4 4 5 6 6 6
7 7 7 8 9 9 9
7 7 7 8 9 9 9
7 7 7 8 9 9 9
reflect101
9 8 7 8 9 8 7
6 5 4 5 6 5 4
3 2 1 2 3 2 1
6 5 4 5 6 5 4
9 8 7 8 9 8 7
6 5 4 5 6 5 4
3 2 1 2 3 2 1
Osserva che il risultato di un filtro può variare significativamente in base al trattamento adottato per i bordi dell’immagine.
Nella libreria didattica morph.py, gli algoritmi implementati direttamente in Python (senza OpenCV o scikit-image) — le varianti con suffisso 0, come mm.conv0 — non usano padding. Per ogni pixel, gli elementi del vicinato vengono esaminati singolarmente, e solo i vicini le cui coordinate appartengono al dominio dell’immagine partecipano al calcolo. Pertanto, nelle regioni vicine ai bordi, il vicinato effettivo può contenere meno pixel rispetto alla finestra specificata; negli operatori basati su mm._viz (ad esempio mm.laplacian), i pixel di bordo con finestra incompleta vengono lasciati invariati.
Esistono due meccanismi matematicamente correlati.
Correlazione incrociata (cross-correlation) — il kernel viene applicato direttamente:
\[ g(x,y) = \sum_{s=-a}^{a}\sum_{t=-b}^{b} w(s,t)\,f(x+s,\,y+t) \tag{3.11}\]
Convoluzione bidimensionale — il kernel viene ruotato di 180° prima dell’applicazione:
\[ g(x,y) = \sum_{s=-a}^{a}\sum_{t=-b}^{b} w(s,t)\,f(x-s,\,y-t) \tag{3.12}\]
Per kernel simmetrici (Gaussiano, Laplaciano, media) le due operazioni producono risultati identici. Per kernel asimmetrici (Sobel, Prewitt) la differenza è significativa, come mostrano gli esempi seguenti.
mm.conv)# immagine 4x4 (uint8) e kernel asimmetrico 3x3
img = np.array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]], dtype=np.uint8)
w = np.array([[0, 1, 2],
[0, 0, 0],
[0, 0, 0]], dtype=np.float32)
corr = mm.conv(img, w, border="constant") # zero fuori dall'immagine
print("Immagine originale:"); print(mm.drawImg(img))
print("Kernel:"); print(mm.drawImg(w))
print("Risultato della correlazione:"); print(mm.drawImg(corr))Immagine originale:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Kernel:
0 1 2
0 0 0
0 0 0
Risultato della correlazione:
0 0 0 0
5 8 11 4
17 20 23 8
29 32 35 12
mm.conv esegue la correlazione, cioè applica il kernel esattamente nell’orientamento fornito.
# ripetuti qui affinché la cella sia indipendente
img = np.array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]], dtype=np.uint8)
w = np.array([[0, 1, 2],
[0, 0, 0],
[0, 0, 0]], dtype=np.float32)
# kernel ruotato di 180° (equivale a np.rot90(w, 2))
w_conv = np.array([[0, 0, 0],
[0, 0, 0],
[2, 1, 0]], dtype=np.float32)
conv = mm.conv(img, w_conv, border="constant")
print("Immagine originale:"); print(mm.drawImg(img))
print("Kernel originale:"); print(mm.drawImg(w))
print("Kernel ruotato di 180°:"); print(mm.drawImg(w_conv))
print("Risultato della convoluzione:"); print(mm.drawImg(conv))Immagine originale:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Kernel originale:
0 1 2
0 0 0
0 0 0
Kernel ruotato di 180°:
0 0 0
0 0 0
2 1 0
Risultato della convoluzione:
5 16 19 22
9 28 31 34
13 40 43 46
0 0 0 0
La convoluzione utilizza il kernel ruotato di 180°. Per riprodurre la definizione matematica di convoluzione, si ruota il kernel (qui, [[0,1,2],[0,0,0],[0,0,0]] → [[0,0,0],[0,0,0],[2,1,0]]) prima di applicare mm.conv.
I coefficienti del kernel determinano completamente l’effetto prodotto dal filtro, come riassunto nella Tabella 3.2.
| Caratteristica | Effetto tipico |
|---|---|
| Coefficienti positivi con somma 1 | Attenuazione (passa-basso) |
| Somma pari a 0, con valori positivi e negativi | Rilevamento dei bordi (passa-alto) |
| Coefficiente centrale positivo dominante e vicini negativi | Enfasi della nitidezza |
| Coefficienti asimmetrici | Gradiente direzionale |
Esempi:
Attenuazione: \[ \frac{1}{9} \begin{bmatrix} 1&1&1\\ 1&1&1\\ 1&1&1 \end{bmatrix} \]
Rilevamento dei bordi: \[ \begin{bmatrix} -1&-1&-1\\ -1&8&-1\\ -1&-1&-1 \end{bmatrix} \]
Enfasi della nitidezza: \[ \begin{bmatrix} 0&-1&0\\ -1&5&-1\\ 0&-1&0 \end{bmatrix} \]
Gradiente direzionale (Sobel): \[ \begin{bmatrix} -1&0&1\\ -2&0&2\\ -1&0&1 \end{bmatrix} \]
La Figura 3.10 dimostra il meccanismo passo dopo passo: per ogni posizione della finestra, si moltiplica ciascun coefficiente del kernel per il pixel corrispondente dell’intorno e si sommano i prodotti ottenuti. Il risultato è esattamente il valore definito dalla Equazione 3.11 per quella posizione dell’immagine. Sebbene le immagini prodotte da mm.conv0 e cv2.filter2D (o mm.conv) siano visivamente molto simili, l’implementazione basata su OpenCV è migliaia di volte più rapida, come mostrato di seguito.
La funzione mm.conv0 implementa la correlazione direttamente in Python tramite cicli annidati. Sebbene questo approccio sia adeguato a fini didattici, esegue un numero elevato di operazioni e diventa lento per immagini di dimensioni maggiori.
Invece, mm.conv utilizza cv2.filter2D, implementato in C++ e ottimizzato per operazioni matriciali. Nell’esempio presentato, la versione vettorializzata è risultata oltre 3000 volte più rapida rispetto all’implementazione didattica, producendo un risultato visivamente equivalente.
Le differenze numeriche osservate si concentrano principalmente sui bordi dell’immagine. In mm.conv0, i pixel del bordo rimangono invariati, mentre mm.conv adotta una strategia di riflessione dei bordi (cv2.BORDER_REFLECT_101, predefinita di cv2.filter2D).
Pertanto, mm.conv0 dovrebbe essere utilizzata per comprendere l’algoritmo, mentre mm.conv è l’opzione consigliata per applicazioni pratiche.
import time
w_mean = np.ones((3,3), dtype=np.float32) / 9.0
img_gray = img_leop_gray
# Demonstração numérica em patch 5×5
patch = img_gray[250:255, 250:255].astype(np.float32)
roi = patch[0:3, 0:3]
print("Patch 5×5 (intensidades):")
print(patch.astype(np.int32))
print(f"\nKernel 3×3 de média:\n{w_mean}")
print(f"\nCorrelação no pixel central [1,1]: \
{(w_mean * roi).sum():.1f} (original: {patch[1,1]:.0f})")
# Comparação de tempo na imagem completa
t0 = time.perf_counter()
img_conv0 = mm.conv0(img_gray, w_mean)
t_conv0 = time.perf_counter() - t0
t0 = time.perf_counter()
img_conv = mm.conv(img_gray, w_mean)
t_conv = time.perf_counter() - t0
diff = np.abs(img_conv0.astype(int) - img_conv.astype(int)).max()
print(f"\nTempos na imagem {img_gray.shape[0]}x{img_gray.shape[1]}:")
print(f" mm.conv0 (laços Python): {t_conv0:.3f} s")
print(f" mm.conv (cv2.filter2D): {t_conv:.5f} s")
print(f" Aceleração: {t_conv0/t_conv:.0f}× mais rápido")
print(f" Diferença máxima: {diff} (bordas com padding diferente)")
mm.show(
[img_gray, img_conv0, img_conv],
titles=["Original", f"conv0 ({t_conv0:.2f}s)", f"conv ({t_conv:.4f}s)"],
cols=3
)Patch 5×5 (intensidades):
[[ 91 95 108 116 114]
[106 107 108 111 114]
[102 103 107 112 116]
[ 83 90 111 125 123]
[ 79 88 110 126 124]]
Kernel 3×3 de média:
[[0.11111111 0.11111111 0.11111111]
[0.11111111 0.11111111 0.11111111]
[0.11111111 0.11111111 0.11111111]]
Correlação no pixel central [1,1]: 103.0 (original: 107)
Tempos na imagem 1324x1242:
mm.conv0 (laços Python): 5.345 s
mm.conv (cv2.filter2D): 0.00247 s
Aceleração: 2163× mais rápido
Diferença máxima: 39 (bordas com padding diferente)
Per rendere concreto il meccanismo della Equazione 3.11, si consideri il kernel di media 3×3 (\(a=b=1\), tutti i coefficienti \(= 1/9 \approx 0{,}111\)) applicato al patch 5×5 estratto dall’immagine del leopardo. La Figura 3.11 mostra il patch con griglia ed evidenzia in giallo la finestra 3×3 centrata sul pixel \([1,1]\):
patch = img_gray[250:255, 250:255]
B = np.ones((3, 3), dtype=np.uint8)
print("Patch 5×5 (intensità):")
print(mm.drawImg(patch))
mm.drawImgKernel(patch, B, 1, 1, 40)Patch 5×5 (intensità):
91 95 108 116 114
106 107 108 111 114
102 103 107 112 116
83 90 111 125 123
79 88 110 126 124
Per illustrare il calcolo della correlazione, si consideri il pixel nella posizione \([1,1]\) del patch 5×5 mostrato nella Figura 3.11.. Tale posizione è stata scelta solo per comodità didattica, poiché possiede un intorno 3×3 completo attorno a sé.
I valori di tale intorno corrispondono alla sottomatrice in alto a sinistra del patch:
\[ \text{vicinato} = \begin{bmatrix} 91 & 95 & 108 \\ 106 & 107 & 108 \\ 102 & 103 & 107 \end{bmatrix} \]
Applicando la Equazione 3.11 con il kernel di media:
\[ g[1,1] = \frac{ 91+95+108+106+107+108+102+103+107}{9} = \frac{927}{9} = 103 \]
Il risultato (103) è leggermente inferiore al valore originale del pixel centrale (107), poiché la media incorpora vicini di minore intensità, producendo l’effetto di smussamento. In pratica, l’algoritmo avvia l’elaborazione in \([0,0]\) e ripete lo stesso calcolo per ogni posizione dell’immagine, spostando la finestra fino a coprire l’intero dominio.
I filtri di levigatura (smoothing filters) attenuano le variazioni brusche di intensità, riducendo rumore e dettagli ad alta frequenza. Sono filtri passa-basso — preservano le componenti a bassa frequenza (strutture grandi) e attenuano quelle ad alta frequenza (rumore, bordi).
Il filtro a media utilizza un kernel uniforme di dimensione \(n \times n\), dove tutti i coefficienti valgono \(1/n^2\):
\[ w_{\text{media}} = \frac{1}{n^2} \begin{bmatrix} 1 & \cdots & 1 \\ \vdots & \ddots & \vdots \\ 1 & \cdots & 1 \end{bmatrix}_{n \times n} \tag{3.13}\]
Ogni pixel di uscita è la media aritmetica degli \(n^2\) pixel del suo intorno. Si noti che la somma dei coefficienti è sempre 1 — la luminosità media dell’immagine viene preservata. Kernel più grandi producono una levigatura più aggressiva, ma sfumano progressivamente i bordi.
La Figura 3.12 mostra l’effetto del filtro di media con kernel \(3\times3\), \(7\times7\) e \(15\times15\) su un dettaglio dell’immagine del leopardo. I risultati sono stati ottenuti con mm.blur, che implementa il filtro di media tramite la funzione cv2.blur, equivalente alla convoluzione dell’immagine con un kernel uniforme i cui coefficienti sono \(h(x,y)=1/N^2\); in modo equivalente, lo stesso risultato può essere ottenuto con mm.conv, calcolando (\(g=f*h\)). Man mano che il kernel aumenta, più pixel contribuiscono a ciascun valore di uscita, intensificando la levigatura, riducendo il rumore e rendendo i dettagli fini e i bordi progressivamente più sfocati.
# Dettaglio della regione dell'occhio
y0, y1, x0, x1 = 580, 740, 680, 900
crop = lambda img: img[y0:y1, x0:x1]
img_gray_crop = crop(img_gray)
sizes = [3, 7, 15]
imgs = [img_gray_crop] + \
[mm.blur(img_gray_crop, k) for k in sizes] # o
#[mm.conv(img_gray_crop, np.ones((k,k), dtype=np.float32)/(k*k)) for k in sizes]
titles = ["Original"] + [f"Média {k}×{k}" for k in sizes]
mm.show(imgs, titles=titles, cols=4)
Il filtro gaussiano pesa i pixel dell’intorno secondo una funzione gaussiana bidimensionale:
\[ G(s,t) = \frac{1}{2\pi\sigma^2}\,e^{-\frac{s^2+t^2}{2\sigma^2}} \tag{3.14}\]
dove \(\sigma\) è la deviazione standard e controlla il raggio di influenza. I pixel più vicini al centro hanno peso maggiore; i pixel distanti vengono progressivamente ignorati.
A Figura 3.13 apresenta o kernel Gaussiano \(5\times5\) gerado para \(\sigma=1\). O kernel foi costruído a partir do produto externo de due vettori Gaussiani unidimensionali e successivamente normalizzato affinché la somma dei suoi coefficienti sia uguale a \(1\). Si osserva che i pesi maggiori si concentrano al centro della matrice, decrescendo radialmente verso i bordi. Questa distribuzione fa sì che i pixel centrali abbiano maggiore influenza sul risultato del filtraggio, contribuendo a una smussatura più naturale e con una migliore conservazione dei bordi rispetto al filtro della media.
# Genera kernel Gaussiano 5×5 tramite cv2
k_gauss = cv2.getGaussianKernel(5, 1)
w_gauss = k_gauss @ k_gauss.T # @ => moltiplicazione matriciale: G(s,t) = G(s)·G(t)
w_gauss = w_gauss / w_gauss.sum() # garantisce somma = 1
print("Kernel Gaussiano 5×5 (σ=1), normalizzato:")
for row in w_gauss:
print(" " + " ".join(f"{v:.4f}" for v in row))
print(f"\nSomma dei coefficienti: {w_gauss.sum():.6f}")
print(f"Peso centrale vs. angolo: {w_gauss[2,2]:.4f} vs. {w_gauss[0,0]:.4f} "
f"({w_gauss[2,2]/w_gauss[0,0]:.1f}× maggiore)")
mm.drawImgPlt((w_gauss * 1000).astype(np.uint8), scale=40)Kernel Gaussiano 5×5 (σ=1), normalizzato:
0.0030 0.0133 0.0219 0.0133 0.0030
0.0133 0.0596 0.0983 0.0596 0.0133
0.0219 0.0983 0.1621 0.0983 0.0219
0.0133 0.0596 0.0983 0.0596 0.0133
0.0030 0.0133 0.0219 0.0133 0.0030
Somma dei coefficienti: 1.000000
Peso centrale vs. angolo: 0.1621 vs. 0.0030 (54.6× maggiore)
Si consideri un kernel quadrato di dimensione \(n \times n\). Se tale filtro è separabile (come quello gaussiano), la convoluzione 2D può essere decomposta in due convoluzioni 1D: una orizzontale e una verticale.
In questo caso, il costo per pixel passa da circa \(O(n^2)\) operazioni (convoluzione 2D diretta) a \(O(2n)\) operazioni (due convoluzioni 1D). La complessità viene quindi ridotta in modo significativo, rendendo l’elaborazione più efficiente.
Rispetto al filtro medio, il filtro gaussiano:
La Figura 3.14 confronta i filtri media e gaussiano applicati all’immagine del leopardo utilizzando una finestra \(9\times9\). Il filtro media è stato implementato tramite convoluzione con un kernel uniforme, in cui tutti gli \(81\) pixel dell’intorno possiedono lo stesso peso (\(1/81\)), mentre il filtro gaussiano è stato ottenuto con cv2.GaussianBlur, utilizzando pesi definiti da una distribuzione gaussiana. Entrambi riducono il rumore e levigano l’immagine, ma il filtro gaussiano preserva meglio i bordi e i dettagli locali, come si può osservare nella regione ingrandita dell’occhio.
La Figura 3.14 confronta i filtri media e gaussiano applicati a un dettaglio dell’immagine del leopardo con kernel \(9\times 9\). Il filtro media è stato ottenuto con mm.blur, equivalente alla convoluzione con un kernel uniforme i cui coefficienti valgono \(1/81\), mentre il filtro gaussiano è stato ottenuto con mm.gaussian, equivalente alla convoluzione con un kernel generato a partire da una distribuzione gaussiana. Entrambi promuovono levigatura e riduzione del rumore, ma il filtro gaussiano attribuisce un peso maggiore ai pixel centrali dell’intorno, preservando meglio i bordi e i dettagli locali, come si può osservare nella regione ingrandita dell’occhio.
img_media9 = mm.blur(img_gray, 9)
img_gauss9 = mm.gaussian(img_gray, 9, 0)
# Dettaglio della regione dell'occhio
img_gray_crop = mm.crop(img_gray, 580, 740, 680, 900)
img_media9_crop = mm.crop(img_media9, 580, 740, 680, 900)
img_gauss9_crop = mm.crop(img_gauss9, 580, 740, 680, 900)
mm.show(
[img_gray_crop, img_media9_crop, img_gauss9_crop],
titles=["Dettaglio: Originale", "Media 9×9", "Gaussiano 9×9"],
cols=3, figsize=(12, 8)
)
I filtri di enfasi (sharpening filters) enfatizzano le transizioni brusche di intensità, aumentando la nitidezza e la visibilità dei bordi. Sono filtri passa-alto — amplificano le componenti ad alta frequenza (bordi, texture) e sopprimono quelle a bassa frequenza (regioni uniformi).
L’intuizione è semplice: se sottraiamo da un’immagine la sua versione attenuata (che contiene solo le basse frequenze), ciò che resta sono le alte frequenze — bordi e dettagli. Sommando questo residuo all’immagine originale, il contrasto locale aumenta:
\[ g = f + k\,(f - f_{\text{suave}}), \quad k > 0 \tag{3.15}\]
La Figura 3.15 illustra questo processo su un segnale 1D sintetico con tre strutture distinte: un gradino largo, un picco sottile e una rampa dolce. Nel pannello ①, il segnale originale \(f(x)\); nel ②, la versione attenuata \(f_{\text{suave}}(x)\) ottenuta mediante media mobile — si noti come il picco sottile venga attenuato. Il pannello ③ mostra il residuo \(f - f_{\text{suave}}\), che conserva solo le transizioni brusche. Infine, il pannello ④ mostra \(g(x)\): il picco, prima attenuato, viene ripristinato e amplificato rispetto all’originale. Regolate \(k\) e la dimensione della finestra per osservare il trade-off tra nitidezza e amplificazione del rumore.
I filtri di enfasi formalizzano questa idea direttamente nel kernel, senza necessità di due fasi separate.
Il Laplaciano è un operatore di derivata seconda isotropico, cioè risponde in modo uguale alle variazioni in tutte le direzioni, a differenza degli operatori di derivata prima, come Sobel e Prewitt, che sono direzionali:
\[ \nabla^2 f = \frac{\partial^2 f}{\partial x^2} + \frac{\partial^2 f}{\partial y^2} \tag{3.16}\]
Una proprietà importante della derivata seconda è che il suo valore è prossimo allo zero nelle regioni uniformi ed elevato nelle transizioni di intensità. Così, sottraendo il Laplaciano dall’immagine originale, si rafforzano bordi e dettagli, aumentando il contrasto locale:
\[ g(x,y) = f(x,y) - \nabla^2 f(x,y) \tag{3.17}\]
Nella forma discreta, la derivata seconda in \(x\) è approssimata da \(f(x+1,y) - 2f(x,y) + f(x-1,y)\), e analogamente in \(y\). Sommando le due direzioni, si ottiene il kernel \(w_4\) (4-vicini) o \(w_8\) (8-vicini, includendo le diagonali):
\[ w_4 = \begin{bmatrix} 0 & 1 & 0 \\ 1 & -4 & 1 \\ 0 & 1 & 0 \end{bmatrix}, \qquad w_8 = \begin{bmatrix} 1 & 1 & 1 \\ 1 & -8 & 1 \\ 1 & 1 & 1 \end{bmatrix} \tag{3.18}\]
Entrambi i kernel hanno somma dei coefficienti pari a zero: nelle regioni uniformi, l’uscita è 0 — il Laplaciano non modifica la luminosità media, ma rileva solo le variazioni. Il centro negativo indica che il pixel viene confrontato con i suoi vicini: quanto più esso si distingue (verso l’alto o verso il basso), tanto maggiore è il valore assoluto del Laplaciano in quel punto.
Nell’esempio seguente, il pixel centrale \([1,1]=107\) possiede vicini \(\{95, 106, 108, 103\}\). Poiché questi valori sono tra loro prossimi, la regione è quasi uniforme e il Laplaciano restituisce un valore basso, producendo poco miglioramento. Nelle regioni di bordo, dove vi sono differenze maggiori tra il pixel centrale e i suoi vicini, il Laplaciano assume valori più elevati (positivi o negativi), e l’operazione di Equazione 3.17 intensifica queste transizioni.
La Figura 3.16 illustra il calcolo del Laplaciano con il kernel \(w_4\) in un intorno \(3\times3\) evidenziato all’interno di un patch \(5\times5\). L’esempio mostra il valore ottenuto dall’operatore e il corrispondente pixel migliorato nell’immagine di uscita, che passa da 107 a 123.
patch = img_gray[250:255, 250:255]
w4 = np.array([[0, 1, 0],
[1,-4, 1],
[0, 1, 0]], dtype=np.float32)
B = np.ones((3,3), dtype=np.uint8)
p = patch.astype(np.float32)
lap_11 = int(p[0,1] + p[1,0] - 4*p[1,1] + p[1,2] + p[2,1])
real_11 = int(np.clip(p[1,1] - lap_11, 0, 255))
print("Patch originale:")
print(mm.drawImg(patch))
print(f"Laplac. w4 in [1,1]: ", end="")
print(f"{p[0,1]:.0f} + {p[1,0]:.0f} - 4×{p[1,1]:.0f} + {p[1,2]:.0f} + {p[2,1]:.0f} = {lap_11}")
print(f"Pixel evidenziato [1,1]: {p[1,1]:.0f} - ({lap_11}) = {real_11}")
mm.drawImgKernel(patch, B, x=1, y=1, scale=40.0)Patch originale:
91 95 108 116 114
106 107 108 111 114
102 103 107 112 116
83 90 111 125 123
79 88 110 126 124
Laplac. w4 in [1,1]: 95 + 106 - 4×107 + 108 + 103 = -16
Pixel evidenziato [1,1]: 107 - (-16) = 123
Figura 3.17 confronta l’applicazione dei kernel laplaciani \(w_4\) e \(w_8\) su un ritaglio più ampio dell’immagine del leopardo. Per ciascun caso, vengono mostrate la risposta grezza dell’operatore, che evidenzia i bordi e le transizioni di intensità, e l’immagine ottenuta dopo l’enfatizzazione mediante sottrazione del laplaciano. Si osserva che il kernel \(w_8\), considerando anche i vicini diagonali, produce una risposta più intensa e rileva variazioni in più direzioni, risultando in un’enfatizzazione lievemente più marcata.
w4 = np.array([[0, 1, 0],
[1,-4, 1],
[0, 1, 0]], dtype=np.float32)
w8 = np.array([[1, 1, 1],
[1,-8, 1],
[1, 1, 1]], dtype=np.float32)
mm.show(
[img_gray_crop, mm.laplacian_viz(img_gray_crop, w4), mm.laplacian(img_gray_crop, w4),
img_gray_crop, mm.laplacian_viz(img_gray_crop, w8), mm.laplacian(img_gray_crop, w8)],
titles=["Originale", "Laplaciano w4", "Evidenziazione w4",
"Originale", "Laplaciano w8", "Evidenziazione w8"],
cols=3, figsize=(14, 8)
)
L’operatore di Sobel stima le derivate parziali del primo ordine nelle direzioni orizzontale e verticale. A differenza del Laplaciano (derivata seconda), il Sobel è direzionale e più robusto al rumore, poiché ogni kernel combina una derivata con un smoothing gaussiano perpendicolare:
\[ G_x = \begin{bmatrix} -1 & 0 & 1 \\ -2 & 0 & 2 \\ -1 & 0 & 1 \end{bmatrix} * f, \qquad G_y = \begin{bmatrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ 1 & 2 & 1 \end{bmatrix} * f \tag{3.19}\]
\(G_x\) rileva i bordi verticali (variazione nella direzione \(x\)); \(G_y\) rileva i bordi orizzontali (variazione nella direzione \(y\)). I pesi \(\{1,2,1\}\) nella direzione perpendicolare corrispondono allo smoothing gaussiano 1D, che riduce la sensibilità al rumore.
I kernel di Sobel sono asimmetrici — la rotazione di 180° modifica il risultato. cv2.Sobel implementa la correlazione incrociata (come cv2.filter2D). Per ottenere la derivata direzionale corretta, i segni sono già definiti per la correlazione: \(G_x\) restituisce valori positivi dove l’intensità cresce da sinistra a destra.
La magnitudine del gradiente combina le due componenti, rappresentando la forza del bordo indipendentemente dalla direzione:
\[ |\nabla f| = \sqrt{G_x^2 + G_y^2} \tag{3.20}\]
E la direzione del gradiente (perpendicolare al bordo) è:
\[ \theta = \arctan\left(\frac{G_y}{G_x}\right) \tag{3.21}\]
Per illustrare numericamente, si calcolano \(G_x\) e \(G_y\) manualmente sul pixel centrale \([1,1]\) del patch 5×5:
patch = img_gray[250:255, 250:255]
p = patch.astype(np.float32)
# Gx nel pixel [1,1]: colonna destra - colonna sinistra (ponderata)
gx = (p[0,2] + 2*p[1,2] + p[2,2]) - (p[0,0] + 2*p[1,0] + p[2,0])
# Gy nel pixel [1,1]: riga inferiore - riga superiore (ponderata)
gy = (p[2,0] + 2*p[2,1] + p[2,2]) - (p[0,0] + 2*p[0,1] + p[0,2])
mag = np.sqrt(gx**2 + gy**2)
theta = np.degrees(np.arctan2(gy, gx))
print("Patch 5x5:")
print(mm.drawImg(patch))
print(f"Gx in [1,1]: ({p[0,2]:.0f} + 2*{p[1,2]:.0f} + {p[2,2]:.0f}) \
- ({p[0,0]:.0f} + 2*{p[1,0]:.0f} + {p[2,0]:.0f}) = {gx:.1f}")
print(f"Gy in [1,1]: ({p[2,0]:.0f} + 2*{p[2,1]:.0f} + {p[2,2]:.0f}) \
- ({p[0,0]:.0f} + 2*{p[0,1]:.0f} + {p[0,2]:.0f}) = {gy:.1f}")
# Sostituito il | con il prefisso mag per non rompere l'interprete di tabelle di Quarto
print(f"mag(Grad f) = sqrt({gx:.1f}^2 + {gy:.1f}^2) = {mag:.1f}")
print(f"Theta = arctan({gy:.1f}/{gx:.1f}) = {theta:.1f} gradi")Patch 5x5:
91 95 108 116 114
106 107 108 111 114
102 103 107 112 116
83 90 111 125 123
79 88 110 126 124
Gx in [1,1]: (108 + 2*108 + 107) - (91 + 2*106 + 102) = 26.0
Gy in [1,1]: (102 + 2*103 + 107) - (91 + 2*95 + 108) = 26.0
mag(Grad f) = sqrt(26.0^2 + 26.0^2) = 36.8
Theta = arctan(26.0/26.0) = 45.0 gradiIl valore ridotto di \(|{\nabla f}|\) in questo patch conferma che la regione è quasi uniforme, poiché il gradiente assume valori elevati solo dove vi sono cambiamenti significativi di intensità. La Figura 3.18 applica l’operatore di Sobel a un ritaglio più ampio dell’immagine del leopardo. Vengono presentate le risposte orizzontale (\(G_x\)) e verticale (\(G_y\)), ottenute per convoluzione con i rispettivi kernel di Sobel, oltre alla magnitudine \(|{\nabla f}|\), calcolata dalla combinazione di entrambe. Mentre \(G_x\) evidenzia i bordi verticali e \(G_y\) quelli orizzontali, la magnitudine mette in risalto i bordi in qualsiasi direzione.
def norm255(img):
mn, mx = img.min(), img.max() #+1e-9 per evitare la divisione per zero
return ((img - mn) / (mx - mn + 1e-9) * 255).astype(np.uint8)
sobelx = cv2.Sobel(img_gray_crop, cv2.CV_64F, 1, 0, ksize=3)
sobely = cv2.Sobel(img_gray_crop, cv2.CV_64F, 0, 1, ksize=3)
magnitude = np.sqrt(sobelx**2 + sobely**2)
direcao = np.degrees(np.arctan2(sobely, sobelx))
# magnitude = mm.sobel(img_gray_crop) # oppure, ma con clip invece di norm255
mm.show(
[img_gray_crop, norm255(np.abs(sobelx)), norm255(np.abs(sobely)),
norm255(magnitude), norm255(direcao % 180)],
titles=["Originale", "Gx (bordi vert.)", "Gy (bordi orizz.)",
"Magnitudine |∇f|", "Direzione θ (mod 180°)"],
cols=5
)
L’operatore di Prewitt è strutturalmente identico a Sobel, ma sostituisce la ponderazione gaussiana \(\{1,2,1\}\) con pesi uniformi \(\{1,1,1\}\):
\[ G_x = \begin{bmatrix} -1 & 0 & 1 \\ -1 & 0 & 1 \\ -1 & 0 & 1 \end{bmatrix} * f, \qquad G_y = \begin{bmatrix} -1 & -1 & -1 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \end{bmatrix} * f \tag{3.22}\]
La magnitudine e la direzione del gradiente seguono le stesse equazioni di Sobel (Equazione 3.20 e Equazione 3.21). La differenza pratica è che Prewitt è leggermente più sensibile al rumore — l’appianamento perpendicolare uniforme pondera meno il pixel centrale della linea — ma è computazionalmente più semplice. In immagini a basso rumore i risultati sono equivalenti.
Kx = np.array([[-1,0,1],[-1,0,1],[-1,0,1]], dtype=np.float32)
Ky = np.array([[-1,-1,-1],[0,0,0],[1,1,1]], dtype=np.float32)
f = img_gray_crop.astype(np.float32)
mm.show(
[img_gray_crop,
norm255(np.abs(cv2.filter2D(f, -1, Kx))),
norm255(np.abs(cv2.filter2D(f, -1, Ky))),
mm.prewitt(img_gray_crop)],
titles=["Originale", "Gx", "Gy", "Magnitudine |∇f|"],
cols=4
)
L’Unsharp Masking è una tecnica classica di miglioramento della nitidezza, originaria della fotografia analogica, oggi ampiamente utilizzata nei software di editing delle immagini. L’idea centrale è estrarre le componenti ad alta frequenza dell’immagine (bordi e dettagli) e sommarle nuovamente all’originale con un peso \(k\):
| Fase | Operazione | Descrizione |
|---|---|---|
| 1 | \(\bar{f} = f * G_\sigma\) | Smussa con una gaussiana — mantiene le basse frequenze |
| 2 | \(m = f - \bar{f}\) | Maschera: differenza = alte frequenze (bordi) |
| 3 | \(g = f + k \cdot m\) | Somma ponderata della maschera all’originale |
Sostituendo la fase 2 nella fase 3, si ottiene l’espressione compatta:
\[ g = f + k\,(f - f*G_\sigma) = (1+k)\,f - k\,(f*G_\sigma) \tag{3.23}\]
Il parametro \(k\) controlla l’intensità del miglioramento:
L’USM non distingue i bordi dal rumore — entrambi sono componenti ad alta frequenza. Per valori elevati di \(k\), il rumore presente nell’immagine viene amplificato insieme ai bordi. Per questo motivo, è consigliabile applicare una leggera smussatura prima dell’USM su immagini rumorose, oppure utilizzare un \(\sigma\) piccolo nella gaussiana.
Per illustrare le fasi dell’USM, la Figura 3.20 applica il metodo a una patch \(30\times30\) dell’immagine del leopardo, utilizzando \(\sigma=1\) e \(k=1\). Inizialmente, l’immagine viene smussata da un filtro gaussiano. Successivamente, la maschera ad alta frequenza si ottiene dalla differenza tra l’immagine originale e quella smussata. Infine, tale maschera viene sommata all’immagine originale, rafforzando bordi e dettagli. La figura presenta le tre fasi del processo e il risultato finale dell’enhancement.
patch = img_gray_crop[35:65, 45:75]
k = 1.0
sigma = 1.0
p = patch.astype(np.float32)
# Fase 1: sfocatura gaussiana
ksize = int(6 * sigma + 1) | 1 # l'operatore binario garantisce dimensione dispari
p_suave = mm.gaussian(patch, ksize, sigma).astype(np.float32)
# Fase 2: maschera ad alta frequenza
mascara = p - p_suave
# Fase 3: rafforzamento
p_usm = np.clip(p + k * mascara, 0, 255).astype(np.uint8)
# p_usm = mm.usm(patch, k) # oppure, diretta
print(f"Pixel centrale [1,1]: originale={int(p[1,1])} sfocato={p_suave[1,1]:.1f}"
f" maschera={mascara[1,1]:.1f} rafforzato={p_usm[1,1]}")
mm.show(
[patch,
p_suave.astype(np.uint8),
np.clip(mascara + 128, 0, 255).astype(np.uint8), # negativi visibili
p_usm],
titles=["Patch originale",
f"Sfocato (σ={sigma})",
"Maschera (alta freq., +128)",
f"Rafforzato USM (k={k})"],
cols=4, figsize=(12, 4)
)Pixel centrale [1,1]: originale=16 sfocato=20.0 maschera=-4.0 rafforzato=12
La Figura 3.21 applica il metodo USM a un ritaglio più ampio dell’immagine del leopardo utilizzando \(\sigma=1\) e diversi valori del fattore di guadagno \(k\). In tutti i casi, la maschera ad alta frequenza è ottenuta dalla differenza tra l’immagine originale e la sua versione smussata tramite filtro gaussiano. Il parametro \(k\) controlla l’intensità del miglioramento: valori più piccoli producono un aumento sottile della nitidezza, mentre valori più grandi rafforzano progressivamente bordi e dettagli. Si osserva che, per valori elevati di \(k\), compaiono aloni attorno ai bordi e il rumore presente nell’immagine viene amplificato.
mm.show(
[img_gray_crop,
mm.usm(img_gray_crop, 0.5), mm.usm(img_gray_crop, 1.0),
mm.usm(img_gray_crop, 3.0), mm.usm(img_gray_crop, 5.0),
mm.usm(img_gray_crop, 8.0)],
titles=["Originale", "USM k=0.5", "USM k=1.0", "USM k=3.0", "USM k=5.0", "USM k=8.0"],
cols=3
)
Il Canny combina quattro fasi in sequenza — smoothing gaussiano, gradiente di Sobel, soppressione dei non-massimi e isteresi con doppia soglia — per produrre bordi sottili, binari e connessi. A differenza di Sobel e Prewitt, il risultato non è una mappa di gradiente continua, ma una maschera in cui ogni pixel è bordi o non lo è.
Il parametro centrale è la coppia di soglie \((T_{low}, T_{high})\). I pixel con gradiente superiore a \(T_{high}\) sono bordi certi; al di sotto di \(T_{low}\), vengono scartati. I pixel ambigui — tra le due soglie — vengono decisi mediante isteresi: diventano bordi se sono connessi a un bordo certo, e vengono scartati in caso contrario. Questo evita sia la perdita di tratti deboli di bordi reali, sia l’inclusione di rumore isolato. Un’euristica comune è \(T_{high} = 3 \times T_{low}\).
mm.show(
[img_gray_crop,
mm.canny(img_gray_crop, 30, 90),
mm.canny(img_gray_crop, 60, 180),
mm.canny(img_gray_crop, 120, 240)],
titles=["Originale", "Canny (30/90)", "Canny (60/180)", "Canny (120/240)"],
cols=4
)
Un’euristica comune è \(T_{high} = 3 \times T_{low}\). I valori tipici dipendono dall’intervallo di gradiente dell’immagine — cv2.Canny accetta valori assoluti in \([0, 255]\). Per immagini con contrasto variabile, calcolare le soglie a partire dai percentili della magnitudine di Sobel è più robusto rispetto a valori fissi.
I filtri d’ordine (order-statistic filters) sostituiscono il pixel centrale con il valore di un percentile della distribuzione delle intensità del vicinato — a differenza dei filtri lineari, che calcolano combinazioni ponderate. Il più importante è il filtro mediano.
Il rumore sale e pepe (salt-and-pepper noise) sostituisce pixel casuali con valori estremi: 0 (pepe, nero) o 255 (sale, bianco). È comune nella trasmissione di immagini con errori di bit e in fotocamere con sensori difettosi.
Per capire perché i filtri lineari falliscono, si consideri un vicinato 3×3 in cui un singolo pixel è stato corrotto a 255:
\[ \text{vizinhança} = \begin{bmatrix} 102 & 98 & 105 \\ 100 & \mathbf{255} & 97 \\ 103 & 99 & 101 \end{bmatrix} \]
| Metodo | Calcolo | Risultato |
|---|---|---|
| Media | (102+98+…+255+…+101)/9 | ≈ 140 |
| Mediana | {97,98,99,100,101,102,103,105,255} | 101 |
La media è sensibile ai valori anomali — un singolo pixel con valore 255 in un vicinato di valore ≈ 100 innalza l’uscita a ≈ 140, diffondendo il rumore nell’immagine. La mediana, essendo uno stimatore robusto, seleziona il valore centrale della distribuzione ordinata, scartando naturalmente gli estremi senza alcun aggiustamento speciale.
L’esempio seguente illustra il comportamento della media e della mediana in presenza di un pixel corrotto da rumore impulsivo. Si osserva che la media è fortemente influenzata dal valore estremo (255), producendo una stima lontana dai valori predominanti del vicinato. La mediana, invece, rimane vicina al valore originale della regione, evidenziando la sua maggiore robustezza ai valori anomali e giustificando il suo utilizzo nella rimozione del rumore sale e pepe.
# Esempio numerico: media vs. mediana con pixel corrotto
vizinhanca = np.array([102, 98, 105, 100, 255, 97, 103, 99, 101])
print(f"Vicinato: {sorted([int(x) for x in vizinhanca])}")
print(f"Media: {vizinhanca.mean():.1f} (spostata dall'outlier 255)")
print(f"Mediana: {int(np.median(vizinhanca))} (ignora l'outlier)")
print(f"Valore originale: ~100")Vicinato: [97, 98, 99, 100, 101, 102, 103, 105, 255]
Media: 117.8 (spostata dall'outlier 255)
Mediana: 101 (ignora l'outlier)
Valore originale: ~100La Figura 3.23 presenta l’effetto del rumore sale e pepe a diverse densità. Il rumore è stato generato sostituendo casualmente una frazione dei pixel con valori minimi (0, pepe) e massimi (255, sale). All’aumentare della densità dal 2% al 10%, cresce la quantità di pixel corrotti, rendendo la degradazione visiva più evidente e ostacolando la percezione dei dettagli dell’immagine.
def add_salt_pepper(img, prob=0.05, seed=42):
"""Aggiunge rumore sale e pepe con probabilità totale prob."""
noisy = img.copy()
rnd = np.random.default_rng(seed).random(img.shape)
noisy[rnd < prob / 2] = 0 # pepe
noisy[rnd > 1 - prob / 2] = 255 # sale
n_corrompidos = int((rnd < prob/2).sum() + (rnd > 1-prob/2).sum())
return noisy, n_corrompidos
probs = [0.02, 0.05, 0.10]
imgs_noise, titles_noise = [img_gray_crop], ["Original"]
for p in probs:
noisy, n = add_salt_pepper(img_gray_crop, p)
imgs_noise.append(noisy)
titles_noise.append(f"Ruído {int(p*100)}%\n({n:,} pixels)")
mm.show(imgs_noise, titles=titles_noise, cols=4)
Il filtro della mediana sostituisce ogni pixel con il valore mediano dei pixel del suo intorno \(n \times n\):
\[ g(x,y) = \text{med}_{(s,t) \in \mathcal{V}_{n}} \{f(x+s, y+t)\} \tag{3.24}\]
Il valore mediano è quello che occupa la posizione centrale quando gli \(n^2\) valori dell’intorno vengono ordinati. Per una finestra \(3\times3\) (\(n^2=9\) pixel), la mediana è il 5° valore della sequenza ordinata.
Per illustrare, si consideri lo stesso patch 5×5 con un pixel corrotto artificialmente in \([1,1]\):
patch = img_gray[250:255, 250:255].copy()
corrompido = patch.copy()
corrompido[1, 1] = 255 # injeta pixel sal no centro
# Vizinhança 3×3 centrada em [1,1]
viz_orig = sorted(patch[0:3, 0:3].ravel().tolist())
viz_corr = sorted(corrompido[0:3, 0:3].ravel().tolist())
print("Patch originale:")
print(mm.drawImg(patch))
print("\nPatch con pixel corrotto [1,1]=255:")
print(mm.drawImg(corrompido))
print(f"\nVicinato 3×3 originale (ordinato): {viz_orig}")
print(f"Mediana originale: {viz_orig[4]}")
print(f"\nVicinato 3×3 corrotto (ordinato): {viz_corr}")
print(f"Mediana corrotta: {viz_corr[4]} ← ignora il 255")
print(f"Media corrotta: {np.mean(viz_corr):.1f} ← distorta dal 255")Patch originale:
91 95 108 116 114
106 107 108 111 114
102 103 107 112 116
83 90 111 125 123
79 88 110 126 124
Patch con pixel corrotto [1,1]=255:
91 95 108 116 114
106 255 108 111 114
102 103 107 112 116
83 90 111 125 123
79 88 110 126 124
Vicinato 3×3 originale (ordinato): [91, 95, 102, 103, 106, 107, 107, 108, 108]
Mediana originale: 106
Vicinato 3×3 corrotto (ordinato): [91, 95, 102, 103, 106, 107, 108, 108, 255]
Mediana corrotta: 106 ← ignora il 255
Media corrotta: 119.4 ← distorta dal 255L’esempio conferma: anche con il pixel corrotto a 255, la mediana restituisce il valore centrale corretto — il valore anomalo occupa l’ultima posizione nell’ordinamento e viene scartato naturalmente.
Poiché si basa sull’ordinamento e non sulla somma, la mediana possiede tre proprietà fondamentali che la differenziano dai filtri lineari:
mm.conv non si applica; si usa cv2.medianBlur.Figura 3.24 confronta diverse tecniche di rimozione del rumore sale e pepe applicate a un’immagine con il 10% dei pixel corrotti. Sono stati valutati i filtri Gaussiano, Media, Mediana, Bilaterale e Morfologico (prossimo capitolo), consentendo di osservare il compromesso tra rimozione del rumore e preservazione dei dettagli. In generale, i filtri di media e Gaussiano riducono il rumore, ma tendono a sfocare i bordi, mentre la mediana presenta prestazioni migliori per il rumore impulsivo. Il filtro bilaterale preserva meglio i bordi, e il filtro morfologico rimuove gran parte dei pixel corrotti senza degradare eccessivamente la struttura dell’immagine.
# 10% di rumore per evidenziare le differenze tra i filtri
noisy_5, _ = add_salt_pepper(img_gray_crop, prob=0.1)
# ── Filtri ───────────────────────────────────────────────────────────────────
f_gauss = cv2.GaussianBlur(noisy_5, (5, 5), 1.0)
f_media = mm.conv(noisy_5, np.ones((5, 5), dtype=np.float32) / 20.0)
f_median3 = cv2.medianBlur(noisy_5, 3)
f_median5 = cv2.medianBlur(noisy_5, 5)
f_bilat = cv2.bilateralFilter(noisy_5, d=9, sigmaColor=75, sigmaSpace=75)
# filtri morfologici nel prossimo capitolo, ma già anticipati qui per confronto
# B = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
# f_morf = cv2.morphologyEx( # presentato nel prossimo capitolo
# cv2.morphologyEx(noisy_5, cv2.MORPH_OPEN, B),
# cv2.MORPH_CLOSE, B)
B = mm.secross() # elemento strutturante di scatola 3×3
f_morf = mm.asf(noisy_5, 'OC', B) # equivalente tramite morph
# ── MSE ───────────────────────────────────────────────────────────────────────
def mse(a, b):
return float(np.mean((a.astype(np.float32) - b.astype(np.float32))**2))
print(f"{'Filtro':<22} {'MSE':>8}")
print("-" * 32)
pares = [("Gaussiano 5×5", f_gauss),
("Média 5×5", f_media),
("Mediana 3×3", f_median3),
("Mediana 5×5", f_median5),
("Bilateral", f_bilat),
("Morf. open+close", f_morf)]
for nome, img in pares:
print(f"{nome:<22} {mse(img_gray_crop, img):>8.2f}")
imgs = [img_gray_crop, noisy_5, f_gauss, f_media,
f_median3, f_median5, f_bilat, f_morf]
titles = ["Original", "Ruído 10%", "Gaussiano 5×5","Média 5×5",
"Mediana 3×3", "Mediana 5×5", "Bilateral", "Morf. open+close"]
mm.show(
imgs,
titles=[f"Crop: {t}" for t in titles],
cols=4, rows=2, figsize=(14, 8)
)Filtro MSE
--------------------------------
Gaussiano 5×5 260.84
Média 5×5 872.57
Mediana 3×3 31.26
Mediana 5×5 65.86
Bilateral 1001.22
Morf. open+close 65.16
Nella pratica, le tecniche di questo capitolo raramente vengono utilizzate singolarmente. Una pipeline di pre-elaborazione tipica combina più fasi in sequenza, adattandosi al tipo di immagine e all’applicazione. La Figura 3.25 illustra una pipeline completa:
L’ordine delle operazioni influisce sul risultato finale. In generale: (1) normalizzazione dell’intensità → (2) riduzione del rumore → (3) miglioramento/segmentazione. Invertire l’ordine può amplificare il rumore o perdere i bordi prima di rilevarli.
# Fase 1: CLAHE
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
img_clahe = clahe.apply(img_gray_crop)
# Fase 2: Gaussiano
img_gauss = cv2.GaussianBlur(img_clahe, (5, 5), 0)
# Fase 3: Canny
edges = cv2.Canny(img_gauss, 50, 150)
# Confronto: pipeline vs. Canny diretto
edges_direct = cv2.Canny(img_gray_crop, 50, 150)
mm.show(
[img_gray_crop, img_clahe, img_gauss, edges, edges_direct],
titles=["Originale", "1. CLAHE", "2. Gaussiano", "3. Canny (pipeline)", "Canny (diretto)"],
cols=5
)
In questo capitolo sono state presentate le principali tecniche di elaborazione nel dominio spaziale, dalla manipolazione diretta dei pixel fino al filtraggio per vicinato:
mm.addm, mm.subm) e logiche bit a bit (mm.band, mm.bor, mm.bnot) per il ritaglio di ROI e la combinazione di immagini; alpha blending (mm.blend) per la fusione pesata con peso \(\alpha \in [0,1]\).mm.histImg e calcolato con mm.hist; base per la diagnosi tonale e per le tecniche di equalizzazione e specificazione.mm.equalize), con variante adattativa CLAHE per il controllo locale del contrasto.mm.conv (cv2.filter2D); differenziati dalla rotazione di 180° del kernel — rilevante solo per kernel asimmetrici.mm.drawImgKernel per la visualizzazione didattica della finestra scorrevole.Il Capitolo 4 tratterà la morfologia matematica (erosione, dilatazione, apertura e chiusura), esplorando in profondità le funzioni mm.ero e mm.dil della libreria morph.py. Successivamente, il Capitolo 5 presenterà l’elaborazione nel dominio della frequenza, con focus sulla Trasformata di Fourier e sulle tecniche di filtraggio spettrale.
In questa edizione, incoraggiamo l’uso di Gemini Notebook come strumento complementare di apprendimento. Questo strumento di IA utilizza esclusivamente i documenti forniti dall’autore come base di conoscenza, garantendo risposte coerenti con il contenuto del libro — incluse le funzioni della libreria morph.py e gli esperimenti realizzati in questo capitolo.
Per ogni capitolo, abbiamo preparato un progetto specifico sulla piattaforma con il PDF del capitolo, i notebook e i materiali ausiliari. Suggeriamo di esplorare in particolare:
(10%) Spiegare la differenza tra convoluzione e correlazione incrociata. Per quali tipi di kernel i risultati sono identici? Fornire un esempio di kernel asimmetrico (come Sobel \(G_x\)) e mostrare numericamente che i risultati differiscono applicandolo al patch 5×5 del capitolo in entrambi i modi.
(15%) Considerare un’immagine 5×5 con intensità concentrate tra i livelli 3 e 5 (basso contrasto, 3 bit). Applicare manualmente l’algoritmo di equalizzazione della Tabella 3.1, completando tutte le colonne della tabella (\(k\), \(h[k]\), \(p[k]\), \(\text{cdf}[k]\), \(\text{lut}[k]\)). Verificare il risultato con mm.equalize.
(15%) Utilizzando mm.conv, applicare il filtro media con kernel di dimensione 3×3, 9×9 e 21×21 all’immagine del mandrillo. Per ciascuna versione, calcolare il PSNR (Peak Signal-to-Noise Ratio) rispetto all’originale: \[\text{PSNR} = 10\log_{10}\!\left(\frac{255^2}{\text{MSE}}\right), \quad \text{MSE} = \frac{1}{MN}\sum_{i,j}(f-g)^2\] Tracciare il PSNR in funzione della dimensione del kernel e spiegare cosa indica la diminuzione progressiva riguardo alla relazione tra smoothing e perdita di informazione.
(15%) Utilizzando add_salt_pepper con densità del 5%, applicare e confrontare: (a) mm.conv con media 3×3, (b) cv2.GaussianBlur con \(\sigma=1\), (c) cv2.medianBlur con finestra 3×3 e (d) cv2.medianBlur con finestra 5×5. Visualizzare le immagini con mm.show in una griglia 2×4 (riga 1: immagini, riga 2: istogrammi tramite mm.histImg). Spiegare perché la mediana supera i filtri lineari utilizzando l’argomento della Tabella 3.4..
(15%) Implementare mm.conv0 utilizzando solo operazioni NumPy vettorizzate — senza cicli Python e senza cv2.filter2D — con l’operatore di stride tricks (np.lib.stride_tricks.sliding_window_view). Confrontare il risultato e il tempo di esecuzione con mm.conv0 (cicli) e mm.conv (cv2) per kernel 3×3 e 15×15 sull’immagine del mandrillo.
(15%) Applicare l’Unsharp Masking con \(\sigma=1\) e \(k \in \{0.5, 1.0, 2.0, 4.0\}\) utilizzando la funzione usm del capitolo. Per ciascun valore di \(k\): (a) calcolare la differenza assoluta \(|g - f|\), (b) visualizzare le immagini e le differenze con mm.show, e (c) tracciare l’istogramma delle differenze con mm.histImg. Identificare a partire da quale \(k\) gli artefatti (aloni e amplificazione del rumore) diventano visivamente inaccettabili.
(15%) Scegliere un’immagine radiografica o tomografica disponibile pubblicamente (es.: tramite mm.read da URL) e progettare una pipeline di pre-elaborazione con almeno 4 fasi sequenziali, giustificando ogni scelta sulla base dei concetti del capitolo. Visualizzare con mm.show in griglia: l’immagine originale, ogni fase intermedia e il risultato finale con i rispettivi istogrammi (mm.histImg).
La base teorica di questo capitolo si fonda sulle seguenti opere:
morph.py.
Il quaderno consente di sviluppare, validare, organizzare e testare soluzioni di Esercizi di Programmazione (EP) in ambienti interattivi, come Colab, con gli stessi casi di test di Moodle, copiandoli lì solo al momento di registrare il voto ufficiale.
Scarica morph.py e testsuite.py eseguendo la cella qui sotto:
import os, urllib.request
url = "https://raw.githubusercontent.com/fzampirolli/pdi-vc/master/morph/config.py"
if not os.path.exists("config.py"):
urllib.request.urlretrieve(url, "config.py")
import config
config.setup(testsuite=True)
from morph import mm
from testsuite import TestSuite✅ Ambiente pronto. Morph: 1.1.9 | OpenCV: 5.0.0 | TestSuite: 1.1.2Per valutare i test, eseguire TestSuite("EP03_01.extensão").run() in una nuova cella, sostituendo l’estensione con quella del linguaggio utilizzato (.py, .java, .c, .cpp, .js o .r). Il sistema scarica i casi di test da GitHub, esegue il programma e calcola automaticamente il voto.
Per testare direttamente codice Python, senza salvare file, utilizzare run_code(codigo) passando il codice come stringa in una variabile codigo:
codigo = """
from morph import mm
# ... il tuo codice qui ...
"""
TestSuite("EP03_01").run_code(codigo)Nei sistemi di videosorveglianza, le telecamere in ambienti con illuminazione variabile producono immagini sottoesposte. La regolazione della luminosità mediante addizione saturata di una costante è l’operazione più semplice per una correzione immediata, applicata in tempo reale sui chip delle telecamere integrate e nelle pipeline di pre-elaborazione dei robot mobili.
Vedi in Figura 3.26 una simulazione di questo EP.
\[p' = \text{clip}(p + k)\]
| Parametro | Tipo | Impatto Visivo |
|---|---|---|
| \(k > 0\) | Intero | Schiarisce l’immagine; i pixel vicini a 255 saturano in bianco |
| \(k < 0\) | Intero | Scurisce l’immagine; i pixel vicini a 0 saturano in nero |
| \(k = 0\) | Intero | Immagine invariata |
Input:
Output:
| Input | Output | Osservazione |
|---|---|---|
| 2 3 50 0 100 200 210 240 255 |
50 150 250 255 255 255 |
Saturazione a 255 nei pixel alti |
| 1 4 -30 0 20 200 255 |
0 0 170 225 | Saturazione a 0 nei pixel bassi |
Regola il valore della costante k per osservare lo spostamento di luminosità dell'immagine e il troncamento per saturazione nell'intervallo [0, 255].
%%writefile EP03_01.py
# Codice PythonOverwriting EP03_01.pyTestSuite("EP03_01.py").run()✔️ EP03_01.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_01.cases
🔍 Test di Python: EP03_01.py
⚠️ EP03_01.py: file vuoto (meno di 3 righe). Test saltati.
In medicina nucleare, immagini di diverse modalità (tomografia computerizzata e risonanza magnetica) vengono fuse per supportare la diagnosi. La miscela ponderata (alpha blending) è l’operazione fondamentale di questo processo, consentendo al radiologo di controllare interattivamente il peso di ciascuna modalità nell’immagine visualizzata.
Vedi in Figura 3.27 una simulazione di questo EP.
\[g(i,j) = \text{clip}\left(\text{round}\left(\alpha \cdot f_1(i,j) + (1-\alpha) \cdot f_2(i,j)\right)\right)\]
round prima della conversione a intero.| Valore di \(\alpha\) | Risultato |
|---|---|
| \(\alpha = 1.0\) | Solo \(f_1\) |
| \(\alpha = 0.5\) | Media aritmetica di \(f_1\) e \(f_2\) |
| \(\alpha = 0.0\) | Solo \(f_2\) |
Input:
Output:
| Input | Output | Osservazione |
|---|---|---|
| 1 3 0.5 0 100 200 100 200 50 |
50 150 125 | Media tra le due immagini |
| 1 3 1.0 10 20 30 90 80 70 |
10 20 30 | Solo \(f_1\) (alpha=1) |
Regola il parametro di trasparenza α per osservare la combinazione lineare ponderata pixel per pixel tra le immagini f1 e f2.
%%writefile EP03_02.py
# Codice PythonOverwriting EP03_02.pyTestSuite("EP03_02.py").run()✔️ EP03_02.cases esiste già in casos/
📋 6 caso/i caricato/i da casos/EP03_02.cases
🔍 Test di Python: EP03_02.py
⚠️ EP03_02.py: file vuoto (meno di 3 righe). Test saltati.
In radiologia, le immagini ai raggi X sono tradizionalmente visualizzate in negativo: le ossa appaiono in nero su sfondo bianco. L’operazione di negativo fotografico viene applicata di routine nei PACS (Picture Archiving and Communication Systems) per facilitare la rilevazione di fratture e densità ossee.
Vedere nella Figura 3.28 una simulazione di questo EP.
\[p' = 255 - p\]
NOT bit a bit (mm.bnot) su immagini a 8 bit.| Pixel Originale \(p\) | Pixel Negativo \(p'\) | Osservazione |
|---|---|---|
| 0 (nero) | 255 (bianco) | Inversione totale |
| 128 (grigio medio) | 127 (grigio medio) | Valore centrale |
| 255 (bianco) | 0 (nero) | Inversione totale |
Input:
Output:
| Input | Output | Osservazione |
|---|---|---|
| 1 4 0 128 200 255 |
255 127 55 0 | Inversione di ogni pixel |
| 2 2 10 20 30 40 |
245 235 225 215 |
Matrice 2x2 invertita |
Osserva l'inversione complementare di intensità: i toni scuri diventano chiari e i toni chiari diventano scuri sottraendo ogni pixel dal valore massimo di 255.
%%writefile EP03_03.py
# Codice PythonOverwriting EP03_03.pyTestSuite("EP03_03.py").run()✔️ EP03_03.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_03.cases
🔍 Test di Python: EP03_03.py
⚠️ EP03_03.py: file vuoto (meno di 3 righe). Test saltati.
Nelle immagini satellitari di telerilevamento, la variazione dell’illuminazione durante il giorno produce immagini a basso contrasto. L’equalizzazione dell’istogramma viene applicata automaticamente su satelliti come il Landsat per redistribuire i toni, rivelando dettagli di vegetazione, rilievo e aree urbane invisibili nell’immagine originale.
Vedere in Figura 3.29 una simulazione di questo EP.
round) nella LUT.| Fase | Operazione | Formula |
|---|---|---|
| 1 | Istogramma | \(h[k] \leftarrow\) n. pixel con intensità \(k\) |
| 2 | Probabilità | \(p[k] = h[k] / (L \cdot C)\) |
| 3 | CDF | \(\text{cdf}[k] = \sum_{j=0}^{k} p[j]\) |
| 4 | LUT | \(\text{lut}[k] = \text{round}(\text{cdf}[k] \cdot (2^B-1))\) |
| 5 | Applicazione | \(g[i,j] = \text{lut}[f[i,j]]\) |
Input:
Output:
| Input | Output | Osservazione |
|---|---|---|
| 5 5 3 3 4 2 3 4 4 3 3 4 3 2 3 4 3 2 3 4 3 2 3 4 3 2 3 4 |
5 7 1 5 7 7 5 5 7 5 1 5 7 5 1 5 7 5 1 5 7 5 1 5 7 |
Esempio a 3 bit del capitolo |
| 1 4 3 0 0 7 7 |
0 0 7 7 | Istogramma bimodale estremo |
Scegli la profondità di bit (B) e genera immagini per analizzare la distribuzione dinamica dell'istogramma e la tabella di rimappatura (LUT) in tempo reale.
%%writefile EP03_04.py
# Codice PythonOverwriting EP03_04.pyTestSuite("EP03_04.py").run()✔️ EP03_04.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_04.cases
🔍 Test di Python: EP03_04.py
⚠️ EP03_04.py: file vuoto (meno di 3 righe). Test saltati.
Nei sistemi di ispezione industriale tramite visione artificiale, è necessario isolare le regioni di interesse (ROI) nelle immagini dei pezzi per verificare difetti di fabbricazione. L’operazione AND bit a bit con una maschera binaria è il meccanismo fondamentale per ritagliare esattamente l’area di ispezione, azzerando tutti i pixel al di fuori di essa.
Vedi in Figura 3.30 una simulazione di questo EP.
\[ g(i,j) = f(i,j) \;\text{AND}\; m(i,j) \]
dove \(255 =\) 11111111 e \(0 =\) 00000000 in binario.
&.| Pixel \(f\) | Maschera \(m\) | Risultato \(f\) AND \(m\) |
|---|---|---|
| qualsiasi \(v\) | 255 (11111111) |
\(v\) (preservato) |
| qualsiasi \(v\) | 0 (00000000) |
0 (azzerato) |
Input:
Output:
| Input | Output | Osservazione |
|---|---|---|
| 2 3 100 150 200 50 80 120 255 255 0 0 255 255 |
100 150 0 0 80 120 |
La maschera seleziona la regione |
| 1 4 10 20 30 40 255 0 255 0 |
10 0 30 0 | Alternato preservato/azzerato |
Fai clic sulle celle della Maschera m per alternare tra passante (255) e bloccante (0), applicando l'operazione logica pixel per pixel.
%%writefile EP03_05.py
# Codice PythonOverwriting EP03_05.pyTestSuite("EP03_05.py").run()✔️ EP03_05.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_05.cases
🔍 Test di Python: EP03_05.py
⚠️ EP03_05.py: file vuoto (meno di 3 righe). Test saltati.
Nelle telecamere dei veicoli autonomi, le immagini acquisite sotto pioggia o nebbia presentano rumore gaussiano. Il filtro di media è ampiamente utilizzato per la sua riduzione in tempo reale, essendo implementato direttamente nell’ISP (Image Signal Processor) dei sensori CMOS (Complementary Metal-Oxide-Semiconductor).
I sensori CMOS sono i sensori di immagine utilizzati nella maggior parte delle fotocamere moderne (smartphone, webcam, fotocamere automobilistiche, ecc.). Essi convertono la luce in segnali elettrici, e l’ISP elabora questi segnali in tempo reale — applicando operazioni come la riduzione del rumore, il bilanciamento del bianco e altre regolazioni dell’immagine.
Vedere in Figura 3.31 una simulazione di questo EP.
\[g(i,j) = \text{round}\left(\frac{1}{N^2} \sum_{s=-(r)}^{r} \sum_{t=-(r)}^{r} f(i+s,\, j+t)\right), \quad r = \lfloor N/2 \rfloor\]
| Dimensione \(N\) | Coefficiente | Pixel nella finestra | Effetto |
|---|---|---|---|
| 3 | \(1/9 \approx 0.111\) | 9 | Morbido |
| 5 | \(1/25 = 0.04\) | 25 | Medio |
| 7 | \(1/49 \approx 0.020\) | 49 | Forte |
Input:
Output:
| Input | Output | Osservazione |
|---|---|---|
| 3 3 3 10 20 30 40 50 60 70 80 90 |
10 20 30 40 50 60 70 80 90 |
Solo bordo (3×3 = bordo totale) |
| 5 5 3 0 0 0 0 0 0 0 0 0 0 0 0 100 0 0 0 0 0 0 0 0 0 0 0 0 |
0 0 0 0 0 0 11 11 11 0 0 11 11 11 0 0 11 11 11 0 0 0 0 0 0 |
Pixel isolato: tutti i 9 pixel interni la cui finestra 3×3 include il valore 100 ricevono round(100/9)=11 |
Seleziona la dimensione del kernel e passa il mouse sui pixel del risultato per ispezionare il vicinato e il calcolo della media aritmetica.
%%writefile EP03_06.py
# Codice PythonOverwriting EP03_06.pyTestSuite("EP03_06.py").run()✔️ EP03_06.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_06.cases
🔍 Test di Python: EP03_06.py
⚠️ EP03_06.py: file vuoto (meno di 3 righe). Test saltati.
Nelle tomografie ad alta risoluzione, la nitidezza dei bordi tra i tessuti è critica per la diagnosi. L’operatore Laplaciano è ampiamente utilizzato nei pipeline di pre-elaborazione delle immagini mediche per enfatizzare automaticamente i contorni anatomici prima della segmentazione, evitando l’intervento manuale del radiologo.
Vedi in Figura 3.32 una simulazione di questo EP.
\[\nabla^2 f(i,j) = f(i-1,j) + f(i+1,j) + f(i,j-1) + f(i,j+1) - 4 \cdot f(i,j)\]
\[g(i,j) = \text{clip}(f(i,j) - \nabla^2 f(i,j))\]
| Regione | \(\nabla^2 f\) | Effetto dell’Enfatizzazione |
|---|---|---|
| Uniforme | \(\approx 0\) | Nessuna modifica |
| Bordo crescente | \(< 0\) | Pixel schiarito |
| Bordo decrescente | \(> 0\) | Pixel scurito |
Ingresso:
Uscita:
| Ingresso | Uscita | Osservazione |
|---|---|---|
| 3 3 0 0 0 0 100 0 0 0 0 |
0 0 0 0 255 0 0 0 0 |
Picco isolato: lap=−400, g=100−(−400)=500 → clip=255 |
| 3 3 50 50 50 50 50 50 50 50 50 |
50 50 50 50 50 50 50 50 50 |
Regione uniforme: Laplaciano=0, nessuna modifica |
Seleziona la variante di evidenziazione e passa il mouse sui pixel interni del risultato per ispezionare l'intorno di 4 punti e l'equazione del Laplaciano.
%%writefile EP03_07.py
# Codice PythonOverwriting EP03_07.pyTestSuite("EP03_07.py").run()✔️ EP03_07.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_07.cases
🔍 Test di Python: EP03_07.py
⚠️ EP03_07.py: file vuoto (meno di 3 righe). Test saltati.
Nei robot esploratori di Marte (come il Perseverance), il rilevamento degli ostacoli viene eseguito in tempo reale da telecamere stereoscopiche. L’operatore di Sobel calcola il gradiente direzionale della scena e viene utilizzato nell’algoritmo di rilevamento dei bordi per identificare rocce, crepe e dislivelli del terreno che potrebbero compromettere la navigazione.
Vedi in Figura 3.33 una simulazione di questo EP.
\[G_x(i,j) = [f(i-1,j+1) + 2f(i,j+1) + f(i+1,j+1)] - [f(i-1,j-1) + 2f(i,j-1) + f(i+1,j-1)]\]
\[G_y(i,j) = [f(i+1,j-1) + 2f(i+1,j) + f(i+1,j+1)] - [f(i-1,j-1) + 2f(i-1,j) + f(i-1,j+1)]\]
round prima di convertire in intero.| Operatore | Rileva | Coefficienti diagonali |
|---|---|---|
| \(G_x\) | Bordi verticali | \(\pm 1\) |
| \(G_y\) | Bordi orizzontali | \(\pm 1\) |
| \(|\nabla f|\) | Tutti i bordi | Combinato |
Input:
Output:
| Input | Output | Osservazione |
|---|---|---|
| 3 3 0 0 0 0 0 0 0 0 0 |
0 0 0 0 0 0 0 0 0 |
Immagine nulla: gradiente zero |
| 3 3 0 0 255 0 0 255 0 0 255 |
0 0 0 0 255 0 0 0 0 |
Bordo verticale centrale: Gx alto |
Analizza la scomposizione orizzontale (Gx) e verticale (Gy) dell'operatore di Sobel e passa il mouse sui pixel della magnitudine per ispezionare l'intorno 3×3.
%%writefile EP03_08.py
# Codice PythonOverwriting EP03_08.pyTestSuite("EP03_08.py").run()✔️ EP03_08.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_08.cases
🔍 Test di Python: EP03_08.py
⚠️ EP03_08.py: file vuoto (meno di 3 righe). Test saltati.
Le immagini radar ad apertura sintetica (SAR) utilizzate nel monitoraggio ambientale e militare sono soggette a un tipo specifico di rumore chiamato speckle, che presenta caratteristiche simili al rumore sale e pepe. Il filtro della mediana è il metodo standard per la rimozione di tale rumore perché preserva i bordi delle strutture eliminando al contempo i punti spuri.
Vedere in Figura 3.34 una simulazione di questo EP.
\[g(i,j) = \text{mediana}\{f(i+s, j+t) : s,t \in \{-1,0,1\}\}\]
| Rumore | Filtro della Media | Filtro della Mediana |
|---|---|---|
| Sale e pepe (0 o 255) | Diffonde il rumore | Rimuove senza distorcere i bordi |
| Gaussiano | Riduce efficacemente | Riduce parzialmente |
Ingresso:
Uscita:
| Ingresso | Uscita | Osservazione |
|---|---|---|
| 3 3 100 100 100 100 0 100 100 100 100 |
100 100 100 100 100 100 100 100 100 |
Punto nero eliminato: mediana di 8×100+1×0 = 100 |
| 3 3 50 50 50 50 255 50 50 50 50 |
50 50 50 50 50 50 50 50 50 |
Punto bianco (sale) eliminato |
Inietta rumore impulsivo (sale e pepe) e passa il mouse sui pixel interni del risultato per ispezionare l'ordinamento del vettore di vicinanza e l'eliminazione del rumore.
%%writefile EP03_09.py
# Codice PythonOverwriting EP03_09.pyTestSuite("EP03_09.py").run()✔️ EP03_09.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_09.cases
🔍 Test di Python: EP03_09.py
⚠️ EP03_09.py: file vuoto (meno di 3 righe). Test saltati.
Nei sistemi di digitalizzazione di documenti storici e opere d’arte, la nitidezza delle immagini è fondamentale per la lettura di testi manoscritti e dettagli ornamentali. Lo Unsharp Masking (USM) è l’algoritmo di miglioramento della nitidezza standard utilizzato negli scanner professionali e in software come Adobe Photoshop, controllato dal parametro \(k\) che determina l’intensità del miglioramento.
Vedi in Figura 3.35 una simulazione di questo EP.
\[\bar{f}(i,j) = \frac{1}{9} \sum_{s=-1}^{1} \sum_{t=-1}^{1} f(i+s, j+t)\]
\[g(i,j) = \text{clip}\left(\text{round}\left(f(i,j) + k \cdot m(i,j)\right)\right)\]
round prima del clipping.| Fase | Operazione | Descrizione |
|---|---|---|
| 1 | \(\bar{f} = f * \frac{1}{9}\mathbf{1}_{3\times3}\) | Smussamento (basse frequenze) |
| 2 | \(m = f - \bar{f}\) | Maschera (alte frequenze) |
| 3 | \(g = \text{clip}(\text{round}(f + k \cdot m))\) | Miglioramento ponderato |
Input:
Output:
| Input | Output | Osservazione |
|---|---|---|
| 3 3 0.0 100 100 100 100 100 100 100 100 100 |
100 100 100 100 100 100 100 100 100 |
k=0: nessun miglioramento |
| 3 3 1.0 50 50 50 50 200 50 50 50 50 |
50 50 50 50 255 50 50 50 50 |
k=1: pixel centrale migliorato e saturato |
Regola il fattore di guadagno k, osserva l'intero pipeline di miglioramento (sfocatura, maschera ad alta frequenza) e passa il mouse sul risultato.
%%writefile EP03_10.py
# Codice PythonOverwriting EP03_10.pyTestSuite("EP03_10.py").run()✔️ EP03_10.cases esiste già in casos/
📋 5 caso/i caricato/i da casos/EP03_10.cases
🔍 Test di Python: EP03_10.py
⚠️ EP03_10.py: file vuoto (meno di 3 righe). Test saltati.