Detectando uma imagem fixa de modelo a partir de um quadro semi-constante de vídeo

Há vários vídeos que estou procurando processar de diferentes jogos para detectar vários "estados" neles.

O primeiro jogo que estou enfrentando é qualquer edição do Super Street Fighter 4 .

Nele, eu gostaria de detectar quando a tela do personagem "vs" aparece. Aqui está um exemplo de um quadro do vídeo:

(retirado do 10s ~ marcar de este vídeo )

Se eu pudesse detectar o "vs", seria capaz de detectar que o quadro de vídeo é de fato a tela "vs", o que me permitiria procurar outras informações (por enquanto, digamos que vou usá-lo para detectar o registro de data e hora no vídeo em que a partida está prestes a começar).

Dito isto, eis o que se pode supor sobre os quadros dos vídeos que processarei (este não é o único vídeo, existem milhares, senão dezenas ou centenas de milhares de vídeos, mas a questão da escala no processamento que muitos vídeos é um domínio completamente diferente):

• Eu preferiria (mas não é necessário) processar a imagem de menor resolução possível com resultados confiáveis ​​(resoluções mais baixas = tempo de processamento mais rápido). A imagem acima tem 480 x 270 pixels (tirada de um vídeo do YouTube com fmt18 ), mas eles podem ter tamanhos diferentes (recebi vídeos do YouTube com fmt18, mas com dimensões de 640 x 360 pixels).
• A maioria dos vídeos terá feed direto
• A maioria dos vídeos terá uma proporção de 16: 9
• O fundo avermelhado será animado, mas geralmente estará nessa cor vermelho alaranjado (são chamas)
• Às vezes, haverá um emblema entrando e saindo na parte inferior do "vs" para indicar uma versão (que será importante, mas não no momento), que pode ofuscar o "vs", assim:

(retirado do ponto de ~ 3s a partir deste vídeo , também notar que o acima é uma resolução de 640 x 360 pixels)

• O tamanho e a posição do "vs" serão praticamente os mesmos (ainda não o verifiquei, mas sei que ele não se move) proporcionalmente a outros vídeos de feed direto
• Os caracteres serão escolhidos entre um pool de mais de 30 em cada lado (em outras palavras, essas áreas do quadro variarão)
• Os vídeos geralmente duram de dois a quatro minutos, com algo entre 4.000 e 6,00 quadros. No entanto, pode haver vídeos mais longos (talvez duas horas) com vários outros jogos e ações ao vivo. Esses vídeos não são tão importantes, mas se uma solução me indicar onde um determinado jogo aparece no vídeo geral maior, ótimo
• A resolução nativa das capturas é 720p, portanto, uma imagem de linha de base do "vs" pode ser obtida no que seria considerado um tamanho "nativo".

Por fim, pretendo codificar esse pipeline no .NET, mas isso não é super importante, a prova de conceito é mais importante aqui, assim como a compreensão das técnicas envolvidas, para que eu possa traduzi-lo e otimizá-lo para o .NET bem como para outros vídeos de outros jogos do mesmo gênero (se eu puder identificar os discriminadores significativos e vídeos de, digamos, Ultimate Marvel vs. Capcom 3 , Street Fighter x Tekken , BlazBlue: Continuum Shift , etc.).

Também estou mergulhando no Mathematica e tenho a versão 8.0 em casa, portanto, uma prova de conceitos nesse ambiente é bem-vinda também.

Se o "VS" for praticamente o mesmo (exceto algumas sobreposições de crachá, como no segundo exemplo), você poderá usar a correlação cruzada direta para detectar a presença do modelo no seu quadro de vídeo. Eu respondi uma pergunta semelhante sobre como fazer isso no MATLAB no Stack Overflow. Você pode usar algo como a ferramenta "varinha mágica" no Photoshop para selecionar o "VS" no quadro para criar um modelo. Fiz isso e binarizei a imagem para obter esse modelo .

Observando os diferentes canais de cores (RGB) em suas duas imagens, o canal vermelho parece ser o melhor para detectar seu modelo.

Agora você pode correlacionar o canal vermelho com seu modelo binarizado e deve obter um pico no local do modelo. Eu escolhi limiar e binarizar o modelo vermelho também, embora você possa detectá-lo sem fazer isso. Prefiro usar uma função de distância do que valores brutos de correlação cruzada, pois ela tende a ser um pouco mais robusta contra falsos positivos. Eu não sei C # / .NET, mas aqui está um esboço da abordagem no Mathematica:

image = Import["http://i.stack.imgur.com/7RwAh.png"];
ImageCorrelate[ Binarize[ColorSeparate[image][[1]], 0.1], vsTemplate, 
   NormalizedSquaredEuclideanDistance] // Binarize[#, 0.2] & // ColorNegate

o que fornece o seguinte. O ponto branco marca a região com a distância mínima em cada uma das duas imagens

$N$$M$$N+M-1$

Você também pode desenvolver isso e implementar um critério de limiar mais robusto. Por enquanto, destacarei apenas a detecção em benefício de outras pessoas:

Você pode gerar o acima com uma função combinada:

detectVS[i_Image] := 
 Module[{mask = 
    ImageCorrelate[ Binarize[ColorSeparate[i][[1]], 0.1], vsTemplate, 
       NormalizedSquaredEuclideanDistance] ~Binarize~ 0.2 // 
     ColorNegate},

  ColorConvert[i, "Grayscale"]~ImageAdd~ 
   ImageMultiply[i, Image[mask]~Dilation~ DiskMatrix@100]
  ]

Há muito potencial para melhorias aqui. Eu sou um hobby de poltrona no processamento de imagens, então não sei quais são os algoritmos mais rápidos. No entanto, há algumas coisas que você pode procurar:

1. Se o VS for aproximadamente o mesmo local em todos os vídeos, você não precisará se correlacionar usando a imagem inteira - basta selecionar uma caixa no meio e trabalhar com isso.
2. Isso pode ser uma operação cara para cada quadro. No entanto, olhando para o seu vídeo, você tem um pouco mais de 4 segundos de quadros nos quais o VS é exibido e os nomes dos personagens. Então, eu sugiro que você analise um quadro a cada segundo ou no máximo a cada 2 segundos, garantindo assim que você aterrará em um quadro com um VS. Depois de detectar o VS, você pode começar a processar todos os quadros sucessivos para executar a próxima parte do seu processamento.
3. Esse processo deve ser, em uma extensão razoável, robusto para alterar o tamanho, ou seja, você pode fazer correlações cruzadas em imagens pequenas, mas precisará de um modelo adequado para corresponder. Se você souber que suas imagens terão tamanhos determinados / padrão, crie modelos para cada uma delas e selecione o modelo apropriado, dependendo do tamanho da imagem.
4. Os limites que escolhi foram por tentativa e erro, mas parecem funcionar para as duas imagens acima e, nos outros vídeos relacionados do youtube, provavelmente funcionarão para a maioria deles. Uma abordagem mais especializada envolveria dividi-lo em blocos e examinar o histograma para inferir se ele pertence ao VS ou não - talvez um classificador bayesiano. No entanto, tenha certeza absoluta de que você precisa fazer isso antes de iniciar o processo. Parece-me que é simples o suficiente para que você não precise.