Дрожащий зум с opencv python

Во-первых, давайте посмотрим, почему ваш подход дает сбои. Тогда я покажу вам альтернативу, которая не дрожит.

В вашем подходе вы масштабируете изображение, сначала обрезая его, а затем изменяя его размер. Такое кадрирование происходит только по целым пиксельным строкам/столбцам, а не более мелкими шагами. Вы видели это особенно хорошо в конце ролика, где изображение очень точно увеличено. Обрезанное изображение изменит ширину/высоту менее чем на один пиксель за кадр, поэтому оно меняется только каждые пару кадров. Подергивание будет усиливаться по мере увеличения масштаба, потому что тогда пиксель становится больше.

Вместо такой обрезки рассчитайте и примените матрицу преобразования для каждого кадра. Это включает в себя warpAffine() или warpPerspective(). Учитывая, что исходное изображение является текстурой, эти функции обрабатывают каждый целевой пиксель, используют матрицу преобразования для вычисления точки в исходном изображении, а затем сэмплируют ее в исходном изображении с некоторым режимом интерполяции.

Составное преобразование рассчитывается из трех примитивных преобразований:

1. переместить определенную точку («якорь») изображения в начало координат
2. масштабировать вокруг начала координат (якоря)
3. переместиться туда, где оно должно быть в видеокадре

В коде я строю это преобразование в такой последовательности. Вы также можете записать это в одном выражении как T = translate2(*+zoom_center) @ scale2(s=z) @ translate2(*-anchor). Да, операции, выраженные этими матрицами, применяются справа налево.

import numpy as np
import cv2 as cv
from tqdm import tqdm # remove that if you don't like it

# Those two functions generate simple translation and scaling matrices:

def translate2(tx=0, ty=0):
    T = np.eye(3)
    T[0:2, 2] = [tx, ty]
    return T

def scale2(s=1, sx=1, sy=1):
    T = np.diag([s*sx, s*sy, 1])
    return T

# you know this one already

def ease_out_quart(alpha):
    return 1 - (1 - alpha) ** 4

# some constants to describe the zoom

im = cv.imread(cv.samples.findFile("starry_night.jpg"))
(imheight, imwidth) = im.shape[:2]

(output_width, output_height) = (1280, 720)

fps = 60
duration = 5.0 # secs

# "anchor": somewhere in the image
anchor = np.array([ (imwidth-1) * 0.75, (imheight-1) * 0.75 ])
# position: somewhere in the frame
zoom_center = np.array([ (output_width-1) * 0.75, (output_height-1) * 0.75 ])

zoom_t_start, zoom_t_end = 1.0, 4.0
zoom_z_start, zoom_z_end = 1.0, 10.0

# calculates the matrix:

def calculate_transform(timestamp):
    alpha = (timestamp - zoom_t_start) / (zoom_t_end - zoom_t_start)
    alpha = np.clip(alpha, 0, 1)
    alpha = ease_out_quart(alpha)
    z = zoom_z_start + alpha * (zoom_z_end - zoom_z_start)

    T = translate2(*-anchor)
    T = scale2(s=z) @ T
    T = translate2(*+zoom_center) @ T

    return T

# applies the matrix:

def animation_callback(timestamp, canvas):
    T = calculate_transform(timestamp)
    cv.warpPerspective(
        src=im,
        M=T,
        dsize=(output_width, output_height),
        dst=canvas, # drawing over the same buffer repeatedly
        flags=cv.INTER_LANCZOS4, # or INTER_LINEAR, INTER_NEAREST, ...
    )

# generate the video

writer = cv.VideoWriter(
    filename = "output.avi",  # AVI container: OpenCV built-in
    fourcc=cv.VideoWriter_fourcc(*"MJPG"), # MJPEG codec: OpenCV built-in
    fps=fps,
    frameSize=(output_width, output_height),
    isColor=True
)
assert writer.isOpened()

canvas = np.zeros((output_height, output_width, 3), dtype=np.uint8)

timestamps = np.arange(0, duration * fps) / fps

try:
    for timestamp in tqdm(timestamps):
        animation_callback(timestamp, canvas)

        writer.write(canvas)

        cv.imshow("frame", canvas)

        key = cv.waitKey(1)
        if key in (13, 27): break

finally:
    cv.destroyWindow("frame")
    writer.release()
    print("done")

Вот несколько видео результатов.

https://imgur.com/a/mDfrpre

Один из них — очень близкое увеличение с интерполяцией ближайшего соседа, поэтому вы можете четко видеть пиксели. Как видите, изображение не «обрезано» до целых пикселей. По краям видны кусочки пикселей.

Ради интереса я также сделал одно видео с несколькими сегментами анимации (пауза, вход, пауза, выход, пауза). Для этого просто нужна некоторая логика calculate_transform, чтобы определить, в каком временном интервале вы находитесь.

zoom_keyframes = [ # (time, zoom)
    (0.0, 15.0),
    (1.0, 15.0),
    (2.0, 16.0),
    (3.0, 16.0),
    (4.0, 15.0),
    (5.0, 15.0),
]

def calculate_transform(timestamp):
    i0 = i1 = 0
    for i, (tq, _) in enumerate(zoom_keyframes):
        if tq <= timestamp:
            i0 = i
        if timestamp <= tq:
            i1 = i
            break

    if i1 == i0: i1 = i0 + 1

    # print(f"i0 {i0}, i1 {i1}")

    zoom_ta, zoom_za = zoom_keyframes[i0]
    zoom_tb, zoom_zb = zoom_keyframes[i1]

    alpha = (timestamp - zoom_ta) / (zoom_tb - zoom_ta)
    alpha = np.clip(alpha, 0, 1)
    alpha = ease_out_quart(alpha)
    z = zoom_za + alpha * (zoom_zb - zoom_za)

    T = translate2(*-anchor)
    T = scale2(s=z) @ T
    T = translate2(*+zoom_center) @ T

    return T