Eu estou trabalhando em um projeto onde eu preciso implementar a prevenção de colisão usando o OpenCV. Isso deve ser feito no iOS (o iOS 5 e acima funcionarão).

Objetivo do projeto: A ideia é montar um iPad no painel do carro e iniciar o aplicativo. O aplicativo deve pegar quadros da câmera e processá-los para detectar se o carro vai colidir com qualquer obstáculo.

Sou novato em qualquer tipo de processamento de imagens, por isso estou ficando preso a níveis conceituais neste projeto.

O que eu fiz até agora:

Teve uma olhada no OpenCV e leu sobre isso na net. A prevenção de colisão é implementada usando o método Lukas-Kanade Pyramid. Isto está certo?

Usando este projeto como ponto de partida:http://aptogo.co.uk/2011/09/opencv-framework-for-ios/ Ele é executado com sucesso no meu iPad e a funcionalidade de captura também funciona, o que significa que a captura da câmera é bem integrada. Eu mudei a implementação processFrame para tentar Fluxo Óptico, em vez de detecção de borda Canny. Aqui está a função (incompleta ainda).

    -(void)processFrame {
    int currSliderVal = self.lowSlider.value;
    if(_prevSliderVal == currSliderVal) return;
    cv::Mat grayFramePrev, grayFrameLast, prevCorners, lastCorners, status, err;

    // Convert captured frame to grayscale for _prevFrame
    cv::cvtColor(_prevFrame, grayFramePrev, cv::COLOR_RGB2GRAY);
    cv::goodFeaturesToTrack(grayFramePrev, prevCorners, 500, 0.01, 10);
    // Convert captured frame to grayscale for _lastFrame
    cv::cvtColor(_lastFrame, grayFrameLast, cv::COLOR_RGB2GRAY);
    cv::goodFeaturesToTrack(grayFrameLast, lastCorners, 500, 0.01, 10);

    cv::calcOpticalFlowPyrLK(_prevFrame, _lastFrame, prevCorners, lastCorners, status, err);
    self.imageView.image = [UIImage imageWithCVMat:lastCorners];
    _prevSliderVal = self.lowSlider.value;
}

Leia sobre o Optical Flow e como ele é usado (conceitualmente) para detectar uma colisão iminente. Resumo: Se um objeto está crescendo em tamanho, mas se movendo em direção a qualquer borda do quadro, ele não é um caminho de colisão. Se um objeto está crescendo em tamanho, mas não se movendo em direção a uma borda, ele está no caminho de colisão. Isto está certo?Este projeto (http://se.cs.ait.ac.th/cvwiki/opencv:tutorial:optical_flow) parece estar fazendo exatamente o que eu quero alcançar. Mas eu não entendi como está fazendo isso lendo o código. Eu não posso executá-lo como eu não tenho uma caixa de linux. Eu li a explicação nesta página da web, parece chegar a uma matriz homográfica. Como esse resultado é usado na prevenção de colisões?

Além dos quatro pontos acima mencionados, li muito mais sobre esse tópico, mas ainda não consigo juntar todas as partes.

Aqui estão minhas perguntas (por favor, lembre-se que eu sou um novato nisso)

Como o fluxo óptico é usado para detectar colisões iminentes? Com isto quero dizer, supondo que eu seja capaz de obter o resultado correto da função cv :: calcOpticalFlowPyrLK (), como faço para avançar a partir daí para detectar uma colisão iminente com qualquer objeto no quadro? É possível medir a distância do objeto com o qual estamos mais propensos a colidir?

Existe um projeto de trabalho de exemplo que implementa isso ou qualquer funcionalidade semelhante que eu possa dar uma olhada. Eu dei uma olhada no projeto no eosgarden.com, mas nenhuma funcionalidade parecia ser implementada nele.

No código de exemplo acima, estou convertendo lastCorners para UIImage e estou exibindo essa imagem na tela. Isso me mostra uma imagem que só tem linhas horizontais coloridas na tela, nada semelhante à minha imagem de teste original. Esta é a saída correta para essa função?

Eu estou tendo um pouco de dificuldade em entender os tipos de dados usados ​​neste projeto. InputArray, OutputArray etc são os tipos aceitos pelas APIs OpenCV. Ainda na função processFrame, cv :: Mat estava sendo passado para o método de detecção de borda Canny. Eu passo cv :: Mat para calcOpticalFlowPyrLK () para prevImage e nextImage?

Desde já, obrigado :)

Atualizar: Encontrei este projeto de amostra (http://www.hatzlaha.co.il/150842/Lucas-Kanade-Detection-for-the-iPhone). Ele não compila no meu mac, mas acho que a partir disso eu terei um código de trabalho para o fluxo ótico. Mas ainda não consigo descobrir como posso detectar uma colisão impeditiva de rastrear esses pontos. Se algum de vocês puder responder ao Qts. No. 1, será de grande ajuda.

Atualizar Parece que o fluxo ótico é usado para calcular o FoE (Foco de Expansão). Pode haver vários candidatos do FoE. E usando o FoE, o TTC (Time To Collision) é alcançado. Eu não estou muito claro na última parte. Mas estou correto até agora?O OpenCV implementa o FoE e / ou o TTC?