Как работают векторы движения в коде с предсказанием для MPEG?

В MPEG существует процесс, в котором изображение разбивается на макроблоки, и вектор движения вычисляется для каждого из этих макроблоков. Затем вы передаете эти векторы вместе с ошибками предсказания, чтобы восстановить следующее изображение в видеопоследовательности.

Я пытаюсь понять, как это работает. Каждый макроблок имеет связанный с ним вектор движения, который (если вектор равен [1,0]) говорит, что all the pixels in this block move 1 in the x direction and 0 in the y direction for the next frame. если все векторы движения не выровнены правильно, это не приведет к тому, что области изображения будут пропущены (например, область, где этот макроблок был на первом месте)?

Например, у меня есть следующий вопрос, который я нашел.

Рассмотрим следующее изображение в момент времени t:

7   7   7   7           
7   7   5   5        
7   5   5   8         
8   8   8   8           
9   9   9   9       
9   9   9   9

Это изображение было разбито на макроблоки 2x2, и для его восстановления были отправлены следующие векторы движения:

(0,0)  (0,0)  (0,1)  (-1,1)  (0,0)  (0,0)

Изображение на предыдущем шаге по времени, t - 1, выглядело так:

7   7   7   7           
7   7   5   4        
7   7   7   7         
7   5   8   8           
8   9   8   9       
9   9   9   9   

Какие ошибки были переданы?

Как бы вы решили это?

Чтобы упростить вашу путаницу - там два процесса:

1. Оценка
движения 2. Компенсация движения

Прежде чем мы поговорим об оценке, мы должны поговорить о компенсации движения.

Допустим, разбивается на блок B l o c k s t [ k ] ( x ′ , y ′ ) .$Image_{t}(x,y)$$Blocks_{t}[k](x',y')$

Задача компенсации движения состоит в том, чтобы произвести из любой области I m a g e t - 1 ( x , y ) .$Blocks_{t}[k](x',y')$$Image_{t-1}(x,y)$

Следовательно, другой блок, не обязательно выровненный по границе 16x16, является наилучшим возможным совпадением $Blocks_{t-1}[k](x'+mx,y'+my)$

Здесь называется векторами движения.$mx, my$

Мы можем рассчитать ошибку между целью и ссылкой как

Поэтому теперь кодер в основном передает (с DCT и квантованием) и ( m x , m y ) [ k ] для каждого блока.$Err_{t}[k](x,y)$${( mx, my) }[k]$

Таким образом, кодер выполняет 2 работы:

1. Оценка движения
Процесс или оценка для каждого k такого, что E r r t [ k ] ( x , y ) минимизируется, называется оценкой движения.${ mx, my }[k]$$k$$Err_{t}[k](x,y)$

2. Генерация изображения ошибки после компенсации движения
. Процесс построения из пикселей изображения I t и ( m x , m y ) [ k ] называется компенсацией движения , Изображение ошибки - это то, что передается.$Blocks_{t}[k](x',y')$$I_{t}$${ (mx, my) }[k]$

Наконец, декодер может заново выполнить компенсацию движения самостоятельно, используя векторы moiton и изображение ошибки, чтобы выполнить окончательную реконструкцию изображения.

Теперь мы понимаем несколько моментов:

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

2. ${ (mx, my) }[k]$$Err_{t}[k](x,y)$

3. $Blocks_{t}[k](x',y')$

4. $Blocks_{t}[k]$$( mx ,my )[k]$$Blocks_{t}[k+1]$

5. $$Energy (Err_{t}[k](x,y)) > Energy ( Blocks_{t}[k](x',y') )$$

В таких случаях может быть более целесообразно передавать блок напрямую без прогнозирования, чем отправлять разность. Это также возможно в кодере с помощью положения, называемого блоком INTRA.

Нет, он не оставит дыр, потому что вектор идет от неизвестного кадра (P или B) к известному кадру (I-кадр). Это немного напоминает о том, как вычислить преобразование изображения - вы используете обратное преобразование, чтобы избежать дыр /

$B(i,j)$$i = \{0,1,2\}$ и $j = \{0,1\}$, каждый из этих блоков имеет координаты в$(2i, 2j)$(мы рассматриваем верхний левый угол каждого, чтобы определить его местоположение). Поэтому у нас сейчас шесть блоков в

(0,0) (0,2)
(2,0) (2,2)
(4,0) (4,2)

Ваши рассчитанные векторы движения $M(i,j)$ для каждого блока

(0,0) (0,0)
(0,1) (-1,1)
(0,0) (0,0)

Теперь, чтобы вычислить полученное изображение, мы должны сначала знать, куда перемещается каждый блок. Чтобы сделать это, мы просто добавляем вышеуказанную координатную матрицу к ее матрице движения:$B'(i,j)=B(i,j)+M(i,j)$, Мы получаем

(0,0) (0,2)
(2,1) (1,3)
(4,0) (4,2)

Для того , чтобы избежать «дыры» , как вы сказали, что мы не просто перемещать блоки исходного кадра вокруг , чтобы получить новый, мы берем оригинал один в качестве эталона и вводят вновь вычисленные блоки. Для этого сначала сделаем копию исходного кадра. Затем мы берем каждый$B'(i,j)$ и заменить его пикселями соответствующего $B(i,j)$,

Примечание: мы не защищены от какого-либо перекрытия блоков «в движении» (два блока перемещаются в перекрывающиеся местоположения). Есть способы справиться с этим, но это выходит за рамки этого ответа. Сейчас мы просто переписываем любые пиксели с блоком, который мы перемещаем, в их местоположение, так что даже если ранее были перемещены блоки, они будут перезаписаны.

Теперь, переходя от блока к блоку в порядке, который вы задали в своем вопросе, мы заменяем каждый $B'(i,j)$ соответствующим $B(i,j)$, Мы получаем следующий примерный кадр$F_e$

7 7 7 7
7 7 5 7
7 7 7 8
7 5 5 8
8 9 8 9
9 9 9 9

Ошибка $E$ находится между оценочным кадром $F_e$ и тот, который мы пытаемся предсказать $F$ найден $E=F-F_e$ который мы рассчитываем быть

0 0 0 0           
0 0 0 -3        
0 0 0 -1         
0 0 3 0           
0 0 0 0       
0 0 0 0