Tutoriais‎ > ‎

OpenCV


1. Introdução

O OpenCV é uma biblioteca concebida especialmente para o processamento e análise de imagens em tempo real e implementa algoritmos bem estabelecidos na literatura de Processamento de Imagens, Visão Computacional e Inteligência Artificial.

A biblioteca,  originalmente desenvolvida pela Intel em 2000, tem uma implementação multiplataforma, totalmente livre para o uso acadêmico e comercial, distribuído sob licençaBSD. Ela possui módulos de Processamento de Imagens e Vídeo, estrutura de dados, álgebra linear, Interface Gráfica (GUI) com sistema de janelas independentes, controle de mouse e teclado, além de mais de 350 algorítmos de Visão Computacional (Processamento e Análise) como: filtros de imagem, calibração de câmera, reconhecimento de objetos, análise estrutural e outros. A biblitoeca possui versões disponíveis em Python, C++, C, Java e Android.

Através desta biblitoeca é possível desenvovler aplicações de processamento de imagens em tempo real.

2. Desenvolvimento de Algoritmos de PDI

Na figura a seguir é apresentado um diagrama básico das etapas de um algoritmo de processamento de imagens.

Resumidamente, a primeira etapa adquire a imagem em um formato adequado e passa para uma etapa de pré-processamento em que serão feitos uma série de ajustes para melhorar a qualidade da imagem.

Após o pré-processamento, é realizada uma etapa de segmentação em que são extraídos da imagem os objetos de interesse. Caso a segmentação não tenha excelentes resultados, pode ser feita uma etapa de pós-processamento para melhorar a qualidade da segmentação.

Com base em cada objeto segmentado, são extraídas informações e passadas por uma etapa de reconhecimento para tomar uma decisão. Eventualmente, após todo o processamento pode ser feito uma etapa de exibição de resultados, na qual são apresentadas uma série de informações sobre a imagem processada.

Nesta página serão apresentadas algumas funções utilizadas para o processamento de imagens em cada uma dessas etapas utilizando funções disponíveis na implementação C++ da biblioteca.

2.1 Aquisição de Imagens

Para adquirir imagens no OpenCV utiliza-se as seguintes funções:

Descrição exemplo em C exemplo em C++

Carrega uma imagem a partir de um arquivo em disco. Os parâmetros de entrada da função são 

  1. O caminho do arquivo
  2. A forma de abertura, definida com
    1. CV_LOAD_IMAGE_ANYDEPTH: carrega no formato original da imagem
    2. CV_LOAD_IMAGE_COLOR: converte obrigatoriamente para uma versão colorida
    3. CV_LOAD_IMAGE_GRAYSCALE: converte obrigatoriamente para uma versão em níveis de cinza
IplImage* img = cvLoadImage("c:/pasta/imagem.jpg", CV_LOAD_IMAGE_COLOR  ); Mat img = imread("c:/pasta/imagem.jpg", CV_LOAD_IMAGE_COLOR );
Configura a aquisição de vídeo a partir da câmera padrão CvCapture * cap = cvCaptureFromCAM(0); VideoCapture cap(0);
Configura a aquisição de vídeo a partir de um arquivo de vídeo  CvCapture * cap = cvCaptureFromFILE("C:/Pasta/nomedoarquivo.mp4"); VideoCapture cap("C:/Pasta/nomedoarquivo.mp4");
Utilizando um sisetma de captura, definido na variável cap, adquire um quadro do vídeo. IplImage * frame = cvQueryFrame(cap); Mat frame;
cap >> frame;

2.1. Pré-processamento

Para realcar imagens (aplicar filtos passa-alta e passa baixa ou ajustar contraste) no OpenCV utiliza-se as seguintes funções:

Descrição exemplo em C exemplo em C++

Fliltra uma imagem utilizando um filtro passa baixa com formato de uma gaussiana. Possiu os seguintes parâmetros de entrada:

  1. imagem de entrada
  2. imagem de saída
  3. tamanho da janela de filtragem
  4. desvio padrão nas colunas
  5. desvio padrão nas linhas
  6. tipo de cálculo feito nas extremidades da imagem
GaussianBlur(imOrigem,imDestino,7,5,5,BORDER_DEFAULT );

Aplica um filtro passa alta em uma imagem de entrada. Possui os seguintes parâmetros de entrada:

  1. imagem de entrada
  2. imagem de saída
  3. tamanho da janela de filtragem

Na versão C++ é possível passar mais parâmetros como o tipo da imagem de saída. 

cvLaplace(imOrigem, imDestino, 3 );

Laplacian(imOrigem,imDestino, CV_8U, 1,1,0,BORDER_DEFAULT );

Nesse exemplo, usa-se como saída uma imagem de 8 bits sem sinal (CV_8U) com máscara 3x3 e cálculo padrão nas regiões extremas da imagem.

Aplica diferentes algoritmos de filtro passa baixa utilizando uma só função, alterando seus parâmetros de entrada.Possui os seguintes parâmetros de entrada:

  1. imagem de entrada
  2. imagem de saída
  3. algoritmo de filtragem. Pode assumir valores: CV_BLUR_NO_SCALE, CV_BLUR, CV_GAUSSIAN, CV_MEDIAN; 
  4. tamanho da janela de filtragem
  5. desvio padrão nas colunas
  6. desvio padrão nas linhas
  7. tipo de cálculo feito nas extremidades da imagem
cvSmooth(imOrigem, imDestino, CV_GAUSSIAN, 3, 3, 0,0 );

Smooth(imOrigem, imDestino, CV_GAUSSIAN, 3, 3, 0,0 );

Calcula uma derivada espaciais de ordem X, Y, utilizado em detectores de borda Sobel. Possui os seguintes parâmetros:

cvSobel(mOrigem,imDestino, dx, dy, 3);

Sobel(mOrigem, imDestino, CV_16S, dx, dy, 3,1, 0, int BORDER_DEFAULT );

Aplica um realce de brilho da imagem associado a um ajuste de contraste. Em que
destino = origem * contraste + brilho. 

cvAddWeighted(imOrigem, contraste, origem, 0,brilho, imDestino);

imgOriginal.convertTo(imgDestino, -1, contraste,brilho);

equivale a 

addWeighted(imOrigem, contraste, origem, 0,brilho, imDestino);

 

2.2 Segmentação

Existem várias funções para a segmentação de imagens disponíveis no OpenCV, as mais simples são mostradas na tabela a seguir:

Descrição exemplo em C exemplo em C++

aplica a limiarização utilizando um único limiar na imagem de origem.

cvThreshold(imOrigem, imDestino, valorDoLimiar, 255, CV_THRESH_BINARY); threshold(imOrigem, imDestino, valorDoLimiar, 255, CV_THRESH_BINARY);
aplica uma limiarização adaptativa que divide a imagem em blocos e aplica a limiarização em cada um dos blocos separadamente cvAdaptiveThreshold(imOrigem imDestino, 255, ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY, 16, 0) adaptiveThreshold(imOrigem imDestino, 255, ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY, 16, 0);

Aplica uma limiarização utilizando dois limiares. A função retorna como pixel igual a 255 os pixels que estiverem entre os dois limiares.

No exemplo, a função limiariza os pixels que contenham o canal vermelho entre 100 e 200, independente do valor de G e B.

cvInRangeS(imOrigem, CV_RGB(100,0,0), CV_RGB(200,255,255), imDestino);
inRangeS(imOrigem, CV_RGB(100,0,0), CV_RGB(200,255,255), imDestino);

2.3 Extração de atributos

Para extrair informações de imagens segmentadas são utilizadas as seguintes funções:

Descrição exemplo em C exemplo em C++
Calcula os momentos a partir de uma imagem segmentada (ImSeg).

CvMoments momentos;
cvMoments(imSeg, &momentos,1);¶

Moments momentos=moments(imSeg, true );

Calcula o quadrado envolvente de uma forma segmentada

CvRect quadrado=cvBoundingRect(imSeg)

Rect quadrado=boundingRect(imSeg);

Calcula o maior quadrado interno a forma

CvBox2D quadrado=cvMinAreaRect2(imSeg,NULL );

RotatedRect quadrado=minAreaRect(imSeg);

Calcula a posição do maior circulo que encontra-se inscrito a forma

cvMinEnclosingCircle(imSeg,&centro,&raio);

minEnclosingCircle(imSeg,centro,raio);

2.4 Exibição de resultados

Para exbir imagens ou inserir anotações nas imagens, o OpenCV utiliza-se as seguintes funções:

Descrição exemplo em C exemplo em C++

Abre uma janela vazia para exibir um quadro ou imagem Recebe como parâmetros 

  1. O nome da janela 
  2. O Formato da Janela
    1. WINDOW_NORMAL: a imagem pode ser redimensionada
    2. WINDOW_AUTOSIZE: ajusta automaticamente ao tamanho da imagem
    3. WINDOW_OPENGL: utiliza o suporte ao OPENGL
cvNamedWindow("Janela",WINDOW_AUTOSIZE); namedWindow("Janela", WINDOW_AUTOSIZE);
mostra uma imagem em uma janela, caso não tenha sido criada a janela anteriormente, o opencv automáticamente cria a janela cvShowImage("Janela", img); imshow("Janela", img);
Salva uma imagem em disco cvSaveImage("C:/Pasta/nomedoarquivo.jpg",img); imwrite("C:/Pasta/nomedoarquivo.jpg",img);

3. Exemplos

     

imagem original
 

ajuste de contraste (contraste diminuido)

 
filtro passa-baixa gaussiano
 

filtro passa alta (laplaciano)

 segmentação com limiar unico (thresholding)
 

segmentação utilizando o inRangeS
 
bounding rect
 
drawContours
 

4. Configuração

Ficou interessado na biblitoeca? 

Nesta pagina encontra-se uma série de tutoriais que podem lhe auxiliar a utilizar a biblioteca.

Configurando o OpenCV no Raspberry2

postado em 31 de ago de 2015 12:16 por Prof. Rodrigo Costa

Neste post, serão descritos os procedimentos necessários para configurar o OpenCV no Raspberry PI 2.

Antes de iniciar as configurações, é necessário obter os seguintes pre-requisitos:

Pré-requisitos

  • Imagem do RASPIBIAN, disponível no site: https://www.raspberrypi.org/downloads/raspbian/ gravada no sdcard do raspberrypi

  • Servidor SSH habilitado no raspberry
  • Cliente SSH, por exemplo, putty. 
  • Opcional: cliente x-windows, configuração no windows disponível no meu site https://sites.google.com/site/rodccosta/tutoriais/windows/Putty-Xming

1. Instalando os pacotes

Deve-se alterar o arquivo /etc/hosts e /etc/hostname. 
[email protected] $ sudo su
[email protected] # apt-get install libcv2* libcv-dev libcvaux* libhighgui* opencv-doc python-opencv pkg-config gcc g++ make

Depois disto, deve-se criar os links simbólicos de algumas bibliotecas, pois o apt-get não criou os links de todas as libs.
[email protected] # ln -s /usr/lib/libopencv_photo.so.2.4.1 /usr/lib/libopencv_photo.so
[email protected] # ln -s /usr/lib/libopencv_ts.so.2.4.1 /usr/lib/libopencv_ts.so
[email protected] # ln -s /usr/lib/libopencv_stitching.so.2.4.1 /usr/lib/libopencv_stitching.so
[email protected] # ln -s /usr/lib/libopencv_videostab.so.2.4.1 /usr/lib/libopencv_videostab.so

2. Configurando o pkg-config 

 Para facilitar as configurações de compilação do opencv, configura-se o pkg-config para armazenar as diretrizes de compilação e ligação
[email protected] # mkdir /var/lib/pkg-config
[email protected] # cd /var/lib/pkg-config 
[email protected] # nano opencv.pc

O conteudo do opencv.pc está disponível a seguir:
prefix=/usr
exec_prefix=${prefix}
libdir=${prefix}
includedir_old=${prefix}/include/opencv
includedir_new=${prefix}/include

Name: OpenCV
Description: Intel(R) Open Source Computer Vision Library
Version: 2.4.1
Libs: -L${libdir} -lopencv_calib3d -lopencv_contrib -lopencv_core -lopencv_features2d -lopencv_flann -lopencv_highgui -lopencv_imgproc -lopencv_legacy -lopencv_ml -lopencv_objdetect -lopencv_photo -lopencv_stitching -lopencv_ts -lopencv_video -lopencv_videostab
Cflags: -I${includedir_old} -I${includedir_new}

Para concluir a configuração, deve-se criar uma variável de ambiente PKG_CONFIG_PATH apontando para o diretório /var/lib/pkg-config. Para fazer isto, deve-se inserir no final do arquivo .bashrc o seguinte comando.
[email protected] # echo "export PKG_CONFIG_PATH=/var/lib/pkg-config" >> ~/.bashrc
[email protected] # echo "export PKG_CONFIG_PATH=/var/lib/pkg-config" >> /home/pi/.bashrc

Para testar o pkg-config usa-se
[email protected] # sh ~/.bashrc
[email protected] # pkg-config opencv --cflags
[email protected] # pkg-config opencv --libs

Após as configurações, deve-se reiniciar o raspberry e pronto, o opencv já está configurado e pronto pra criar programas.

3. Testando

Neste tutorial será criado um programa que carrega uma imagem gravada no sdcard do raspberry e a exibe na interface gráfica em seguida. 
[email protected] ~ $ nano teste.cpp

O conteúdo do arquivo teste.cpp é descrito a seguir

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int main(void)
{
        Mat img = imread("imagem.jpg");
        imshow("Original",img);
        waitKey(0);
}

Depois disso, basta compilar o arquivo
[email protected] ~ $ c++ -c teste.cpp -o teste.o `pkg-config opencv --cflags`
[email protected] ~ $ c++ teste.o -o teste.bin `pkg-config opencv --libs`

Pronto, concluído estas instruções, executa-se o programa compilado e a imagem é exibido na tela
[email protected] ~ $ ./teste.bin

A seguir é mostrado o resultado final dos testes realizados no windows com o x-ming

Vídeo

Foi criado um video executando este tutorial, disponível no youtube.com/rodccosta

Configurando o Eclipse para desenvolver no OpenCV

postado em 2 de dez de 2014 11:43 por Prof. Rodrigo Costa   [ 2 de dez de 2014 12:53 atualizado‎(s)‎ ]

Após a compilação do OpenCV, descrito no tutorial disponível no link , podemos escolher e configurar um ambiente integrado de desenvolvimento.
Neste tutorial será descrito como configurar e como criar um projeto para desenvolver no OpenCV.

1. Configurando dependências

Para utilizar o OpenCV no eclipse, deve-se verificar se já estão configurados:
  • o compilador MinGW
  • a biblioteca OpenCV está compilada e configurado o path para o loca onde encontra-se a pasta bin do OpenCV compilado.
  • o ambiente PKG-CONFIG e as diretrizes de configuração do OpenCV configurado.
Estes detalhes estão descritos em: https://sites.google.com/site/rodccosta/tutoriais/opencv/compilaropencv249

2. Obtendo o Eclipse e requisitos para configuração automática do OpenCV

Primeiramente, é necessário obter o Eclipse através do site de downloads.
Particularmente, instalei a versão Standard 4.4, disponível no link https://eclipse.org/downloads/packages/eclipse-standard-44/lunar. Mas, caso seja de seu interesse instalar a versão já com CDT, pode fazer o download através do link https://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/lunasr1.

Após o download, extrai-se os arquivos para uma pasta e em seguida, pode-se executar o programa eclipse.exe e após o seu carregamento, deve-se ir em install new software, conforme mostrado a seguir:


Deve-se incluir dois pacotes:
  • CDT disponível no repositório http://download.eclipse.org/releases/luna sob o sub-menu Programing Language > C/C++ Developement.
  • pkg-config disponível no repositório http://petrituononen.com/pkg-config-support-for-eclipse-cdt/update
A seguir é mostrada a janela de seleção de ambos os repositórios.
   

3. Criando um projeto

Deve-se clicar com o botão direito em qualquer espaço em branco e ir em New > Project.
Depois disso, deve-se escolher o tipo de projeto (C ou C++). Neste exemplo, foi utilizado um projeto C++.  Na tela a seguir é escolhido o compilador, deve-se escolher o compilador MINGW, já configurado.

 
 
 

Depois disso, deve-se alterar as configurações do projeto. Com o pkg-config configurado conforme o tutorial indicado anteriormente, essa configuração é bem simplificada, basta ir em Properties > C++ Build/ Settings / PKG-Config e marcar a biblioteca opencv.

   

Após clicar em OK, você pode verificar se as configurações foram importadas corretamente, clicando na pasta includes do projeto, conforme mostrado a seguir:

4. Criando o arquivo main com o código fonte

Após a configuração, deve-se criar um arquivo com o código fonte utilizando códigos da biblioteca opencv. Um exemplo de código fonte é mostrado a seguir:
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include <iostream>
#include <stdio.h>

using namespace std;
using namespace cv;


int main( int argc, const char** argv )
{
VideoCapture cap(0); // open the default camera
    if(!cap.isOpened())  // check if we succeeded
        return -1;

    Mat edges;
    namedWindow("original",1);
    for(;;)
    {
        Mat frame;
        cap >> frame; // get a new frame from camera
        imshow("original", frame);
        if(waitKey(30) >= 0) break;
    }
    // the camera will be deinitialized automatically in VideoCapture destructor
    return 0;
}

Exemplo de Código Fonte para selecionar arquivos via interface gráfica

postado em 1 de dez de 2014 16:48 por Prof. Rodrigo Costa   [ 2 de dez de 2014 03:20 atualizado‎(s)‎ ]

Com uma pequena configuração, é possível utilizar interfaces gráficas do Windows no C para utilizar junto ao OpenCV.

Antes de mais nada, é necessário incluir a biblioteca nas diretrizes de ligação do projeto c++. Na figura a seguir é apresentado um exemplo de configuração dessa diretriz no eclipse.


Usando as interfaces gráficas padrão do windows, criei a função select_file() que abre a interface, carrega a imagem e a exibe. 

O código fonte deste teste é mostrado a seguir: 

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
#include <stdio. h>
#include <windows. h>
using namespace std;
using namespace cv;
Mat select_file()
{
   OPENFILENAME ofn;
   char szFileName[ 500] ;
   szFileName[ 0] = '\0' ;
   memset(&ofn, 0, sizeof(ofn)) ;
   ofn. lStructSize = sizeof(ofn) ; // comprimento da estrutura, usa-se sizeof(OPENFILENAME) 
   ofn. hwndOwner = NULL; // manipulador da janela que possui a interface. Neste caso foi setado NULL pois o código não foi chamado por outra GUI.
   ofn. lpstrFile = szFileName; // ponteiro para onde será armazenado o nome do arquivo
   ofn. nMaxFile = sizeof(szFileName) ; // tamanho máximo do nome do arquivo
   ofn. hInstance = NULL; 
   ofn. lpstrFilter = TEXT("Images *. png, *. jpg, *. bmp\0*. png; *. jpg; *. bmp\0All Files*.*\0*.*\0\0") ; // filtro contendo os tipos de arquivos a serem abertos.
                      // usa-se a sintaxe: Texto\0extensoes separadas por ;\0 Texto\0Extensoes\0 \0 
   ofn. nFilterIndex = 1; // tipo de filtro de arquivo padrão.
   ofn. Flags= OFN_FILEMUSTEXIST; // caso você deseje mais opções, deve separá-las através do operador ou bitwise |. 
                                  // Exemplos de flags: OFN_FILEMUSTEXIST requer que o arquivo exista. OFN_ALLOWMULTISELECT permite que selecione vários arquivos.
   int bRes;
   bRes = GetOpenFileName(&ofn) ;
   MessageBox(0, szFileName, "-", MB_OK) ;
   Mat img = imread(szFileName) ;
   imshow("Original", img) ;
   waitKey(0) ;
   return img;
}
int main( int argc, const char** argv )
{
   select_file() ;
   return 0;
}


Compilando o OpenCV 2.4.9 com o MinGW

postado em 24 de nov de 2014 05:33 por Prof. Rodrigo Costa   [ 24 de nov de 2014 14:16 atualizado‎(s)‎ ]

Neste tutorial serão descritos as ações necessárias para compilar a versão do OpenCV 2.4.9 para uso no Eclipse e no Codeblocks.

Resumidamente, são necessários os seguintes passos:
  1. Instalação de um compilador gcc
  2. Compilação da biblioteca OpenCV
  3. Configuração do PKG-Config para auxiliar a compilação do MinGW
  4. Testando a compilação no prompt

1. Instalação do Compilador GCC

Para instalação do compilador é necessário fazer o download do setup de instalação do Mingw http://sourceforge.net/projects/mingw/files/latest/download?source=files.

Ao executar o arquivo de instalação, deve-se escolher o local de instalação do mingw e alguns detalhes sobre a ferramenta de download do MinGW.

Na imagem ao lado é feita a configuração básica do MinGW.  A configuração é dividida em dois estágios, no primeiro estágio é feita a seleção do local aonde o compilador será instalado e detalhes simples de configuração. 

É possível permitir a escolha de quais usuários podem realizar a instalação de pacotes do MINGW. Recomenda-se utilizar as configurações mostrada na figura ao lado para evitar que usuários leigos alterem os pacotes existentes do MINGW e desconfigurem o ambiente.

Depois disso, o ambiente de obtenção de pacotes do MinGW será baixado e ao final do download, a ferramenta de gerenciamento de pacotes do MinGW é aberta automaticamente
 


Na ferramenta de gerenciamento, o usuário pode escolher quais pacotes do MinGW serão obtidos e configurados no Sistema. Ao clicar com o botão direito em qualquer pacote listado, é possível escolher cinco opções:
  • mark for instalation: o pacote selecionado será obtido e configurado. 
  • mark for reinstalation: o pacote será reinstalado
  • mark for upgrate: será feito o upgrate do pacote
  • mark for removal: o pacote será excluído
  • unmark : aborta a seleção feita.
Deve-se selecionar para download os pacotes, conforme mostrado na figura da direita:
  • mingw32-base
  • mingw32-gcc-g++
Concluída a seleção, deve-se ir no menu Instalation > Apply Changes.



Para tornar possível a compilação do opencv é necessário incluir no path do sistema o diretório MINGW\bin. Na figura ao lado é mostrado como configurar a variável de ambiente path.

Para fazer isto, deve-se clicar no menu iniciar e escrever variáveis, conforme mostrado na figura a seguir. Caso o usuário deseje alterar as variáveis para todos os usuários, deve clicar em editar as variáveis de ambiente do sistema. Caso o usuário deseje que apenas ele tenha acesso, deve-se clicar em editar as variáveis de ambiente para sua conta.

Deve-se inserir no path o diretório bin do mingw. No caso desse exemplo, foi inserido no path o diretório C:\MINGW\bin
 


Para testar se o compilador está disponível, deve-se ir no prompt de comando e inserir o comando mingw32-gcc --help. A seguir é apresentado o resultado desse procedimento.

 
Caso apareça um resultado similar, você instalou e configurou corretamente o mingw no seu pc.

2. Compilação do OpenCV 2.4.9 no Windows usando o MinGW 

Para compilação da biblioteca, é necessário a instalação da versão 2.8 do CMAKE para Windows e os códigos fonte do OpenCV. Os arquivos de instalação do CMAKE e do Opencv 2.4.9 estão disponíveis a seguir:

  • OpenCV 2.4.9: http://sourceforge.net/projects/opencvlibrary/files/opencv-win/2.4.9/opencv-2.4.9.exe/download
  • Cmake 2.8.12-2: http://www.cmake.org/files/v2.8/cmake-2.8.12.2-win32-x86.exe
Depois de obter os arquivos, faz-se a instalação do CMake. A única preocupação que deve ser tomada é que os diretórios do CMake devem ser incluídos automaticamente no path do sistema, conforme mostrado na figura a seguir.

depois de configurado o CMake, deve-se extrair os arquivos do opencv2.4.9 e depois clica-se no menu iniciar para abrir a interface gráfica do CMake, conforme mostrado na figura a seguir:

Na janela principal do CMake, deve-se selecionar o diretório dos códigos fonte e o diretório onde serão colocados os códigos compilados do mingw.
No exemplo mostrado na figura a seguir, os arquivos da biblioteca opencv foram colocados no diretório D:\. Desta forma, foi escolhido como origem o diretório D:\opencv\sources e foi selecionado o diretório opencv_build para guardar os códigos fontes configurados para a compilação.


Após a configuração da origem e destino da compilação, deve-se clicar em configure.  Durante a inicialização do processo, é solicitado o compilador e deve-se informar que será utilizado o compilador MinGW.

Após o processamento de todas as dependencias, será disponibilizado uma lista de opções de compilação. Exemplo: habilita ou não a compilação dos exemplos, etc. Após a seleção de todas as configurações, deve-se clicar em Generate para gerar as configurações de compilação. Depois disto, o código está pronto para ser compilado. Na figura a seguir é apresentado como realizar o processo de compilação.


Após todo o processo de compilação, deve-se fazer a instação da biblioteca. Durante a configuração foi setado o diretório de destino opencv_build\install. Para fazer isso, deve-se realizar o comando mingw32-make install


Para finalizar a configuração deve-se colocar no path do sistema o local aonde encontram-se a biblioteca. No caso deste exemplo foi colocado no path o diretório: D:\opencv_build\install\x86\mingw\bin

3. Configuração de uma ferramenta de configuração automática de projetos.

O pkg-config é uma ferramenta utilizada para a configurar qualquer projeto em sistemas Linux. Consegui juntar as algumas bibliotecas para rodar uma versão do pkg-config no Windows. No caso, deve-se colocar os arquivos necessários na pasta do compilador C e também configurar os parâmetros necessários ao PKG-CONFIG.
  1. Faz-se o download do arquivo em dispnível no link Download do PKG-CONFIG 
    Neste existe um executável pkg-config e também um arquivo opencv.pc (este arquivo irá guardar a configuração do seu sistema)
  2. Extrai-se o arquivo para dentro da pasta bin do mingw.
    no caso deste tutorial, c:\MinGW\bin
  3. Depois disso, cria-se uma variável de ambiente PKG_CONFIG_PATH e faz seu valor ser igual a pasta bin do mingw. Exemplo
    PKG_CONFIG_PATH = C:\MinGW\bin
  4. Depois disso, edita-se o arquivo opencv.pc, indicando o local correto do opencv e a versão correta das libs. Compilando a versão do OpenCV conforme realizado neste tutorial, foi gerado o seguinte arquivo opencv.pc
    # Package Information for pkg-config

    includedir=d:/opencv_build/install/include/opencv 
    includedir2=d:/opencv_build/install/include

    Name: OpenCV
    Description: Intel(R) Open Source Computer Vision Library
    Libs: -Ld:/opencv_build/install/x86/mingw/lib -llibopencv_calib3d249 -llibopencv_contrib249 -llibopencv_core249 -llibopencv_features2d249 -llibopencv_flann249 -llibopencv_gpu249 -llibopencv_highgui249 -llibopencv_imgproc249 -llibopencv_legacy249 -llibopencv_ml249 -llibopencv_nonfree249 -llibopencv_objdetect249 -llibopencv_photo249 -llibopencv_stitching249 -llibopencv_video249 -llibopencv_videostab249  

    Cflags: -I${includedir} -I${includedir2} -Wunused-functio

Depois disso, o pkg-config já está configurado. Para testar se o mesmo está configurado corretamente, deve-se abrir o prompt de comando e realizar os comandos, conforme mostrado na figura a seguir: 
  • pkg-config opencv --cflags : para testar se está configurado corretamente as diretrizes de compilação.
  • pkg-config opencv --libs: para testar se está configurado corretamente as diretrizes de linkagem.

Se aparecer as configurações mostradas acima, seu pkg-config está configurado corretamente.

4.Testando a configuração no CMD

Para testar a configuração, cria-se em qualquer pasta o código fonte mostrado a seguir:

teste.cpp : 

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include <iostream>
#include <stdio.h>

using namespace std;
using namespace cv;


int main( int argc, const char** argv )
{
VideoCapture cap(0); // open the default camera
   if(!cap.isOpened())  // check if we succeeded
       return -1;

   Mat edges;
   namedWindow("original",1);
   for(;;)
   {
       Mat frame;
       cap >> frame; // get a new frame from camera
       imshow("original", frame);
       if(waitKey(30) >= 0) break;
   }
   // the camera will be deinitialized automatically in VideoCapture destructor
   return 0;
}

depois disso, vai-se até a pasta do arquivo e insere-se os seguintes comandos:

  • for /f "usebackq tokens=*" %a in (`pkg-config opencv --cflags`) do mingw32-g++ -c test.cpp %a -o main.o
  • for /f "usebackq tokens=*" %a in (`pkg-config opencv --libs`) do mingw32-g++ main.o %a -o test_opencv.exe
Na figura a seguir é mostrado a realização deste teste.

O código tem o objetivo apenas de abrir a câmera e mostrar o quadro adquirido em uma janela.

Codeblocks: Criando um projeto utilizando o OpenCV

postado em 25 de fev de 2012 19:08 por Prof. Rodrigo Costa   [ 4 de dez de 2014 05:30 atualizado‎(s)‎ ]


Após configurar o OpenCV no Windows ou no Linux, conforme descrito em meus posts anteriores. Pode-se utilizar qualquer um dos compiladores e configurar um novo projeto.

Nesta seção é mostrado como realizar isto no CodeBlocks, mas de qualquer forma, o procedimento é similar para os demais compiladores.

Crie um Novo Console Project

Pode ser tanto C ou C++, depende de como você vai utilizar as bibliotecas. Por exemplo, criando um projeto C, você deve inserir as linhas de código para deixá-lo da forma mostrada a seguir.

#include <stdio.h>
#include <stdlib.h>
#include <cv.h>
#include <highgui.h>

int main() 
{
    IplImage * img = cvCreateImage(cvSize(320,240),IPL_DEPTH_8U,3);
    cvNamedWindow("Hello World",0);
    CvFont font;
    cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 1.0, 1.0, 0, 1, CV_AA);
    cvPutText(img, "Rodrigo Costa", cvPoint(10, 130), &font, cvScalar(255, 0,255, 0));
    cvShowImage("Hello World", img);
    cvWaitKey(0);
    cvReleaseImage(&img);
    return 0;
}

Configurando o Projeto

 Se você tentar compilar este código, não vai funcionar pois o comilador não encontrará as chamadas de sistema das bibliotecas do OpenCV. Para configurar isto, você deve ir no menu  Build options, conforme mostrado na figura abaixo. 


Com a janela aberta, você deve inserir as seguintes configurações.
   
 Esta configuração é responsável por configurar as opções de compilação do opencv, indicando o local de onde encontram-se os .h do openc
 Esta configuração é responsável por definir a localização das bibliotecas, vem como definir quais delas são carregadas.




Linux: Instalação do OpenCV no Ubuntu

postado em 24 de fev de 2012 20:23 por Prof. Rodrigo Costa   [ 24 de nov de 2014 14:17 atualizado‎(s)‎ ]

Esta pagina tem como objetivo mostrar as duas formas de instalação do OpenCV no Windows
Se esse tutorial lhe foi útil, clique em curtir!

Forma 1: Baixando os códigos pré-compilados para sua distribuição

Neste caso, os códigos do opencv estão disponíveis no repositório de atualização padrão. Assim, ao realizar o comando:
apt-get install libcv2.1 libcv-dev libcvaux2.1 libcvaux-dev libhighgui2.1 libhighgui-dev opencv-doc python-opencv pkg-config

O openCV e suas dependências são instaladas.

Forma 2: Baixando os códigos fonte atualizado e compilar sua versão mais recente.

Neste caso, é necessário instalar alguns pacotes para compilar a biblioteca e depois instalar os pacotes compilados. Os passos para isto são
  1. sudo apt-get install subversion build-essential cmake pkg-config libavformat-dev libgtk2.0-dev
  2. Baixa-se o opencv para uma pasta:
    svn co https://code.ros.org/svn/opencv/trunk/opencv
  3. Depois disso, é compilar o código
    cd opencv
    mkdir release # cria a pasta que conterá os arquivos compilados
    cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_PYTHON_SUPPORT=ON --with-v4l ..
    make -j
    sudo make install

Após isto a biblioteca está configurada e basta apenas criarmos um projeto.


Testando na linha de comando

cc -c main.c `pkg-config opencv --cflags` main.o
cc main.o `pkg-config opencv --libs` -o test_opencv


1-6 of 6