A detecção de objetos é muito importante na visão computacional, várias pesquisas e metódos são criados todos os anos com novas melhorias e aperfeiçoamento de algoritmos já existentes.
Mostrando postagens com marcador OpenCv. Mostrar todas as postagens
Mostrando postagens com marcador OpenCv. Mostrar todas as postagens
Nos últimos tutoriais vimos como trabalhar com imagens e com captura de imagens vindas da webcam, hoje cobriremos a reprodução de vídeos.
Para reproduzir videos usaremos o objeto VideoCapture o mesmo utilizado para exibir os frames vindos da camera. Observe o exemplo abaixo e logo após veremos o que está acontecendo:
| main.cpp | |
| // Bibliotecas necessarias do opencv | |
| #include "opencv2/core/core.hpp" | |
| #include "opencv2/highgui/highgui.hpp" | |
| using namespace std; | |
| using namespace cv; | |
| int main(int argc, const char** argv) | |
| { | |
| VideoCapture cap; //endereço do video | |
| cap.open("suicidesquad.mp4"); | |
| //criacao da janela | |
| namedWindow("Video", 1); | |
| //reproduzindo o video | |
| for(;;) | |
| { | |
| Mat frame; | |
| cap >> frame; //pega um novo frame do video //exibe o frame | |
| imshow("Video", frame); | |
| if(waitKey(30) >= 0) break; | |
| } | |
| // Libera o espaço alocado pelo VideoCapture | |
| cap.release(); | |
| return 0; | |
| } |
Entendendo o Código
A primeira coisa que precisamos fazer é incluir as bibliotecas necessárias para o projeto, utilizamos a biblioteca gráfica para trabalhar com janelas highgui e incluimos a biblioteca padrão do opencv core:
| //Bibliotecas do opencv #include "opencv2/core/core.hpp" | |
| #include "opencv2/highgui/highgui.hpp" |
Logo após criarmos o objeto, precisamos indicar qual é o caminho do video que desejamos reproduzir, para isso utilizamos o método open("caminho do video") , caso deseje verificar se foi possivel encontrar ou abrir o arquivo informado poderia utilizar cap.isOpened(), que retorna true ou false.
| VideoCapture cap; cap.open("suicidesquad.mp4"); |
O proximo passo é exibir os frames vindos do video, para isso, criamos uma janela com a função namedWindow, e a partir do nosso loop infinito, recebemos cada frame do video com o operador >>, por fim exibimos o frame com a função imshow. Com a função waitKey(30), aguardamos 30 milisegundos para verificar se o usuário deseja encerrar a aplicação apertando qualquer tecla.
| //criacao da janela namedWindow("Video", 1); | |
| //reproduzindo o video | |
| for(;;) | |
| { | |
| Mat frame; | |
| cap >> frame; //pega um novo frame do video //exibe o frame | |
| imshow("Video", frame); | |
| if(waitKey(30) >= 0) break; | |
| } | |
| // Libera o espaço alocado pelo VideoCapture | |
| cap.release(); | |
| return 0; |
Agora precisamos criar um arquivo cmake e indicar nossas dependências para compilarmos nosso programa. Crie um arquivo chamado CMakeLists.txt, em seguida adicione o seguinte código:
| cmake_minimum_required (VERSION 2.6) cmake_policy(SET CMP0012 NEW) | |
| PROJECT(read_video) | |
| # Requires OpenCV | |
| FIND_PACKAGE( OpenCV REQUIRED ) | |
| MESSAGE("OpenCV version : ${OpenCV_VERSION}") | |
| include_directories(${OpenCV_INCLUDE_DIRS}) | |
| link_directories(${OpenCV_LIB_DIR}) | |
| ADD_EXECUTABLE( read_video main.cpp ) | |
| TARGET_LINK_LIBRARIES( read_video ${OpenCV_LIBS} ) |
Compilando e Rodando
- Crie uma pasta chamada read_video em opencv-3.0.0/apps.
- Copie os arquivos main.cpp e CMakeLists.txt que criamos acima para a pasta read_video junto com o video que deseja exibir.
- Com a pasta read_video aberta no terminal digite cmake . e logo após make para gerar nosso executável.
- Por último digite ./read_video
Voce verá uma janela que exibirá o video escolhido em RGB, como o exemplo a seguir:
Baseado em: OpenCv By Example
Código fonte: read_video
Até a próxima!
Olá galera, daremos nossos primeiros passos com o uso da webcam com OpenCV, faremos algo simples nessse tutorial como receber os dados que veem de sua webcam e mostrar as imagens na tela, o resultado obtido será a saída de sua webcam dessa maneira:
Crie uma pasta chamada Deteccao_intruso dentro de seu diretório OpenCV, no meu caso é OpenCV/opencv/meus_apps, logo a seguir crie um arquivo chamado detec.cpp, logo após copie o seguinte código, em seguida detalharemos o algoritmo:
#include<iostream>
#include<opencv2/opencv.hpp>
#include<opencv2/highgui/highgui_c.h>
using namespace cv;
using namespace std;
int main(int argc, char** argv)
{
/*pegando a webcam padrao*/
CvCapture* webcam = cvCaptureFromCAM(0);
//criando uma janela
cvNamedWindow("Identificador", CV_WINDOW_AUTOSIZE);
IplImage* imagem;//variavel para guardar a imagem recebida da webcam
while(1){//loop para atualizacao da imagem recebida
/*recebe a imagem da camera*/
imagem = cvQueryFrame(webcam);
if(!imagem) break;//se nao houver imagem saia do loop
//mostre a imagem
cvShowImage("Identificador", imagem);//recebe o nome de uma janela e o nome da imagem a ser mostrada
/*aguarda a tecla esc ser apertada se for sai do loop*/
char c = cvWaitKey(33);
if(c == 27) break;
}
cvReleaseCapture(&webcam);
cvDestroyWindow("Identificador");
return 0;
}
Agora crie um arquivo chamado CMakeLists.txt e cole o seguinte script:
cmake_minimum_required(VERSION 2.8)
project(Deteccao_intruso)
find_package(OpenCV REQUIRED)
add_executable(detec detec.cpp)
target_link_libraries(detec ${OpenCV_LIBS})
Vamos executar e ver o resultado, para isso dentro da mesma pasta abra o terminal e digite os seguintes comandos:
cmake .
make
./detec
Explicação:
#include<iostream>
#include<opencv2/opencv.hpp>
#include<opencv2/highgui/highgui_c.h>
Nessas três primeiras linhas é apenas inclusão de bibliotecas necessárias para entrada e saída padrão em C++, biblioteca do opencv para utilizar suas funções.
using namespace cv;Inclusão de namespace para não precisar colocar a biblioteca na frente de toda chamada de função como exemplo: std::cout, ao invés disso apenas escrevemos cout.
using namespace std;
/*pegando a webcam padrao*/
CvCapture* webcam = cvCaptureFromCAM(0);
//criando uma janela
cvNamedWindow("Identificador", CV_WINDOW_AUTOSIZE);
Na primeira linha criamos um objeto ponteiro para CvCapture que realiza uma captura de imagem, nesse caso recebemos a imagem da webcam, passando o argumento (0), para cvCaptureFromCAM significa que a as imagens processadas veem da webcam padrão, caso esteja em um computador e tenha mais de uma webcam plugada, poderia colocar (1) que iria para a segunda webcam e assim sucessivamente. Na sequencia criamos uma janela chamada Identificador com um tamanho padrão. Essa janela é onde sairá as imagens captadas pela webcam.
IplImage* imagem;//variavel para guardar a imagem recebida da webcam
while(1){//loop para atualizacao da imagem recebida
/*recebe a imagem da camera*/
imagem = cvQueryFrame(webcam);
Criamos um ponteiro para guardar a imagem recebida da webcam, logo em seguida entramos no loop infinito para poder atualizar as imagens recebidas da webcam, guardamos a seguir os dados recebidos da webcam dentro de imagem.
if(!imagem) break;//se nao houver imagem saia do loop
//mostre a imagem
cvShowImage("Identificador", imagem);//recebe o nome de uma janela e o nome da imagem a ser mostrada
Na primeira linha verificamos se recebemos alguma imagem da webcam caso não tenha recebido encerra o loop. Caso tenha conseguido, na linha abaixo mostramos uma janela , passando o nome da janela a ser exibida e o conteúdo que queremos exibir no nosso caso imagem.
/*aguarda a tecla esc ser apertada se for sai do loop*/char c = cvWaitKey(33);
if(c == 27) break;
Criamos um char que recebe uma tecla e se esse caractere for 27 ou seja a tecla esc, o programa é encerrado.
cvReleaseCapture(&webcam);
cvDestroyWindow("Identificador");
Por último o espaço reservado na memória é liberado, na primeira linha liberamos a webcam e na segunda a janela criada.
É isso espero que tenham gostado. Deixem suas dúvidas nos comentários. Até a próxima.
Aprenderemos hoje a exibir uma imagem na tela do seu pc, com o OpenCv, se você não acompanhou a instalação do ambiente no último post clique aqui.
Olá galera, falaremos hoje sobre a instação do OpenCV, para quem não conhece o OpenCV é uma biblioteca escrita em c e c++ criada nos anos de 2000 pela Intel, com o objetivo de ajudar as pessoas a construirem aplicações de visão computacional, pode ser aplicado em várias áreas como: Identificação de objetos, sistema de reconhecimento facial, robôs móveis e etc. Se quiser conhecer mais acesse OpenCV.
Há quatro linguagens que são suportadas pelo OpenCv, são elas: Python, C++, C e Java. Utilizaremos C++ em nossos tutoriais.
Antes de iniciarmos precisamos preparar nosso ambiente e instalar a ferramenta em si, cobriremos a instalação no linux nesse tutorial, contudo instalações para outros sistemas podem ser encontradas facilmente no próprio site da OpenCv.
Há alguns pacotes que precisam ser instalados antes do OpenCV, como o compilador GCC, segue os comandos abaixo:
- sudo apt-get install build-essential
- sudo apt-get install cmake git libgtk2.0-dev pkg-config libavcodec-dev
libavformat-dev libswscale-dev
- sudo apt-get install python-dev python-numpy libtbb2 libtbb-dev
libjpeg-dev libpng-dev libtiff-dev libjasper-dev libdc1394-22-dev
Entre em sua pasta de trabalho ou crie uma se não tiver e dentro da pasta digite o seguinte comando no terminal:
mkdir OpenCV
cd OpenCV
git clone https://github.com/Itseez/opencv.git
Agora crie uma pasta temporária que chamaremos de <cmake_binary_dir>, lá será colocado os arquivos de Makefiles do projeto e binário.
Entre nesta pasta que criamos e digite:
cd opencv
mkdir release
cd release
cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local ..
Por último dentro da nossa pasta release, digite os seguintes comandos:
make
sudo make install
Tudo certo, agora temos nosso ambiente configurado no próximo tutorial faremos uma pequena demonstração do que o OpenCv pode fazer com imagens. Até lá.
Referências: http://stackoverflow.com, opencv.org, Fagner Assis - Introdução à OpenCv e Visão Computacional.
