Como os vetores de movimento funcionam na codificação preditiva para MPEG?

No MPEG, existe um processo em que uma imagem é dividida em macroblocos e um vetor de movimento é calculado para cada um desses blocos de macro. Em seguida, você transmite esses vetores, juntamente com os erros de previsão, para reconstruir a próxima imagem na sequência de vídeo.

Estou tentando entender com firmeza como isso funciona. Cada macrobloco possui um vetor de movimento associado a ele, que (se o vetor for [1,0]), diz: all the pixels in this block move 1 in the x direction and 0 in the y direction for the next frame. Se todos os vetores de movimento não estiverem alinhados corretamente, isso não deixará áreas da imagem inexplicáveis ​​(como a área em que esse macrobloco estava em primeiro lugar)?

Por exemplo, tenho a seguinte pergunta que encontrei.

Considere a seguinte imagem no momento 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

Essa imagem foi dividida em macroblocos 2x2 e os seguintes vetores de movimento foram enviados para recriá-la:

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

A imagem na etapa anterior, t-1, tinha a seguinte aparência:

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

Quais foram os erros transmitidos?

Como você resolveria isso?

Para simplificar sua confusão - existem dois processos:

1. Estimativa de
movimento 2. Compensação de movimento

Antes de falarmos sobre a estimativa, devemos falar sobre a compensação de movimento.

Digamos que a seja dividida no bloco .B l o c k s t [ k ] ( x ′ , y ′$Image_{t}(x,y)$$Blocks_{t}[k](x',y')$

A tarefa da compensação de movimento é produzir partir de qualquer região da .I m a g e t - 1 ( x , y $Blocks_{t}[k](x',y')$$Image_{t-1}(x,y)$

Portanto, outro bloco não necessariamente alinhado no limite de 16x16 é a melhor correspondência possível $Blocks_{t-1}[k](x'+mx,y'+my)$

Aqui, é chamado de vetores de movimento.$mx, my$

Podemos calcular o erro entre o alvo e a referência como

Então agora, o codificador basicamente transmite (com DCT e quantização) e ( m x , m y ) [ k ] para cada bloco.$Err_{t}[k](x,y)$${( mx, my) }[k]$

Então, o codificador tem 2 trabalhos a fazer:

1. Estimativa de movimento
O processo ou estimativa de para cada k, de modo que E r r t [ k ] ( x , y ) seja minimizado, é chamado de estimativa de movimento.${ mx, my }[k]$$k$$Err_{t}[k](x,y)$

2. Geração de imagem de erro após compensação de movimento
O processo de construção de partir de i t pixels de imagem e ( m x , m y ) [ k ] é chamado de compensação de movimento . A imagem de erro é o que é transmitido.$Blocks_{t}[k](x',y')$$I_{t}$${ (mx, my) }[k]$

Finalmente, o decodificador pode refazer a compensação de movimento por si próprio, usando vetores moiton e a imagem de erro para fazer a reconstrução final da imagem.

Agora percebemos alguns pontos:

1. A estimativa de melhor movimento ajuda a minimizar a energia necessária para ser transmitida e, portanto, otimiza os bits para uma determinada qualidade.

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') )$$

Nesses casos, pode ser mais aconselhável transmitir o bloco diretamente sem previsão do que enviar a diferença. Isso também é possível no codificador por uma provisão chamada bloco INTRA.

Não, não deixará orifícios, porque o vetor é de um quadro desconhecido (P ou B), para um quadro conhecido ( quadro I). Ele lembra um pouco como calcular uma transformação de imagem - você usa uma transformação para trás para evitar buracos /

$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)$

Nota: Não estamos protegidos contra nenhum tipo de sobreposição de bloco "em movimento" (dois blocos são movidos para locais sobrepostos). Existem maneiras de lidar com isso, mas está além do escopo desta resposta. Por enquanto, vamos reescrever todos os pixels com um bloco que estamos movendo para o local deles, para que, mesmo que houvesse blocos movidos para lá anteriormente, eles serão substituídos.

$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