Frame Interpolation

A interpolação de quadros, também chamada de interpolação de quadros de vídeo (VFI), é a tarefa de visão computacional que sintetiza novos quadros entre dois quadros existentes de um vídeo. Inserir um quadro entre cada par duplica a taxa de quadros, transformando uma filmagem de 30 FPS em 60 FPS, e inserir vários cria câmera lenta a partir de filmagens comuns. Isso aumenta a resolução temporal de um vídeo, o equivalente no tempo à super-resolução, e preenche apenas lacunas entre quadros existentes, ao contrário da previsão de vídeo, que extrapola quadros após o último.

Como funciona a interpolação de quadros#

Tirar a média de dois quadros causa efeito fantasma: uma imagem dupla de tudo o que se moveu. Em vez disso, os métodos baseados em fluxo estimam o fluxo óptico, ou seja, o movimento de cada pixel entre os dois quadros, deslocam cada quadro parcialmente ao longo desse movimento até o instante pretendido e combinam os dois resultados. As oclusões são a parte mais difícil: uma região do fundo revelada por uma pessoa caminhando existe em apenas um dos quadros, por isso modelos de aprendizado profundo, como o Super SloMo, também preveem mapas de visibilidade que determinam de qual quadro vem cada pixel da saída.

O fluxo óptico de Farneback do OpenCV é suficiente para demonstrar o efeito em filmagens reais. O trecho separa o quadro central de três quadros e o reconstrói a partir dos vizinhos, comparando os dois métodos pela relação sinal-ruído de pico (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")

Ele imprime Blend: 22.3 dB, flow interpolation: 29.5 dB: deslocar cada quadro até a metade do seu movimento reconstrói o quadro separado com uma precisão 7,2 dB maior do que a média. Os benchmarks avaliam os modelos da mesma forma: o conjunto de trios Vimeo-90K contém 73.171 clipes de três quadros cujo quadro central o modelo precisa prever, com a avaliação feita por PSNR e SSIM.

Métodos de interpolação aprendidos#

• Redes baseadas em fluxo: O Super SloMo (2018) prevê o fluxo e a visibilidade para qualquer instante entre dois quadros, enquanto o RIFE (2022) estima diretamente o fluxo no instante intermediário, funcionando de 4 a 27 vezes mais rápido que o Super SloMo e o DAIN.
• Redes baseadas em kernels: O SepConv (2017) prevê kernels de convolução separáveis para cada pixel de saída e os aplica a recortes dos dois quadros de entrada, combinando a estimativa de movimento e a composição em uma só etapa.
• Modelos para movimentos amplos: O FILM (2022), do Google, compartilha pesos entre as escalas de uma pirâmide de características, de modo que um movimento amplo em uma escala fina é tratado como os pequenos movimentos que aprende em escalas mais grosseiras; além disso, é treinado apenas com trios de quadros.
• Modelos generativos: Interpoladores baseados em difusão, como o LDMVFI (2024), geram o quadro central removendo o ruído de uma representação latente condicionada pelas duas entradas, em vez de deformar os pixels.
• Interpolação baseada em eventos: O Time Lens (2021) acrescenta as mudanças de brilho que uma câmera de eventos registra entre dois quadros, revelando o movimento real durante o intervalo.

Aplicações no mundo real#

• Geração de quadros para jogos: O NVIDIA DLSS Multi Frame Generation insere até cinco quadros gerados para cada quadro renderizado em GPUs GeForce RTX 50 Series; cada quadro gerado precisa do próximo quadro renderizado, o que acrescenta latência.
• Edição de vídeo: Os editores criam câmera lenta a partir de filmagens convencionais e convertem vídeos de 24 ou 30 FPS para telas de 60 Hz e 120 Hz, usando a mesma interpolação de movimento que as TVs aplicam como suavização de movimento.
• Animação: Os modelos de interpolação geram desenhos intermediários entre quadros-chave desenhados à mão, e os geradores de vídeo podem produzir clipes completos que começam e terminam em dois quadros determinados.

O rastreamento de objetos aplica a mesma ideia a posições, em vez de pixels. Quando um objeto reaparece depois de ficar oculto por vários quadros, o rastreador OC-SORT no modo de rastreamento do Ultralytics (tracker="ocsort.yaml") interpola linearmente caixas virtuais para os quadros perdidos e as reproduz pelo filtro de Kalman, corrigindo a estimativa de velocidade usada para associar o objeto à próxima detecção do YOLO26.