Rastreadores ópticos: ASEF e MOSSE

Uma das subtarefas importantes da análise de vídeo é rastrear objetos em um vídeo. Não é tão primitivo que eu precisei descer para o nível pixel por pixel, mas não é tão complexo que exija inequivocamente uma rede neural multicamada para a solução. O rastreamento pode ser usado como um fim em si mesmo e como parte de outros algoritmos:

• Contando pessoas únicas que entraram em uma determinada zona ou cruzaram a fronteira em um quadro
• Identificação de rotas típicas de carros em um estacionamento e pessoas em uma loja
• Rotação automática da câmera de vigilância quando o objeto é deslocado

Mesmo sem olhar para a literatura, posso dizer com confiança que a melhor maneira de resolver o problema é usar redes neurais. Em geral, você não pode escrever mais nada, mas nem sempre é possível se apressar em uma tarefa com um par de GTX 1080Ti. Quem se importa em rastrear objetos no vídeo em tais casos, por favor, em cat. Vou tentar não apenas explicar como os rastreadores ASEF e MOSSE funcionam, mas levá-lo à solução para que as fórmulas pareçam óbvias.

Para começar, responderemos a uma pergunta preliminar: por que inventar algo quando você pode alimentar uma pilha de vídeos com fluxo tensor e deixar o computador por algumas semanas? As abordagens de redes neurais têm uma séria desvantagem: mesmo nas placas de vídeo modernas, é difícil obter uma boa taxa de incêndio nas redes. Isso não é um problema se analisarmos o vídeo gravado, mas ele insere um bastão nas rodas se você deseja trabalhar em tempo real. Suponha que desejemos processar vídeo de cinco câmeras a 10 FPS. Mesmo com condições relativamente moderadas, uma rede neural deve ter um tempo de inferência inferior a $$$\ frac {1000} {5 \ times 10} = $ 2$ milissegundos (em condições de não paralelismo completo). Para comparação, o YoloV3, uma rede classificadora com uma arquitetura relativamente simples, pode revelar uma imagem em $$$50$ milissegundos. Além disso, soluções baseadas em poderosas placas gráficas podem ser muito caras.

Este artigo pressupõe que você já tenha lidado com o processamento de imagens de máquina, esteja familiarizado com as operações básicas da álgebra linear (convolução, norma, inversão de matriz) e, em geral, entenda a transformação de Fourier.

Daqui em diante:

• $$$A \ odot B$ significa multiplicação de matrizes elementares $$$A$ e $$$B$
• $$$A / vezes B$ denota convolução de matrizes $$$A$ e $$$B$
• $$$\ hat {A} (\ omega, \ nu) = \ mathcal {F} (A (x, y))$ significa que $$$\ hat {A} (\ omega, \ nu)$ - matriz de frequências da transformada rápida de Fourier aplicada à imagem $$$A$ .
• $$$\ paralelo A \ parallel_2$ - indica a soma dos quadrados dos elementos da matriz $$$A$

Decisão trivial

À primeira vista, a tarefa de rastrear um assunto específico não parece tão complicada.

Que possamos ter $$$T$ quadros consecutivos de vídeo $$$I_t$ o tamanho $$$w$ em $$$h$ pixels. No quadro inicial do vídeo $$$I_0$ um retângulo é circulado em torno de algum objeto $$$F_0$$$$m$ em $$$n$ . É necessário encontrar a localização desse corpo em todos os outros quadros $$$I_t$ .

Removemos o ruído nas imagens e normalizamos cada uma delas na faixa de -1 a 1, para que as alterações gerais no brilho não afetem a detecção. Tire o primeiro quadro do vídeo sem marcação $$$I_1$ . Se $$$I_0$ e $$$I_1$ - quadros vizinhos de vídeo com bom FPS, é improvável que o objeto desejado esteja longe da sua posição original. Aproveite isso. Cortar $$$I_1$ retângulo $$$F_1$ do local onde o corpo desejado estava localizado anteriormente. "Arrastar" $$$F_0$ através de $$$F_1$ e em cada ponto calculamos o quadrado da soma das diferenças

$$

$$G_ {L_2} (i, j) = \ paralelo F_ {1} (i, j) - F_0 \ paralelo_ {2}, i \ em [0, m], j \ em [0, n]$$

onde calcular a diferença de $$$G_ {L_2} (i, j)$ precisa combinar o centro $$$F_0$ com elemento $$$(i, j)$ em $$$F_1$ e os valores ausentes para zero. Depois disso na matriz $$$G_ {L2}$ o mínimo é procurado; sua localização menos as coordenadas do centro $$$F_1$ e será o deslocamento do objeto desejado por $$$I_1$ .

Para que uma transição nítida para zero não "toque" durante a detecção, é melhor inicialmente levar o retângulo um pouco mais do que o necessário e reduzir suavemente para zerar os valores mais próximos das bordas $$$F_0$ e $$$F_1$ . Para isso, cada um $$$F$ precisa ser multiplicado pela máscara. Para objetos quadrados, o bom e velho expositor fará. $$$A = \ exp {\ frac {(x - i) ^ 2 + (y - j) ^ 2} {\ sigma ^ 2}}$ (onde $$$(x, y)$ É o centro da janela), mas, no caso geral, é melhor usar uma janela Hanning bidimensional.

Para $$$I_2$ a janela $$$F_2$ tirada da posição prevista no quadro $$$I_1$ e assim por diante.


Em vez disso $$$L_2$ normas podem ser usadas $$$L_1$ ( $$$G_ {L_ {1}} (i, j) = | F_1 (i, j) - F_0 |$ ) e menos a correlação cruzada de matrizes ( $$$G_ {nCC} (i, j) = - \ sum_ {kl} {F_ {1, kl} (i, j) F_ {0, kl}}, k \ em [0, m], l \ in [ 0, n]$ ) Ambos são considerados um pouco mais rápidos que $$$L_2$ mas eles têm suas próprias características. $$$L_1$ não diferenciável e menos sensível a grandes diferenças nos valores de pixel. A correlação cruzada pode produzir falsos positivos se a amostra tiver baixo contraste e a imagem tiver áreas muito claras ou muito escuras.

$$$L_2$ -versão da métrica não tem essa desvantagem:

$$

$$G_ {L_2} = \ sum {(F_ {1, kl} (i, j) - F_ {0, kl}) ^ 2}$$

$$

$$= \ sum {(F_ {1, kl} (i, j)) ^ 2 - 2 F_ {1, kl} (i, j) F_ {0, kl} + (F_ {0, kl}) ^ 2 }$$

$$

$$= \ sum {(F_ {1, kl} (i, j)) ^ 2} - \ sum {2 F_ {1, kl} (i, j) F_ {0, kl}} + \ sum {(F_ {0, kl}) ^ 2}$$

$$

$$= E_ {F_1 (i, j)} + 2 G_ {nCC} (i, j) + E_ {F_0}$$

$$$E_ {F_1 (i, j)}$ , A "energia" do site selecionado em $$$I_t$ atua como um fator de equilíbrio ( $$$E_ {F_0}$ , a soma dos quadrados dos valores de pixel da amostra é a mesma para todas as posições da janela e não tem significado prático aqui).

Mesmo esse algoritmo primitivo lida muito bem no caso de movimento linear de objetos (por exemplo, uma câmera olhando para o transportador). No entanto, devido à simplicidade do modelo e execução, esse método de rastreamento tem várias desvantagens:

1. Um movimento linear simples de um objeto sem mudanças na natureza é raro. Como regra, os corpos no campo de visão da câmera podem sofrer algumas classes de alterações. Em ordem crescente de complexidade: aumento / diminuição de tamanho, voltas, transformações afins, transformações projetivas, transformações não lineares, alterações em um objeto. Mesmo se omitirmos mudanças de objeto e transformações não lineares, gostaríamos que o algoritmo pudesse se recuperar de rotações e alterações de tamanho relativamente simples. Obviamente, o procedimento acima não possui essa propriedade. Provavelmente $$$F_0$ ainda dará uma resposta perceptível no objeto, mas será difícil determinar a localização exata da amostra e a faixa será descontínua.
   
   
   Exemplo

   

   
   
2. Mostramos ao algoritmo apenas uma amostra positiva, é difícil dizer qual resposta dará $$$F_0$ se outro objeto semelhante entrar na janela. Bem, se o objeto desejado estiver contrastando e tiver uma estrutura rara, mas e se quisermos monitorar uma máquina em um fluxo de outras máquinas? Um rastreador pode pular imprevisivelmente de um carro para outro.
3. Em cada quadro, descartamos toda a história de fundo. Provavelmente, também deve ser usado de alguma forma.
4. Além disso, aprendemos apenas em um ponto da imagem. Será melhor que, perto da localização correta do objeto, o rastreador também dê uma boa resposta. Um pouco contra-intuitivo, mas pense: se o filtro estiver no local exato do objeto na imagem $$$(x, y)$ dá o melhor valor e, em $$$(x + 1, y + 1)$ - Algo aleatório, o que significa que ele é sensível demais a pequenos detalhes que podem mudar facilmente. Por outro lado, se em $$$(x, y)$ e em $$$(x + 1, y + 1)$ aproximadamente os mesmos bons valores, o filtro “enganchou” em sinais maiores e, esperamos, mais permanentes.
5. Com a implementação ingênua do procedimento de rastreamento, para cada pixel do quadro, multiplicamos a janela inteira pelo item selecionado pela parte correspondente desse quadro. A complexidade desta operação é $$$O (m ^ 2n ^ 2)$ . Nesses casos, não é muito bom rastrear até 50 a 50 objetos de pixel. Esse problema é parcialmente resolvido com a redução do tamanho do vídeo, mas ao reduzir a imagem para menos de 240 pixels de largura, até grandes detalhes significativos começam a ser perdidos, o que torna o algoritmo sem sentido.

ASEF, MOSSE

Abordagem trivial ++?

Arregace as mangas e tente resolver os problemas acima.

Aumente a imagem original. Aplicamos a ele várias transformações afins leves. Você também pode adicionar ruído ou alterar a gama. Assim, em vez de uma única imagem, um conjunto de microdados de $$$P$ fotos. Havia muitas imagens, mas uma janela permaneceu. Então agora não vamos apenas cortar um retângulo da imagem, mas procurar um filtro $$$W$ o que dará uma boa resposta para todos $$$I ^ p$ . Transformamos o problema em um problema de minimização:

$$

$$W: \ min_W {\ paralelo F ^ p - W \ paralelo_2}, p \ em [1, P]$$

onde $$$\ paralelo F ^ p - W \ paralelo_2$ - a soma dos quadrados das diferenças de pixel entre $$$W$ e a seção correspondente da localização exata do objeto no $$$p$ essa imagem sintética criada a partir de um quadro com marcação verdadeira.

Além disso, você pode amostrar retângulos longe da localização do objeto rastreado e maximizar a diferença mostrada acima.

É mais difícil sugerir que o filtro dê uma boa resposta em pontos próximos à localização exata do objeto. Sabemos que em $$$(x, y)$ aplicação de filtro com $$$L_2$ -metric deve dar 0, próximo - mais, longe - ainda mais. Além disso, não temos nenhuma direção preferida, a resposta deve ser centralmente simétrica em relação a $$$(x, y)$ . Parece que podemos expressar matematicamente como deve ser a resposta de um filtro aplicado às imagens de referência! A aparência exata pode variar dependendo da função de atenuação da resposta específica, mas todos amam os gaussianos? Portanto, assumimos que $$$W$ aplicado a $$$F_p$ idealmente deve dar um resultado $$$G_p = 1 - \ exp {\ frac {(x - i) ^ 2 + (y - j) ^ 2} {\ sigma ^ 2}}$ . Portanto, o problema de minimização se transforma em:

$$

$$D_p (i, j) = \ paralelo F ^ p (i, j) - W \ paralelo_2$$

$$

$$W: \ min_W {\ paralelo D_p (i, j) - G_p (i, j) \ paralelo_2}, p \ em [1, P$$

Agora, não minimizamos a resposta em um ponto, mas minimizamos o desvio da resposta da desejada.

Espere um segundo ... Conseguimos $$$P \ vezes m \ vezes n$ equações com $$$m \ vezes n$ variáveis ​​a serem minimizadas. Parece que nós exageramos. Vamos voltar um pouco.

Truque principal

De todos os problemas, a maior dificuldade é a complexidade. $$$O (m ^ 2n ^ 2)$ . É possível criar algo além da divisão complicada de uma caixa de pesquisa em várias pequenas ou pesquisar na imagem em pequena resolução e ajustar a alta precisão?

Acontece que você pode! A análise analítica nos diz que o dobramento de funções no espaço comum é uma multiplicação de suas imagens de Fourier. Podemos aplicar a transformação rápida de Fourier às imagens, multiplicar suas frequências elemento por elemento e depois transformar o resultado novamente em uma matriz para $$$O (mn \ log {mn})$ , que é muito mais rápido do que minimizar a matriz honestamente. Fourier! Quem teria pensado! Na era do fluxo tensor, ele ainda pode nos ajudar com a visão computacional.

(A propósito, isso demonstra o princípio matemático geral: se você não deseja resolver o problema no espaço $$$X$ mova-o para o espaço $$$Y$ , decida lá e transfira a decisão de volta. A solução alternativa é geralmente mais curta que a direta.)

Como mostrado acima, podemos usar correlação cruzada para localizar a amostra na imagem. Mas a correlação cruzada é uma convolução com reflexos horizontal e verticalmente $$$W$ . A análise analítica sugere que, neste caso, será necessário multiplicar as frequências $$$F$ em uma matriz conjugada complexa a uma matriz de frequência $$$W$ :

$$

$$\ hat {W} (\ omega, \ nu) = \ mathcal {F} (W (x, y))$$

$$

$$\ hat {F} (\ omega, \ nu) = \ mathcal {F} (F (x, y))$$

$$

$$\ hat {G} _ {conv} (\ omega, \ nu) = \ mathcal {F} (G_ {conv} (x, y))$$

$$

$$G_ {conv} = Às vezes W \ rightarrow \ hat {G} _ {conv} = \ hat {F} \ odot \ hat {W} ^ *$$

onde $$$G_ {conv} = \ exp {\ frac {(x - i) ^ 2 + (y - j) ^ 2} {\ sigma ^ 2}}$ - função de resposta perfeita na imagem de referência. Por favor note que $$$L_2$ Minimizamos a métrica e maximizamos a métrica de convolução; agora, quanto maior a resposta, melhor.

Se tivéssemos uma imagem, encontraríamos a matriz exata de frequência do filtro:

$$

$$\ hat {W} ^ * = \ frac {\ hat {G} _ {conv}} {\ hat {F}}$$

onde o lado direito se refere à divisão elemento a elemento. Mas um pouco antes geramos $$$P$ imagens da fonte. Podemos aplicá-los com a abordagem de Fourier. Não há filtro com essas frequências que satisfaça idealmente todas as imagens, mas você pode obter algo bom o suficiente. Existem duas maneiras de resolver o problema:

1. Você pode encontrar um conjunto de filtros ideais e depois fazer a média deles em um. É assim que os autores de Média de filtros exatos sintéticos (ASEF) seguem:

   $$

   $$\ hat {W} ^ * = \ frac {1} {P} \ sum_ {p = 1} ^ {P} \ hat {W} ^ * _ p = \ frac {1} {P} \ sum_ {p = 1} ^ {P} {\ frac {\ hat {G} _p} {\ hat {F} ^ p}}$$
   Aqui usamos a propriedade de linearidade das imagens de Fourier. Adicionando frequências, como mostrado acima, parecemos calcular vários pesos de filtro.
2. Você pode encontrar frequências de filtro que satisfazem todas as imagens em média, aproximadamente como $$$L_2$ :

   $$

   $$\ hat {W} ^ *: \ min _ {\ hat {W} ^ *} {\ sum_ {p = 1} ^ {P} {\ paralelo \ hat {F} ^ p \ odot \ hat {W} ^ * - \ hat {G} _p \ parallel_2}}$$
   Para encontrar o mínimo, você precisa derivar os elementos de filtro:

   $$

   $$\ frac {\ delta} {\ delta \ hat {W} ^ *} \ sum_ {p = 1} ^ {P} {\ paralelo \ hat {F} ^ p \ odot \ hat {W} ^ * - \ hat {G} _p \ parallel_2} = 0$$
   Uma captura honesta dessa derivada pode ser encontrada no Visual Object Tracking usando os filtros de correlação adaptativos , que oferecem filtros mínimos de soma quadrada de erro quadrático (filtros MOSSE). O resultado é este:

   $$

   $$\ hat {W} ^ * = \ frac {\ sum_ {p = 1} ^ {P} {\ hat {G} _p \ odot \ hat {F} ^ {p *}}} {\ sum_ {p = 1} ^ {P} {\ hat {F} ^ p \ odot \ hat {F} ^ {p *}}}$$

Hmm, como se elementos semelhantes estivessem envolvidos nas fórmulas. At $$$P = 1$ as fórmulas para ASEF e MOSSE são exatamente as mesmas. $$$\ hat {W} ^ *$ para uma imagem pode ser representada como

$$

$$\ hat {W} ^ * = \ frac {\ hat {G_p}} {\ hat {F ^ p}} = \ frac {\ hat {G_p} \ odot \ hat {F} ^ {p *}} { \ hat {F ^ p} \ odot \ hat {F} ^ {p *}}$$

Substitua na fórmula pelo ASEF e obtenha

$$

$$\ hat {W} ^ * = \ sum_ {p = 1} ^ {P} {\ frac {\ hat {G} _p \ odot \ hat {F} ^ {p *}} {\ hat {F} ^ p \ odot \ hat {F} ^ {p *}}}$$

Sim! Agora é muito melhor ver que ASEF e MOSSE diferem apenas no método de média dos filtros! Argumenta-se que o MOSSE produz filtros melhores que o ASEF. Parece lógico: ajustar melhor o conjunto de imagens como um todo é melhor do que calcular a média dos filtros.

Depois que chegamos $$$\ hat {W} ^ *$ , calculamos a resposta no domínio da frequência $$$\ hat {G} _ {conv} = \ hat {F} \ odot \ hat {W} ^ *$ , traduzimos para o domínio espacial e procuramos o máximo na matriz resultante $$$G$ . Onde o máximo é, há a nova posição do objeto.

Pontos adicionais

• Os termos nos denominadores das fórmulas têm um significado físico interessante. $$$\ hat {F} ^ p \ odot \ hat {F} ^ {p *}$ É o espectro de energia de um retângulo com $$$p$ essa imagem.
• Preste atenção à simetria interessante. Era necessário multiplicar as frequências do filtro pelas frequências da imagem para obter uma resposta. Agora você precisa multiplicar as frequências de resposta pelas frequências de imagem (e normalizar) para obter as frequências de filtro.
• Na vida real, a divisão elemento a elemento pode causar divisão por zero; portanto, uma constante de regularização geralmente é adicionada ao denominador $$$\ epsilon$ . Argumenta-se que essa regularização faz com que o filtro preste mais atenção às baixas frequências, o que melhora a capacidade de generalização.
• Ao processar vídeo real, geralmente você deseja salvar informações sobre o objeto rastreado obtido de quadros anteriores. Ao passar para o próximo quadro, você não pode calcular $$$\ hat {W}$ do zero e atualize o anterior. Fórmula de atualização para ASEF:

  $$

  $$\ hat {W} ^ * _ i = \ frac {\ eta} {P} \ sum_ {p = 1} ^ {P} {\ frac {\ hat {G_p}} {\ hat {F ^ p}}} + (1 - \ eta) \ hat {W} ^ * _ {i-1}$$
  Para o MOSSE, você precisa acumular o numerador e o denominador separadamente:

  $$

  $$A_i = \ eta \ sum_ {p = 1} ^ {P} \ hat {G} _p \ odot \ hat {F} ^ {p *} + (1 - \ eta) A_ {i-1}$$

  $$

  $$B_i = \ eta \ sum_ {p = 1} ^ {P} \ hat {F} ^ p \ odot \ hat {F} ^ {p *} + (1 - \ eta) B_ {i-1}$$

  $$

  $$\ hat {W} ^ * _ i = \ frac {A_i} {B_i}$$
  onde $$$\ eta$ - velocidade de aprendizado.
• É importante lembrar que a transformação de Fourier não é exatamente a mesma que o cálculo $$$G$ honestamente, conforme descrito no início do artigo. Ao calcular a FFT, os elementos ausentes não desaparecem, mas são substituídos no verso, como se a imagem estivesse em loop da direita para a esquerda e de baixo para cima. Mas no começo do artigo, já decidimos escurecer as bordas $$$F$ , portanto, esse problema não terá um efeito perceptível.
• Como mencionado acima, a correlação cruzada tem uma característica desagradável: em geral, um filtro de luz pode dar uma forte resposta em áreas brancas da imagem, mesmo que não coincidam em áreas contrastantes. Os problemas não se limitam a isso. Mesmo um pixel correspondente com um valor fortemente positivo ou muito negativo pode interferir no filtro se a amostra como um todo tiver baixo contraste. Para suavizar esse efeito, uma transformação não linear de pixels da imagem deve ser incluída no pré-processamento, o que “pressionará” áreas muito claras e muito escuras no meio. Devido a isso, a coincidência dessas áreas contrastantes contribui mais fortemente para a métrica. Os artigos ASEF e MOSSE usam o logaritmo:

  $$

  $$I = \ log {I + 1}$$
  onde estão os pixels $$$I$ de 0 a 255. Na minha opinião, isso é muito severo e ignora o problema de forte resposta do filtro escuro em áreas pretas . Esse esquema funciona melhor:

  $$

  $$I = sinal (I - 127) \ sqrt {| I - 127 |}$$
  Depois vem a normalização, e acontece que a maioria dos elementos está centrada em torno de zero.
  
• Como esse algoritmo pode determinar que o objeto rastreado desapareceu do quadro? Uma análise mais detalhada da resposta recebida do próximo quadro ajudará aqui. Os criadores do MOSSE oferecem um indicador PSR - Peak to Sidelobe Ratio. Vamos $$$g_ {max}$ - elemento máximo $$$G$ correspondente à nova posição do objeto $$$(x, y)$ . Excluímos o quadrado da consideração $$$11 \ vezes 11$ em torno deste máximo. Calculamos a média e o desvio padrão para os pixels restantes ( $$$\ mu_ {sl}, \ sigma_ {sl}$ ) Então

  $$

  $$PSR = \ frac {g_ {max} - \ mu_ {sl}} {\ sigma_ {sl}}$$
  Se esse valor estiver acima de um determinado limite, a detecção será considerada bem-sucedida. O limite geralmente é calculado na região entre 3 e 10. Para detecções confiáveis, o PSR geralmente é mantido acima de 20.
  
  (observe que aqui PSR não significa em absoluto o que geralmente significa na teoria do processamento de sinais; portanto, não pesquise no Google, nada de bom sairá)
• O algoritmo é extremamente simples. O procedimento de rastreamento no Core-i7 em imagens com 320x400 usando a implementação OpenCV leva de 0,5 a 2 milissegundos, dependendo do tamanho do objeto rastreado.

Algoritmo MOSSE

Juntando tudo.

Condição geral:

Matriz de frequência do filtro: $$$\ hat {W}$
Matrizes auxiliares para o cálculo de frequências de filtro: $$$A, B$
Matriz de frequência da resposta ideal desejada: $$$\ hat {G}$
Velocidade de treinamento durante o rastreamento: $$$\ eta$
O retângulo da posição atual do objeto: $$$R$
Número de transformações: $$$P$
Limiar de resposta: $$$PSR_ {thr}$

Função auxiliar: Treinamento . Entrada: Imagem $$$I$ velocidade atual de aprendizado $$$\ eta_ {current}$

1. $$$A_ {novo}: = 0, B_ {novo}: = 0$
2. Até eu conseguir $$$P$ transformações:
   
   1. Aplique uma pequena transformação afim aleatória centralizada no centro da imagem. $$$R$
   2. Cortar da imagem retangular com objeto $$$F$
   3. Aplique uma máscara para anular suavemente as bordas
   4. Traduzir $$$F$ no domínio da frequência: $$$\ hat {F}$
   5. $$$A_ {new} = A_ {new} + \ hat {G} \ odot \ hat {F} ^ *$
   6. $$$B_ {novo} = B_ {novo} + \ hat {F} \ odot \ hat {F} ^ *$
   
   
3. Se $$$\ eta_ {current} \ geq 1,0$ então substitua $$$A$ e $$$B$ em $$$A_ {new}$ e $$$B_ {novo}$ . Caso contrário:
   

   $$

   $$B: = \ eta B_ {novo} + (1 - \ eta) B$$

   $$

   $$A: = \ eta A_ {novo} + (1 - \ eta) A$$
4. Calcular frequências de filtro:

   $$

   $$\ hat {W} ^ * = \ frac {A} {B}$$

Inicialização . Entrada: Imagem $$$I$ retângulo em torno da posição do objeto $$$R_ {init}$

1. $$$R: = R_ {init}$
2. Prepare a resposta desejada $$$G$ . Normalmente, essa é uma matriz completamente zero, com um pequeno gaussiano no centro.
3. Treinamento : $$$I$ 1,0
4. Traduzir $$$G$ no domínio da frequência: $$$\ hat {G}$

Rastreamento : Entrada: Imagem $$$I$

1. Cortar retângulo $$$F$ de $$$I$ para a posição anterior existente do objeto $$$R$
2. Aplique uma máscara para anular suavemente as bordas
3. Traduzir $$$F$ no domínio da frequência: $$$\ hat {F}$
4. $$$\ hat {G} _ {response} = \ hat {W} \ odot \ hat {F} ^ *$
5. Traduzir $$$\ hat {G} _ {response}$ para o domínio espacial: $$$G_ {response}$
6. Encontre o máximo em $$$G_ {response}$ : $$$g_ {max}, (x, y)$
7. Calcular o poder de resposta $$$PSR: = \ frac {g_ {max} - \ mu_ {sl}} {\ sigma_ {sl}}$
8. Se $$$PSR <PSR_ {thr}$ falha na saída
9. Atualizar posição $$$R$ . Ajuste R se ultrapassar a imagem ou foi decidido que o objeto aumentou / diminuiu.
10. Treinamento : $$$I$ , $$$\ eta$
11. Retorno $$$R$

Os detalhes da implementação podem variar. Por exemplo

• Somente pode pré-processar $$$F$ , não a imagem inteira.
• $$$G$ pode ser recriado para cada transformação de imagem com função variável e largura de resposta.
• Você pode treinar vários filtros diferentes ao mesmo tempo em várias escalas do objeto para detectar movimentos à distância e nas proximidades.

Como é isso?

Para iniciantes, alguns exemplos da transformação bidimensional de Fourier.


Agora vamos para um exemplo de trabalho real:


O mesmo exemplo com uma resposta desejada mais estreita:


$$$W$ para os três casos anteriores $$$G$ quando usado para treinar 16 transformações da imagem de entrada:


Se você quiser ver como fica ao vivo, baixe aqui meu repositório de teste com a implementação do MOSSE com a saída de imagens de depuração. Você pode encontrar mais opções MOSSE no github. Além disso, está em OpenCV .

Conclusão

Obrigado pela atenção, Habrovsk. O rastreamento MOSSE e ASEF não são os algoritmos mais complexos do mundo. O mais fácil é não apenas aplicá-las efetivamente, mas também entender como seus criadores foram orientados. Espero que minha explicação tenha ajudado você a entrar na cabeça dos pesquisadores para seguir o curso de seus pensamentos. Isso pode ser útil: o aprendizado de máquina não é um campo estático do conhecimento; há um lugar para criatividade e pesquisa. Tente se aprofundar em algum algoritmo estabelecido: descubra membros desnecessários para acelerar ou adicione alguns para fazê-lo funcionar melhor no seu caso particular. Você vai gostar!

Este artigo foi escrito com o suporte do DSSL.