Frame Interpolation

L’interpolation d’images, également appelée interpolation d’images vidéo (VFI), est la tâche de vision par ordinateur qui consiste à synthétiser de nouvelles images entre deux images existantes d’une vidéo. Insérer une image entre chaque paire double la fréquence d’images, faisant passer une vidéo de 30 FPS à 60 FPS, et en insérer plusieurs crée un effet de ralenti à partir d’une vidéo ordinaire. Elle augmente la résolution temporelle d’une vidéo, l’équivalent temporel de la super-résolution, et se contente de combler les intervalles entre les images existantes, contrairement à la prédiction vidéo, qui extrapole des images après la dernière.

Fonctionnement de l’interpolation d’images#

Faire la moyenne de deux images produit un effet fantôme, une double image de tout ce qui a bougé. Les méthodes fondées sur le flux estiment plutôt le flux optique, c’est-à-dire le mouvement de chaque pixel entre les deux images, déplacent chaque image d’une partie de ce mouvement jusqu’au temps cible, puis mélangent les deux résultats. Les occultations posent problème : une région d’arrière-plan découverte par une personne qui marche n’existe que dans l’une des deux images ; les modèles d’apprentissage profond, comme Super SloMo, prédisent donc également des cartes de visibilité qui déterminent de quelle image provient chaque pixel de sortie.

Le flux optique de Farneback d’OpenCV suffit à montrer l’effet sur une séquence réelle. Cet extrait met de côté l’image centrale de trois images, la reconstruit à partir de ses voisines et évalue les deux méthodes à l’aide du rapport signal/bruit de crête (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")

Il affiche Blend: 22.3 dB, flow interpolation: 29.5 dB : déplacer chaque image à mi-chemin le long de son mouvement reconstruit l’image mise de côté avec une précision supérieure de 7,2 dB à celle de la moyenne. Les benchmarks évaluent les modèles de la même manière : l’ensemble de triplets Vimeo-90K contient 73 171 séquences de trois images dont le modèle doit prédire l’image centrale, avec une mesure par PSNR et SSIM.

Méthodes d’interpolation apprises#

• Réseaux fondés sur le flux : Super SloMo (2018) prédit le flux et la visibilité à tout instant entre deux images ; RIFE (2022) estime directement le flux à l’instant intermédiaire et s’exécute 4 à 27 fois plus vite que Super SloMo et DAIN.
• Réseaux fondés sur des noyaux : SepConv (2017) prédit des noyaux de convolution séparables pour chaque pixel de sortie et les applique aux patches des deux images d’entrée, combinant estimation du mouvement et fusion en une étape.
• Modèles de grands mouvements : FILM de Google (2022) partage les poids entre les échelles d’une pyramide de caractéristiques ; un grand mouvement à une échelle fine est ainsi traité comme les petits mouvements appris aux échelles plus grossières, et l’entraînement se fait uniquement à partir de triplets d’images.
• Modèles génératifs : Les modèles d’interpolation fondés sur la diffusion, comme LDMVFI (2024), génèrent l’image centrale en débruitant une représentation latente conditionnée par les deux entrées, plutôt qu’en déformant leurs pixels.
• Interpolation fondée sur les événements : Time Lens (2021) ajoute les variations de luminosité enregistrées par une caméra événementielle entre deux images, qui révèlent le mouvement réel pendant l’intervalle.

Applications concrètes#

• Génération d’images pour les jeux : NVIDIA DLSS Multi Frame Generation insère jusqu’à cinq images générées pour chaque image rendue sur les GPU GeForce RTX 50 Series ; chaque image générée nécessite l’image rendue suivante, ce qui ajoute de la latence.
• Montage vidéo : Les logiciels de montage créent des ralentis à partir de séquences standard et convertissent les vidéos de 24 ou 30 FPS pour les écrans 60 Hz et 120 Hz ; il s’agit de la même interpolation de mouvement que celle appliquée par les téléviseurs pour lisser les mouvements.
• Animation : Les modèles d’interpolation génèrent les dessins intermédiaires entre des images clés dessinées à la main, et les générateurs vidéo peuvent produire des séquences entières commençant et se terminant sur deux images données.

Le suivi d’objets applique la même idée aux positions plutôt qu’aux pixels. Lorsqu’un objet réapparaît après avoir été masqué pendant plusieurs images, le suivi OC-SORT en mode suivi d’Ultralytics (tracker="ocsort.yaml") interpole linéairement des boîtes virtuelles pour les images manquées et les fait repasser par son filtre de Kalman, corrigeant ainsi l’estimation de vitesse utilisée pour associer l’objet à la détection YOLO26 suivante.