Frame Interpolation

L'interpolazione dei fotogrammi, detta anche interpolazione dei fotogrammi video (VFI), è il compito di visione artificiale che consiste nel sintetizzare nuovi fotogrammi tra due fotogrammi esistenti di un video. Inserire un fotogramma tra ogni coppia raddoppia la frequenza dei fotogrammi, portando un filmato a 30 FPS a 60 FPS; inserirne diversi crea l'effetto rallentatore a partire da un filmato normale. Aumenta la risoluzione temporale del video, l'equivalente nel tempo della super-risoluzione, e riempie solo gli intervalli tra fotogrammi esistenti, a differenza della previsione video, che estrapola i fotogrammi successivi all'ultimo.

Come funziona l'interpolazione dei fotogrammi#

Fare la media di due fotogrammi produce immagini fantasma, ovvero una doppia immagine di tutto ciò che si è mosso. I metodi basati sul flusso stimano invece il flusso ottico, cioè il movimento di ogni pixel tra i due fotogrammi, spostano ogni fotogramma lungo quel movimento fino al tempo desiderato e fondono i due risultati. Le occlusioni sono la parte difficile: una regione di sfondo scoperta da una persona che cammina esiste in un solo fotogramma, quindi i modelli di deep learning, come Super SloMo, prevedono anche mappe di visibilità che determinano da quale fotogramma proviene ciascun pixel in uscita.

Il flusso ottico di Farneback di OpenCV basta a mostrare l'effetto su filmati reali. Lo snippet esclude il fotogramma centrale di una sequenza di tre, lo ricostruisce a partire dai fotogrammi adiacenti e valuta entrambi i metodi con il rapporto picco/rumore (PSNR):

import cv2
import numpy as np

# Read three consecutive frames of people walking and hold out the middle one
cap = cv2.VideoCapture("https://github.com/ultralytics/assets/releases/download/v0.0.0/decelera_portrait_min.mov")
f0, f1, f2 = (cap.read()[1] for _ in range(3))
g0, g2 = (cv2.cvtColor(f, cv2.COLOR_BGR2GRAY) for f in (f0, f2))

# Estimate dense optical flow in both directions between the outer frames
flow02 = cv2.calcOpticalFlowFarneback(g0, g2, None, 0.5, 3, 15, 3, 5, 1.2, 0)
flow20 = cv2.calcOpticalFlowFarneback(g2, g0, None, 0.5, 3, 15, 3, 5, 1.2, 0)

# Warp each outer frame halfway along its flow, then average the two warps
h, w = g0.shape
grid = np.dstack(np.meshgrid(np.arange(w), np.arange(h))).astype(np.float32)
warp0 = cv2.remap(f0, grid - 0.5 * flow02, None, cv2.INTER_LINEAR)
warp2 = cv2.remap(f2, grid - 0.5 * flow20, None, cv2.INTER_LINEAR)
middle = cv2.addWeighted(warp0, 0.5, warp2, 0.5, 0)

# Score both against the real middle frame: flow interpolation vs. plain blending
blend = cv2.addWeighted(f0, 0.5, f2, 0.5, 0)
print(f"Blend: {cv2.PSNR(blend, f1):.1f} dB, flow interpolation: {cv2.PSNR(middle, f1):.1f} dB")

Stampa Blend: 22.3 dB, flow interpolation: 29.5 dB: spostare ogni fotogramma a metà del suo movimento ricostruisce il fotogramma escluso con una precisione superiore di 7,2 dB rispetto alla media. I benchmark valutano i modelli allo stesso modo: il set di triplette Vimeo-90K contiene 73.171 clip di tre fotogrammi, in cui un modello deve prevedere il fotogramma centrale; la valutazione usa PSNR e SSIM.

Metodi di interpolazione appresi#

• Reti basate sul flusso: Super SloMo (2018) prevede il flusso e la visibilità per qualsiasi istante tra due fotogrammi, mentre RIFE (2022) stima direttamente il flusso all'istante intermedio ed è da 4 a 27 volte più veloce di Super SloMo e DAIN.
• Reti basate su kernel: SepConv (2017) prevede kernel di convoluzione separabili per ogni pixel in uscita e li applica alle patch dei due fotogrammi in ingresso, combinando in un solo passaggio la stima del movimento e la fusione.
• Modelli per movimenti ampi: FILM di Google (2022) condivide i pesi tra le scale di una piramide di feature, così un movimento ampio a una scala fine viene gestito come i piccoli movimenti appresi alle scale più grossolane; inoltre, si addestra solo con triplette di fotogrammi.
• Modelli generativi: Gli interpolatori basati sulla diffusione, come LDMVFI (2024), generano il fotogramma centrale denoising una rappresentazione latente condizionata dai due input, invece di deformarne i pixel.
• Interpolazione basata su eventi: Time Lens (2021) aggiunge le variazioni di luminosità registrate da una telecamera a eventi tra due fotogrammi, che rivelano il movimento reale durante l'intervallo.

Applicazioni nel mondo reale#

• Generazione di fotogrammi nei videogiochi: NVIDIA DLSS Multi Frame Generation inserisce fino a cinque fotogrammi generati per ogni fotogramma renderizzato sulle GPU GeForce RTX 50 Series; ogni fotogramma generato richiede il successivo fotogramma renderizzato, il che aggiunge latenza.
• Montaggio video: I programmi di montaggio creano il rallentatore a partire da filmati standard e convertono video a 24 o 30 FPS per schermi a 60 Hz e 120 Hz; è la stessa interpolazione del movimento applicata dai televisori per rendere il movimento più fluido.
• Animazione: I modelli di interpolazione generano disegni intermedi tra i fotogrammi chiave disegnati a mano, mentre i generatori video possono creare intere clip che iniziano e terminano con due fotogrammi specificati.

Il tracking degli oggetti applica la stessa idea alle posizioni anziché ai pixel. Quando un oggetto, rimasto nascosto per diversi fotogrammi, riappare, il tracker OC-SORT nella modalità di tracking di Ultralytics (tracker="ocsort.yaml") interpola linearmente le bounding box virtuali per i fotogrammi mancanti e le rielabora con il suo filtro di Kalman, correggendo la stima della velocità che usa per abbinare l'oggetto al successivo rilevamento di YOLO26.