Introdução ao OpenCV

Prévia do material em texto

ANDERSON PABLO FREITAS EVANGELISTA 
Universidade Estadual do Maranhão 
 
ANTÔNIO IAGO LESMO GASPAR 
Universidade Estadual do Maranhão 
 
CLÁUDIO DIEGO RAMOS 
Universidade Estadual do Maranhão 
PAULO GUSTAVO GONÇALVES DE AGUIAR 
Universidade Estadual do Maranhão 
 
 
 
 
 
 
Engcomp-UEMA 
| Agradecimentos
Agradeço a Deus pelo me dar força diária, aos meus
familiares que tem me dado todo o apoio todos esses
anos e aos professores e colegas que contribuíram de
forma positiva na minha vida acadêmica.
Anderson P. Evangelista
A Deus pela força, a minha esposa e ao meu filho pela
paciência, aos meus pais pela confiança e pelo amor de
todos já citados.
Cláudio D. Ramos
Primeiramente quero agradecer a Deus, pois sem Ele este
trabalho não poderia ser realizado. Agradeço também os
meus pais pela dedicação e pelos ensinamentos que me
trouxeram até este momento de minha vida, e continuam
me guiando por esta grande jornada, e agradeço a todos
os meus amigos e professores por compartilharem suas
jornadas e conhecimentos comigo.
Antônio I. Gaspar
Agradeço a Deus pela oportunidade de participar desse
trabalho e ao apoio da minha família. Ambos são a razão
de todo meu esforço. Não posso deixar de agradecer
também aos companheios de turma e aos professores
cujo apoio também foi fundamental.
Paulo G. Aguiar
| Prefácio
Este trabalho tem como objetivo apresentar a biblioteca OpenCV,
abordando características importantes desta grande ferramenta visando
expor ao leitor uma ideia geral, mostrando sua utilidade para desenvol-
ver aplicações que envolvam visão computacional.
No primeiro capítulo desta obra será mostrada informações im-
portantes da ferramenta, abordando o histórico, mostrando as motiva-
ções para o desenvolvimento da biblioteca. Será mostrado também a
estrutura, trazendo uma breve descrição dos módulos que compõe a bi-
blioteca, como por exemplo o módulo CORE, MACHINE LEARNING,
HIGHGUI entre outros.
No segundo capítulo mostraremos como realizar a instalação da
biblioteca para que seja usada no IDE NetBeans. O passo-a-passo de
instalação será mostrada tando para o sistema operacional WINDOWS
quanto para LINUX.
Do terceiro capítulo em diante será mostrada como criar algumas
aplicações usando as funções do OpenCV, onde será apresentada uma
biblioteca que auxilia na criação de aplicações com OpenCV na lingua-
gem Java, o JavaCV. Esta biblioteca permite ao desenvolvedor usar mé-
todos do OpenCV como se estivesse programando em C++ dentro do
ambiente Java. Nos demais exemplos vamos demonstrar como realizar
algumas transformações numa imagem, realizando mudança no sistema
de cores, como utilizar um dispositivo de vídeo ligado ao computador
com OpenCV e por fim, mostraremos como desenvolver uma pequena
aplicação de detecção de padrões em vídeo.
| Sumário
1 O que é OPENCV? . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.1 A Visão Computacional . . . . . . . . . . . . . . . . . . . . . 11
1.2 Breve Histórico . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3 Módulos do OPENCV . . . . . . . . . . . . . . . . . . . . . 13
1.3.1 Módulo CXCORE . . . . . . . . . . . . . . . . . . . . 13
1.3.1.1 Estrutura Básica . . . . . . . . . . . . . . . 14
1.3.1.2 Operações com Arrays . . . . . . . . . . . . 14
1.3.1.3 Funções de Desenho . . . . . . . . . . . . . 15
1.3.1.4 Persistência XML/YAML . . . . . . . . . . 16
1.3.1.5 Funções do Sistema e Utilidade . . . . . . . 16
1.3.1.6 Clustering . . . . . . . . . . . . . . . . . . . 16
1.3.2 Módulo HIGHGUI . . . . . . . . . . . . . . . . . . . 17
1.3.2.1 Criando uma janela . . . . . . . . . . . . . 18
1.3.3 Módulo ML . . . . . . . . . . . . . . . . . . . . . . . 18
2 Instalando o OPENCV . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1 WINDOWS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.1 Utilizando o OPENCV Com O NETBEANS . . . . . 24
2.2 LINUX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.2.1 Integrando o OpenCV em um projeto Java do Net-
Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3 Interface JavaCV . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1 Exemplo em JavaCV . . . . . . . . . . . . . . . . . . . . . . 33
4 Transformações de Imagens . . . . . . . . . . . . . . . . . . . . . 37
4.1 Exemplo de Aplicação . . . . . . . . . . . . . . . . . . . . . 37
5 Trabalhando com vídeo . . . . . . . . . . . . . . . . . . . . . . . 41
5.1 Código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.1.1 jfmPrincipal . . . . . . . . . . . . . . . . . . . . . . . 41
5.1.2 VideoCaptura . . . . . . . . . . . . . . . . . . . . . . 45
5.1.3 ExibeQuadro . . . . . . . . . . . . . . . . . . . . . . . 47
6 Classificando Padrões em OpenCV . . . . . . . . . . . . . . . . 49
6.1 Classificador em cascata de Haar . . . . . . . . . . . . . . . 49
6.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.2.1 Classe Meu_Painel . . . . . . . . . . . . . . . . . . . 51
6.2.2 Classe Processador . . . . . . . . . . . . . . . . . . . 52
6.2.3 Classe Janela . . . . . . . . . . . . . . . . . . . . . . . 54
6.2.4 Resultado . . . . . . . . . . . . . . . . . . . . . . . . 56
Referências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
*
Lista de ilustrações
Figura 1 – Classe DataType . . . . . . . . . . . . . . . . . . . . . . . 14
Figura 2 – Classe CV_EXPORTS . . . . . . . . . . . . . . . . . . . . 15
Figura 3 – Calculo do módulo dos elementos da matriz . . . . . . 15
Figura 4 – Método de desenho de circulo na imagem . . . . . . . . 16
Figura 5 – Adicionando a biblioteca OPENCV ao path do sistema 19
Figura 6 – Localização da dll do OPENCV . . . . . . . . . . . . . . 20
Figura 7 – Painel de Controle . . . . . . . . . . . . . . . . . . . . . 20
Figura 8 – Propriedades do Sistema . . . . . . . . . . . . . . . . . . 21
Figura 9 – Variáveis do Sistema . . . . . . . . . . . . . . . . . . . . 22
Figura 10 – Editar as variáveis de Sistema . . . . . . . . . . . . . . . 23
Figura 11 – Adicionando nova variável ao sistema . . . . . . . . . . 24
Figura 12 – Adicionando as bibliotecas . . . . . . . . . . . . . . . . 24
Figura 13 – Adicionando o arquivo .jar ao projeto . . . . . . . . . . 25
Figura 14 – Adicionando arquivo .jar ao projeto . . . . . . . . . . . 26
Figura 15 – Diretório de bibliotecas de um projeto. . . . . . . . . . . 29
Figura 16 – Criando a biblioteca para o NetBeans . . . . . . . . . . 29
Figura 17 – Adicionando o pacote.jar do OpencV para Java. . . . . 30
Figura 18 – Downloda do JavaCV . . . . . . . . . . . . . . . . . . . 31
Figura 19 – Diretório de bibliotecas. . . . . . . . . . . . . . . . . . . 32
Figura 20 – Sessão bibliotecas. . . . . . . . . . . . . . . . . . . . . . . 32
Figura 21 – Resultado do código em JavaCV . . . . . . . . . . . . . 35
Figura 22 – Transformações de imagem . . . . . . . . . . . . . . . . 40
Figura 23 – Captura de vídeo . . . . . . . . . . . . . . . . . . . . . . 48
Figura 24 – Extração de características . . . . . . . . . . . . . . . . . 50
Figura 25 – detecção de faces . . . . . . . . . . . . . . . . . . . . . . 56
11
1 || O que é OPENCV?
O OpenCV é uma biblioteca de visão computacional que provê
uma infraestrutura para desenvolvimento de aplicações na área de visão
computacional de forma simples e rápida. A biblioteca possui diver-
sos algoritmos que envolvem processamento de imagens e aprendizado
de máquina, este último geralmente voltado para o reconhecimento de
padrões.
1.1 | A Visão Computacional
Visão computacional é a área de estudo que tem por objetivo extrair
informações relevantes a partir de imagens. Essas imagens podem ser
obtidas de diversas formas: uma câmera fotográfica, um raio-X, uma
ressonância magnética, um espectogramado som, dentre outras fontes.
O ser humano possui um complexo sistema que permite interpretar
alguma informação através de uma imagem. A luz entra pela íris, e
atinge o fundo do olho, onde estão localizados os cones e bastonetes,
responsáveis por capturar a frequência da faixa luminosa e gerar um
impulso elétrico para o cérebro. O cérebro recebe o impulso e interpreta
como uma cor. A imagem é então formada no cérebro, que através do
seu repositório de informações associadas, fornece uma interpretação
para a imagem visualizada.
A máquina apenas enxerga números. Ela não possui a capacidade
nativa de interpretar cores e realizar associações. Portanto, cabe aos de-
senvolvedores utilizarem técnicas de análise de imagem e aprendizado
de máquina para processar a imagem, retirar dados e por fim gerar uma
12 Capítulo 1. O que é OPENCV?
informação relevante. Em relação a esse pensamento, o OpenCV é uma
ferramenta bastante completa, pois ela nos fornece métodos tanto para
análise de imagens como para aprendizado de máquina. O desenvolve-
dor não necessita recorrer a outras bibliotecas.
1.2 | Breve Histórico
O OpenCV cresceu em uma iniciativa do setor de pesquisa da Intel
que trabalhava com aplicações que utilizam intensamente a CPU. Eles
trabalhavam especificamente com ray-tracing em tempo real e retropro-
jetores. Na época, um dos pesquisadores visitou algumas das grandes
universidades do mundo, como MIT por exemplo, e descobriu que os
alunos desenvolviam uma infraestrutura para visão computacional de
forma interessante: os novos estudantes recebiam os códigos desenvol-
vidos e incrementavam novas funcionalidade ou então corrigiam fun-
cionalidades existentes, não era necessário reinventar a roda. Portanto,
o OpenCV seguiu o mesmo raciocínio: não era necessário reinventar a
roda, mas sim incrementar a biblioteca de forma que pudesse ser uni-
versalmente utilizada. Assim, o OpenCV começou com um núcleo de
códigos que foi enviado para o time de desenvolvimento da Rússia, onde
o OpenCV propriamente dito originou. Pode-se citar três pessoas que
contribuíram enormemente para o desenvolvimento da biblioteca: Va-
dim Pisarevsky, que gerenciou, codificou e otimizou uma grande parte da
biblioteca; Victor Eruhimov, que desenvolveu a infraestrutura e Valerya
Kuriakin, que gerenciou o laboratório russo e contribuiu enormemente
para o projeto.
Podemos descrever três objetivos da biblioteca, que definem o
porquê de se utilizar o OpenCV como ferramenta para visão compu-
tacional:
1. Avançar em pesquisas em relação a visão computacional através
do fornecimento de uma ferramenta aberta e otimizada. Não é
necessário reinventar a roda;
1.3. Módulos do OPENCV 13
2. Disseminar o conhecimento sobre visão computacional provendo
uma infraestrutura onde desenvolvedores podem trabalhar, tor-
nando o código mais transferível e legível;
3. Avançar no desenvolvimento de aplicações comerciais baseadas em
visão computacional através da construção de um código portátil e
otimizado gratuito, independente de outras aplicações comerciais
para realizar a tarefa.
1.3 | Módulos do OPENCV
A biblioteca do OpenCV conta com um conjuntos de módulos que
podem ser usados para auxiliar no desenvolvimentos de aplicações de
visão computacional.
1.3.1 | Módulo CXCORE
O módulo Core é o núcleo do OpenCV, pois possui estruturas e
funções que são utilizadas por todos os outros módulos da biblioteca.
Módulo compacto que define as estruturas de dados básicas, incluindo
o array multidimensional Mat. É possível dividir seus arquivos fontes
de acordo com a finalidade:
1. Estruturas Básicas;
2. Operações com Arrays;
3. Funções de Desenho;
4. Persistência XML/YAML;
5. Clustering;
6. Funções do Sistema e de Utilidade;
7. Interoperabilidade OpenGL.
14 Capítulo 1. O que é OPENCV?
1.3.1 | Estrutura Básica
As estruturas básicas do módulo Core são referentes às definições
dos objetos, classes, atributos e funções que serão manipulados e/ou
executarão as operações do cerne da biblioteca. Como exemplo, pode-se
citar a classe DataType que serve para oferecer uma descrição dos dados
primitivos, como mostra a figura abaixo:
Figura 1 – Classe DataType
Além desta classe, se encontra a Point_ (que descreve um ponto no
plano cartesiano), a Point3_ (ponto 3D), Size, entre outras, como a classe
Mat que define um array denso numérico n-dimensional single-channel
ou multi-channel, o qual por sua vez, poderá ser usado para armazenar
imagens na forma de matriz.
O módulo possui uma API para linguagem C com classes corres-
pondentes às supracitadas: CvPoint, CvPoint3D32f, CvSize.
1.3.1 | Operações com Arrays
Parte do módulo Core que possui um conjunto de métodos para
operações com vetores, matrizes, etc. Um exemplo é o método Abs que
determina o módulo de cada elemento da matriz.
1.3. Módulos do OPENCV 15
Figura 2 – Classe CV_EXPORTS
Figura 3 – Calculo do módulo dos elementos da matriz
Dentre outras funções, além do Abs, é possível utilizar Absdiff,
Add, etc.
1.3.1 | Funções de Desenho
As funções de desenho trabalham com matrizes/imagens de pro-
fundidade arbitrária. Todas as funções incluem o parâmetro color que
16 Capítulo 1. O que é OPENCV?
usa um valor RGB para imagens coloridas e um valor brilho pra imagens
em escala de cinza. Abaixo, encontra-se a descrição do comando circle
que desenha um circulo na figura em questão.
Figura 4 – Método de desenho de circulo na imagem
Outros exemplos de comandos de desenho são clipLine e Ellipse.
1.3.1 | Persistência XML/YAML
O módulo Core também dispõe de funções para armazenamento e
leitura de informações em estruturas de dados nos formatos XML/YAML.
1.3.1 | Funções do Sistema e Utilidade
Conjunto de métodos básicos utilizados pelos demais métodos em
tarefas como: ajuste de ponteiros, alocamento de memória, alinhar ta-
manho de buffer, etc.
1.3.1 | Clustering
Métodos utilizados para agrupamento são importantíssimos na
atualidade, principalmente quando se fala de visão computacional. Um
1.3. Módulos do OPENCV 17
dos métodos de agrupamento abrangidos pelo OpenCV faz parte do
módulo core: Kmeans.
1.3.2 | Módulo HIGHGUI
O OpenCV fornece funções que auxiliam na interação com arqui-
vos e hardware do sistema operacional. Estas funções estão agrupadas
no módulo Highgui(“High Level Graphical User Interface”). Através
desse módulo, podemos criar janelas, visualizar, ler e editar arquivos de
imagem e vídeo, manipular componentes de hardware como webcans e
câmeras e manipular também eventos do mouse e do teclado.
Podemos subdividir o módulo Highgui em três partes: a parte que
trata do hardware, a parte que trata dos arquivos e a parte que trabalha
com os componentes GUI. Vamos analisar cada cada uma dessas partes
para melhor entender como o módulo funciona.
A parte de hardware basicamente foi concebida para operar com
câmeras. Utilizar esse recurso do computador geralmente é tedioso e
trabalhoso, mas os componentes de hardware do Highgui proporcionam
métodos simples de buscar as câmeras disponíveis no sistema e utilizá-
las, por exemplo, para aquisição de imagens. Toda a parte trabalhosa é
abstraída pelo OpenCV.
Os componentes que tratam de arquivos de áudio e vídeo têm como
objetivo carregar e salvar arquivos. Uma característica interessante é que
os métodos para ler um arquivo de vídeo são os mesmo utilizados para
ler dados vindos da câmera, ou seja, ler o vídeo da câmera.
A terceira parte que trata dos componentes GUI provê métodos
que permitem criar janelas para a visualização de dados gráficos na tela.
Permite também detectar e tratar eventos relacionados ao mouse e ao
teclado. Podemos criar rotinas que sejam invocadas a partir dos eventos
capturados, proporcionando diversas alternativas de implementações
utilizando apenas os componentes GUI do OpenCV.
18 Capítulo 1. O que éOPENCV?
1.3.2 | Criando uma janela
Primeiramente, devemos compreender como criar uma janela e,
a partir dela, mostrar o conteúdo gráfico que queremos. Para criar
uma janela utilizando o JavaCV, utilizaremos a classe CanvasFrame, do
pacote org.bytedeco.javacv. A seguir temos o código básico para criar
uma janela:
CanvasFrame cf = new CanvasFrame("Digite o título da janela
aqui!"); cf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Criamos o objeto que será nossa janela e passamos para o construtor
uma String que representa o título da janela. Após, definimos que a
aplicação encerrará fechando a janela. Podemos utilizar a constante
estática definida na classe JFrame, contida no pacote javax.swing.
Para redimensionar a janela, podemos utilizar o seguinte método
do objeto CanvasFrame:
cf.setCanvasSize(int width, int height) Onde definimos a largura e
a altura desejada.
1.3.3 | Módulo ML
Em muitas aplicações de visão computacional, não se tem um tipo
de classificador pronto para está atuando sobre o conjunto de imagens
que se quer trabalhar, nesses casos é necessário desenvolver o classifica-
dor que se adeque a aplicação.
No OPENCV módulo de Machine Learning, ou ML, onde há im-
plementado diversos tipos de algoritmos de aprendizado de máquina
como:
• Aprendizagem supervisionado;
• Aprendizagem não-supervisionado;
• Métodos estatísticos, entre outros.
19
2 || Instalando o OPENCV
Nessa capítulo vamos estar abordando as forma de se utilizar as
bibliotecas do OPENCV nos sistemas operacionais Windows e Linux.
2.1 | WINDOWS
Para fazer o download do OpenCV para Windows basta acessar a
página <http://opencv.org/downloads.html> e selecionar a versão ade-
quada. A versão que será utilizada neste tutorial é a versão 2.4.9, obvia-
mente para Windows. O arquivo baixado será um arquivo compactado
executável, ou seja, assim que executado irá solicitar um local para ar-
mazenar os arquivos nele compactado. O que será descompactado é
uma pasta com os arquivos referentes à biblioteca do OpenCV. Indica-
se armazenar a pasta com a biblioteca na unidade C: conforme figura
abaixo.
Figura 5 – Adicionando a biblioteca OPENCV ao path do sistema
20 Capítulo 2. Instalando o OPENCV
Uma vez que a pasta estiver na unidade C: abra a pasta “opencv”.
Dentro da pasta opencv, abra a pasta “build”. Dentro desta última, abra
a pasta “java”. Por fim, abra a pasta x86. Abaixo uma imagem desta
última pasta e uma ênfase no endereço desta. Copie o caminho da barra
de endereços. Se o pasta da biblioteca estiver salva com o nome opencv
e na raiz da unidade C: o caminho será “C:\opencv\build\java\x86”.
Guarde-o, pois esse caminho será adicionado ao Path do sistema. Após
a imagem, um passo a passo de como fazê-lo.
Figura 6 – Localização da dll do OPENCV
Na barra de endereços, digite “Painel de Controle\Sistema e Segurança\Sistema”
e confirme. Neste ponto, aparecerão as informações do computador. A
esquerda acima, selecione a opção configurações avançadas do sistema,
conforme figura abaixo.
Figura 7 – Painel de Controle
Tendo clicada na opção acima destacada, aparecerá a janela “Pro-
priedades do sistema”. Selecione a aba “Avançado” e clique no botão
“Variáveis de ambiente...” conforme imagem abaixo.
2.1. WINDOWS 21
Figura 8 – Propriedades do Sistema
Tendo clicada na opção acima destacada, aparecerá a janela “Pro-
priedades do sistema”. Selecione a aba “Avançado” e clique no botão
“Variáveis de ambiente...” conforme imagem abaixo.
22 Capítulo 2. Instalando o OPENCV
Figura 9 – Variáveis do Sistema
Uma nova janela com nome “Variáveis de Ambiente” abrirá com
duas tabelas. Na tabela “Variáveis do sistema” selecione a variável
“Path” e após selecioná-la clique no botão “Editar...” , conforme figura a
seguir.
2.1. WINDOWS 23
Figura 10 – Editar as variáveis de Sistema
Uma nova janela com nome “Editar Variável do Sistema” se abrirá.
Esta janela terá dois campos de texto, “Nome da variável” e “Valor
da variável”. Após o último caractere do campo “Valor da variável”,
acrescente um ponto e vírgula. Lembra que no início deste tópico foi
solicitado para guardar um determinado caminho? Essa é a hora de
usar. Cole-o sem espaços após o ponto e vírgula. Deverá ficar algo como
a figura abaixo.
Por fim, pressione os botões OK das janelas anteriormente abertas
para confirmar a operação. A seguir, como utilizar o OpenCV em um
projeto utilizando o Netbeans IDE 8.0.1.
24 Capítulo 2. Instalando o OPENCV
Figura 11 – Adicionando nova variável ao sistema
2.1.1 | Utilizando o OPENCV Com O NETBEANS
Tendo adicionado o OpenCV ao Path do sistema, agora é hora
de adicioná-lo a um projeto. Não é proposta deste tutorial ensinar a
criar um projeto no Netbeans. Com um projeto já criado, clique com o
botão direito do mouse sobre o ícone do projeto na bandeja de projetos
do Netbeans, conforme figura abaixo. Neste tutorial o projeto tem por
nome “ProjetoComOpenCV”. Clique então na opção “Propriedades”.
Figura 12 – Adicionando as bibliotecas
Abrirá, então, a janela “Propriedades do Projeto - <Nome do Pro-
2.2. LINUX 25
jeto>”. À esquerda, em “Categorias:”, clique em “Bibliotecas”. Em
seguida clique em “Adicionar JAR/Pasta” à direita da janela conforme a
figura seguinte.
Figura 13 – Adicionando o arquivo .jar ao projeto
Uma vez que o botão for selecionado, uma janela de procura abrirá.
Os passos seguintes são parecidos com o passo para encontrar o caminho
do Path no tópico anterior, exceto pelo fato de NÃO entrar na pasta
“x86”. Assim, os passos são os seguintes: vá até a pasta que armazena a
biblioteca OpenCV e abra a pasta “opencv”. Dentro da pasta opencv, abra
a pasta “build”. Dentro desta última, abra a pasta “java”. Se a biblioteca
estiver na raiz da unidade C: o caminho será “C:\opencv\build\java”.
Agora selecione o arquivo opencv-249.jar e confirme. Na figura abaixo
a pasta do caminho citado aberta e ênfase no arquivo a ser selecionado e
no caminho para chegar ao arquivo.
2.2 | LINUX
Tutorial de instalação do OpencCV no linux e integrando ao Net-
beans
26 Capítulo 2. Instalando o OPENCV
Figura 14 – Adicionando arquivo .jar ao projeto
Este tutorial foi realizado no sistema operacional Ubuntu 14.04
LTS com a versão 2.4.9 do OpenCV. Utilizamos a versão 8.0.1 do Net-
beans, disponível para download no seguinte site, juntamente com o jdk:
<http://www.oracle.com/technetwork/pt/java/javase/downloads/index.html>.
Primeiramente abra o terminal utilizando o atalho Crtl+Alt+t(não
utilize o AltGr). Vamos atualizar os pacotes instalados no linux utili-
zando os seguintes comandos:
$ sudo apt-get update
$ sudo apt-get upgrade
Necessitamos instalar vários pacotes que ajudarão na compilação
dos arquivos do OpenCV, na leitura e escrita de imagens, na criação de
janelas, dentre outras dependências. Para instalar esses pacotes, digite a
seguinte linha de comando no terminal. Forneça a senha e a confirmação
de instalação e então o processo começará. De acordo com a velocidade
da sua conexão, este processo pode demorar ou não.
$sudo apt-get install build-essential libgtk2.0-dev libjpeg-dev
libtiff4-dev libjasper-dev libopenexr-dev cmake python-dev python-numpy
python-tk libtbb-dev libeigen3-dev yasm libfaac-dev libopencore-amrnb-dev
libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev
libx264-dev libqt4-dev libqt4-opengl-dev sphinx-common texlive-latex-extra
2.2. LINUX 27
libv4l-dev libdc1394-22-dev libavcodec-dev libavformat-dev libswscale-dev
default-jdk ant libvtk5-qt4-dev
Após o término da instalação dos pacotes, vamos baixar o OpenCV para o linux.
Navegue até o diretório em que você deseja salvar o OpenCV através do terminal e
execute o seguinte comando. Neste tutorial salvamos o OpenCV no diretório pessoal,
o :
$cd ~
$wget http://sourceforge.net/projects/opencvlibrary/
files/opencv-unix/2.4.9/opencv-2.4.9.zip$unzip opencv-2.4.9.zip
$cd opencv-2.4.9
Vamos criar um diretório que conterá o makefile do OpenCV, um arquivo que
contém configurações de como o OpenCV deve ser compilado. O comando a seguir gera
um makefile proporcionando ao desenvolvedor compilar o OpenCV para python, Java,
TBB, OpenGL, Qt e trabalhar com videos. Portanto, no terminal, digite as seguintes
linhas de comando:
$mkdir build_x000D_$cd build_x000D_$cmake -D WITH_TBB=ON
-D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D
INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON
-D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON
-D WITH_VTK=ON ..
Como o diretório build foi criado dentro do diretório do OpenCV, informamos
ao cmake que queremos gerar o makefile do diretório pai através dos dois pontos no
final.
Verifique se ocorreu algum erro e se os seguintes módulos serão compilados (na
linha to be built):
core flann imgproc highgui features2d calib3d ml video legacy objdetect photo
gpu ocl nonfree contrib java python stitching superres ts videostab viz.
Caso aconteca algum erro, volte e corrija-os. Geralmente a instalação de depen-
dências soluciona alguns erros.
Após tudo corretamente solucionado e o makefile construido, podemos instalar
o OpenCV. Dentro do diretório build, execute os comandos:
28 Capítulo 2. Instalando o OPENCV
$make $sudo make install
O OpenCV está instalado no Ubuntu. Agora vamos configurar o OpenCV. No
terminal, abra o arquivo opencv.conf com o seguinte comando:
$sudo gedit /etc/ld.so.conf.d/opencv.conf
Não se preocupe se o arquivo estiver vazio. Digite a seguinte linha e salve o
arquivo(caso tenha algum conteúdo, não apague. Digite a linha e salve o arquivo):
/usr/local/lib
Feche o arquivo e, no terminal, execute o seguinte comando para configurar a
biblioteca do OpenCV:
$sudo ldconfig
Vamos abrir outro arquivo, onde colocaremos as bibliotecas do OpenCV no
PATH do sistema. Execute o seguinte comando:
$sudo gedit /etc/bash.bashrc
Adicione essas duas linhas e salve o arquivo:
$PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig_x000D_export
PKG_CONFIG_PATH
Feche o terminal e abra novamente. O OpenCV agora está funcionando correta-
mente. Para testar se está tudo normal, vamos executar um exemplo. Primeiramente,
no terminal, execute as seguintes comandos:
$cd /opencv-2.4.9/samples/c_x000D_$chmod +x build_all.sh_x000D_$./build_all.sh
Agora execute o seguinte comando. Este abrirá um programa em C que detecta
a face de uma foto:
\$./facedetect--cascade=
"/usr/local/share/OpenCV/haarcascades/haarcascade_frontalface\_alt.xml"
--scale=1.5 lena.jpg
2.2.1 | Integrando o OpenCV em um projeto Java do Net-
Beans
Abra o NetBeans e crie um projeto Java. O projeto contém um diretório chamado
bibliotecas. Clique com o botão direito e clique em adicionar uma biblioteca.
2.2. LINUX 29
Figura 15 – Diretório de bibliotecas de um projeto.
Clique na opção criar. Ele solicitará um nome para a biblioteca, informe o nome
e prossiga.
Figura 16 – Criando a biblioteca para o NetBeans
Na janela que aparecer, clique em adicionar Jar/pasta. O caminho que está o
arquivo jar é: o_diretorio_que_esta_o_opencv_descompactado/build/bin. Selecione o
arquivo opencv-249.jar e confirme as operações. Na lista de bilbiotecas agora consta a
biblioteca do OpenCV com o nome escolhido por você. Basta seleciona-la e confirmar.
Pronto! Agora você pode usar o OpenCV com a linguagem Java.
30 Capítulo 2. Instalando o OPENCV
Figura 17 – Adicionando o pacote.jar do OpencV para Java.
31
3 || Interface JavaCV
O JavaCV é uma interface bastante útil para desenvolvedores da linguagem
Java: ela encapsula as bibliotecas nativas do OpenCV para o ambiente Java. Assim,
o desenvolvedor pode utilizar métodos escritos originalmente para a linguagem C++
em seus projetos Java.
Para instalar o JavaCV no Linux, acesse o seguinte site que contém os binários
da interface: <https://github.com/bytedeco/javacv>. Baixe o arquivo javacv-<versão>-
bin.zip e extraia-o em um diretório em que você não irá alterar. Atenção! Antes de
instalar o JavaCV, é muito importante que você instale a biblioteca do OpenCV, pois o
JavaCV necessita dos arquivos definidos nela para executar. Quando você terminar a
instalação do OpenCV, continue lendo este tutorial.
Figura 18 – Downloda do JavaCV
Abra o NetBeans, selecione o projeto desejado e no diretório de bibliotecas,
clique com o botão direito sobre ele e selecione propriedades:
32 Capítulo 3. Interface JavaCV
Figura 19 – Diretório de bibliotecas.
Na janela que abrir, acesse a opção bibliotecas e selecione a opção “Adicionar
JAR/Pasta”:
Figura 20 – Sessão bibliotecas.
Navegue até o diretório que você descompactou o arquivo baixado. Selecione
os arquivos que correspondem ao seu sistema operacional(se você possui um sistema
operacional 32bits, selecione os arquivos com terminação x86; caso contrário, se o
sistema operacional for 64bits, selecione os arquivos com terminação x86_64). Selecione
também os arquivos que não possuem a especificação do sistema operacional.
Para a versão 0.9 do JavaCV, foram selecionados os seguintes arquivos:
3.1. Exemplo em JavaCV 33
1. artoolkitplus-linux-x86_64.jar
2. artoolkitplus.jar
3. ffmpeg-linux-x86_64.jar
4. ffmpeg.jar
5. flycapture-linux-x86_64.jar
6. flycapture.jar
7. javacpp.jar
8. javacv.jar
9. libdc1394-linux-x86_64.jar
10. libdc1394.jar
11. libfreenect-linux-x86_64.jar
12. libfreenect.jar
13. opencv-linux-x86_64.jar
14. opencv.jar
Pronto! Você já está apto a programar em Java como se estivesse programando
em C++!
3.1 | Exemplo em JavaCV
Vamos implementar o seguinte exemplo para testar a instalação do JavaCV. Ao
executar, irá aparecer uma janela com a imagem que você escolheu para executar. Segue
abaixo o código:
import org.bytedeco.javacv.Blobs;
import org.bytedeco.javacv.CanvasFrame;
import static org.bytedeco.javacpp.opencv_core.*;
import static org.bytedeco.javacpp.opencv_highgui.*;
import static org.bytedeco.javacpp.opencv_imgproc.*;
34 Capítulo 3. Interface JavaCV
public class LoadImage {
public static void main(String[] args) {
IplImage image = cvLoadImage("coloque o caminho da imagem
aqui!!!");
showImage(image,"Legenda da imagem!!!");
}
//Funcao que mostra uma imagem no display.
public static void showImage(IplImage image, String legenda) {
//Obtendo a versao matricial da imagem.
CvMat mat = image.asCvMat();
//Obtendo a largura da matriz;
int largura = mat.cols();
if(largura < 1) largura = 1;
//Obtendo a altura da matriz;
int altura = mat.rows();
if(altura < 1) altura = 1;
//Tela que vai aparecer a imagem;
CanvasFrame canvas = new CanvasFrame(legenda);
canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
//Definindo o tamanho da tela;
canvas.setCanvasSize(largura, altura);
canvas.showImage(image);
}
}
3.1. Exemplo em JavaCV 35
Ao executar o projeto acima será mostrada a seguinte janela, onde a imagem
será uma que você definiu no código:
Figura 21 – Resultado do código em JavaCV
37
4 || Transformações de Imagens
Neste tópico iremos estar aprendendo como realiza algumas transformações em
imagens, pois para melhor solução dos problemas de visão computacional nem sempre
irão trabalhar com as imagens originais.
O OpenCV contém um pacote que provê funções para estarmos realizando essas
transformações, o “imgproc”. A tabala abaixo mostra algumas funções de transforma-
ção de imagens:
Tabela 1 – Métodos de transformação de imagens
4.1 | Exemplo de Aplicação
Agora vamos ver como aplicar uma dessas funções. No código abaixo iremos
pegar uma imagem do computador e fazer a transformação da imagem do padrão RGB
para o padrão HSV, onde esse padrão armazena a matiz (Hue), saturação(Saturation)
e ovalor (Value) de cada pixel da imagem.
38 Capítulo 4. Transformações de Imagens
Código:
package Window;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.File;
import javax.imageio.ImageIO;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgproc.Imgproc;
public class convertImagem {
public static void main(String[] args) {
try {
System.loadLibrary("opencv_java249");
//carrega o caminho da imagem
File arquivo = new File("D:\\Livros\\visão
computacional\\cartilha OPENCV\\iago.jpg");
//carrega a imagem
BufferedImage image = ImageIO.read(arquivo);
//guardando ao dados(pixels) da imagem em bytes
byte[] data = ((DataBufferByte) image.getRaster().
getDataBuffer()).getData();
//cria uma matris do tamanho da imagem
Mat mat = new Mat(image.getHeight(), image.getWidth(),
CvType.CV_8UC3);
//adicionando elementos da imamgem na matriz
mat.put(0, 0, data);
//criando a matriz que guardará a conversao da imagem
//onde o CV_8C3 significa que será uma imagem de inteiro de
8 bits
//com tres canais
//para converter para imagem em escala de cinza
//mudar para CV_8UC1
Mat mat1 = new Mat(image.getHeight(), image.getWidth(),
CvType.CV_8UC3);
//convertendo a imagem em RGB para HSV
4.1. Exemplo de Aplicação 39
//para converter para escala de cinza colocar COLOR_RGB2GRAY
Imgproc.cvtColor(mat, mat1, Imgproc.COLOR_RGB2HSV);
//guardando dados da nova imagem
byte[] data1 = new byte[mat1.rows() * mat1.cols() * (int)
(mat1.elemSize())];
mat1.get(0, 0, data1);
//criando uma nova imagem
//para imagem em escala de cinza colocar no lugar do 5
//BufferedImage.TYPE_BYTE_GRAY
BufferedImage image1 = new BufferedImage(mat1.cols(),
mat1.rows(), 5);
//colocando os dados na matriz (pixels)
image1.getRaster().setDataElements(0, 0, mat1.cols(),
mat1.rows(), data1);
//salvando a imagem numa pasta
File ouptut = new File("D:\\Livros\\visão
computacional\\cartilha OPENCV\\nome_arquivo.jpg");
ImageIO.write(image1, "jpg", ouptut);
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
}
40 Capítulo 4. Transformações de Imagens
Ao executar o código acima teremos os seguintes resultados:
(a) RGB
(b) espaço HSV
(c) escala de cinza
Figura 22 – Transformações de imagem
41
5 || Trabalhando com vídeo
Neste exemplo vamos ver como se utiliza uma câmera conectada ao computador.
Para desenvolver o exemplo iremos precisar de 3 classes:
1. jfmPrincipal: esta classe é responsável por criar a janela da aplicação juntamente
com os botoes e eventos relacionados e outros elementos da janela. O botão iniciar
da aplicação inicia o vídeo na janela do programa, já o botão de para suspende
o redesenho do painel, deixando a imagem estática até reabilitar a atualizações
da imagem.
2. VideoCaptura: classe responsável criar o objeto que realiza a captura do vídeo
da webcam ligada ao PC.
3. ExibeQuadro: Inicia o processo de desenhar a imagem da webcam no painel da
janela da aplicação.
5.1 | Código
Agora vamos mostrar o código da aplicação.
5.1.1 | jfmPrincipal
package opencvwebcam2;
import javax.swing.Icon;
import javax.swing.ImageIcon;
public class jfmPrincipal extends javax.swing.JFrame {
VideoCaptura webCam; //Objeto para captura do quadro da webcam
42 Capítulo 5. Trabalhando com vídeo
ExibeQuadro exibeQuadro; //Objeto para exibição do quadro
Thread executor; //Thread em que será executada a aplicação
public jfmPrincipal() {
initComponents();
}
@SuppressWarnings("unchecked")
private void initComponents() {
//criando os componentes da janela
jbtIniciar = new javax.swing.JButton();
jbtParar = new javax.swing.JButton();
jspCaptura = new javax.swing.JScrollPane();
jlbCaptura = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("Video OPENCV");
//setando o evento aos botoes da aplicacao
jbtIniciar.setText("Iniciar");
jbtIniciar.addActionListener(new java.awt.event.ActionListener()
{
public void actionPerformed(java.awt.event.ActionEvent evt) {
jbtIniciarActionPerformed(evt);
}
});
jbtParar.setText("Para");
jbtParar.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jbtPararActionPerformed(evt);
}
});
jspCaptura.setPreferredSize(new java.awt.Dimension(646, 485));
jlbCaptura.setPreferredSize(new java.awt.Dimension(640, 480));
jspCaptura.setViewportView(jlbCaptura);
5.1. Código 43
javax.swing.GroupLayout layout = new
javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout. reateParallelGroup (javax.swing.
GroupLayout.Alignment.LEADING)
.addComponent(jspCaptura,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGroup(layout.createSequentialGroup()
.addComponent(jbtIniciar)
.addPreferredGap( javax.swing.
LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jbtParar)))
.addContainerGap( javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(
javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing. GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addContainerGap()
.addComponent(jspCaptura, javax.swing.
GroupLayout.DEFAULT_SIZE, 486, Short.MAX_VALUE)
.addPreferredGap(javax.swing.
LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(layout. createParallelGroup(javax.swing.
GroupLayout.Alignment.BASELINE)
.addComponent(jbtIniciar)
.addComponent(jbtParar))
.addContainerGap())
);
pack();
}
44 Capítulo 5. Trabalhando com vídeo
//evento o botao iniciar
private void jbtIniciarActionPerformed(java.awt.event.ActionEvent
evt) {//GEN-FIRST:event_jbtIniciarActionPerformed
webCam = new VideoCaptura();
exibeQuadro = new ExibeQuadro(webCam,jlbCaptura);
executor = new Thread(exibeQuadro);
executor.start();
}
//evento de para a captura de video
private void jbtPararActionPerformed(java.awt.event.ActionEvent
evt) {//GEN-FIRST:event_jbtPararActionPerformed
executor.suspend();
}
public static void main(String args[]) {
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(jfmPrincipal.class.
getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(jfmPrincipal.class.
getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(jfmPrincipal.class.
getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(jfmPrincipal.class.
getName()).log(java.util.logging.Level.SEVERE, null, ex);
5.1. Código 45
}
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new jfmPrincipal().setVisible(true);
}
});
}
//declarando as variaveis
private javax.swing.JButton jbtIniciar;
private javax.swing.JButton jbtParar;
private javax.swing.JLabel jlbCaptura;
private javax.swing.JScrollPane jspCaptura;
}
5.1.2 | VideoCaptura
package opencvwebcam2;
import java.awt.image.BufferedImage;import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.highgui.VideoCapture;
//classe responsavel pela captura do video
public class VideoCaptura {
VideoCapture video; //variável do tipo VideoCapture para utilização
do vídeo
Mat imageMat = new Mat();//Variável do tipo Mat para utilização do
opencv na captura de imagens
BufferedImage imageBuffer; //Imagem BufferedImage para exibição
byte[] dat;
public VideoCaptura(){
this.video = new VideoCapture();
this.video.open(0); //Habilita a utilização da câmera
}
46 Capítulo 5. Trabalhando com vídeo
public BufferedImage capturaQuadroBufferedImage(){
this.video.read(this.imageMat); //Captura o quadro
imageBuffer = this.matToBufferedImage(this.imageMat); //Converte
para imageBuffer
return imageBuffer;
}
public Mat capturaQuadroMat(){
this.video.read(this.imageMat); //Captura o quadro
return imageMat;
}
public BufferedImage matToBufferedImage(Mat matrix) { //Método de
conversão do tipo Mat para BufferedImage
int cols = matrix.cols();
int rows = matrix.rows();
int elemSize = (int)matrix.elemSize();
byte[] data = new byte[cols * rows * elemSize];
int type;
matrix.get(0, 0, data);
switch (matrix.channels()) {
case 1:
type = BufferedImage.TYPE_BYTE_GRAY; //verificação se a imagem
está em escala de cinza
break;
case 3:
type = BufferedImage.TYPE_3BYTE_BGR; //caso a imagem éuma
imagem colorida
// bgr para rgb
byte b;
for(int i=0; i<data.length; i=i+3) {
b = data[i];
data[i] = data[i+2];
data[i+2] = b;
}
break;
default:
return null;
5.1. Código 47
}
BufferedImage image = new BufferedImage(cols, rows, type);
image.getRaster().setDataElements(0, 0, cols, rows, data);
return image;
}
static{
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
}
}
5.1.3 | ExibeQuadro
package opencvwebcam2;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
//classe que exibe a imagem na aplicacao
public class ExibeQuadro implements Runnable {
VideoCaptura webCam;
JLabel jlbQuadro;
int cont =1;
public ExibeQuadro(VideoCaptura cam, JLabel label){ //Método de
recepcao dos parametros
this.webCam = cam; //objeto VideoCaptura
this.jlbQuadro = label;//Objeto JLabel
}
@Override
public void run() { //Metodo de exibicao da janela propriamente dita
48 Capítulo 5. Trabalhando com vídeo
while(webCam.video.isOpened()){
Icon icon = new
ImageIcon(webCam.capturaQuadroBufferedImage());
this.jlbQuadro.setIcon(icon);
this.jlbQuadro.repaint();
try {
Thread.sleep(150);
} catch (InterruptedException ex) {
Logger.getLogger(ExibeQuadro.class.getName()).log(Level.SEVERE,
null, ex);
}
}
}
}
Ao executar o projeto o resultado será o seguinte:
Figura 23 – Captura de vídeo
49
6 || Classificando Padrões em OpenCV
Neste caso iremos desenvolver nosso primeiro sistema de visão computacional.
O sistema que será desenvolvido realizará um reconhecimento de padrões na imagem,
assim podendo destacar objetos, letras e seres humanos.
O processo de reconhecimento de padrões em imagem se dá nos seguintes
passos:
• Capturar imagem, seja arquivo digital ou vídeo;
• Tratamento da imagem para o reconhecimento;
• Utilização de um classificador de padrão;
• Destacar o padrão reconhecido na imagem....
Para este problema, iremos captar a imagem de vídeo, como já aprendemos em
estudos anteriores.
O tratamento de imagem varia de situação para situação, então dependendo do
que se deseja e como se quer resolver, deve-se aplicar um tratamento que otimize o
processo. Neste exemplo vamos pegar a imagem da câmera e convertê-la em uma de
tons de cinza de após será feita a equalização de histograma para a análise da imagem.
A etapa mais importante de um sistema de visão computacional é a de classi-
ficação de padrão, nela que é realizada a análise da imagem e é feita o destaque dos
padrões reconhecidos. Há vários tipos desses classificadores, que podem ser redes
neurais, algoritmos estatísticos, K-means entre vários que existem e que o OpenCV
pode utilizar e desenvolver.
6.1 | Classificador em cascata de Haar
Para esse estudo, vamos usar o classificador em cascata de Haar, onde pode
ser aplicado em detecção de faces humanas em imagens, tanto em arquivo quanto em
vídeo.
50 Capítulo 6. Classificando Padrões em OpenCV
Método proposto por Paul Viola e Michael Jones no artigo “Rapid Object Detec-
tion using a Boosted Cascade of Simple Features” em 2001. O método é uma maquina
onde a função em cascata é treinada por um conjunto de imagens positivas e negativas,
como por exemplo fotografias com carros e sem carros.
As características da imagem é detectada utilizando as figuras abaixo:
Figura 24 – Extração de características
As características do método são:
• As características são obtidas pela subtração da soma dos pixels sobre a o retân-
gulo branco pela soma da dos pixels sobre a retângulo preto.
• Depois é eleitas as características mais relevantes da imagem.
• Para diminuir o processamento, o método se foca na parte onde não tem face,
pois a maior parte da imagem não contem face.
• Para isso fizeram o classificador em cascata, ao invés de procurar todas as carac-
terísticas de uma vez, dividiram a classificação em estágios, onde o objeto alvo
passara por todos os estágios.
6.2 | Algoritmo
Para desenvolver a nossa aplicação de detecção de face vamos precisar criar 3
classes no projeto, que são:
• Meu_Painel: classe que criará a área que será desenhada a imagem da câmera
na janela da aplicação;
• Processador: esta classe é a que fará o processo de reconhecimento da face na
imagem e o destaque das faces detectadas, o download do arquivo .xml do
classificador pode ser realizado no link <http://ftp.jaist.ac.jp/pub/sourceforge/
m/ma/magicvisionport/mvp/cascades/haarcascade_frontalface_alt.xml>;
6.2. Algoritmo 51
• Janela: esta será a classe principal do nosso projeto, ela criará a janela juntamente
com o painel e executará o processador de imagem e mostrará o resultado da
detecção.
6.2.1 | Classe Meu_Painel
package Window;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import javax.swing.JPanel;
import org.opencv.core.Mat;
class Meu_Painel extends JPanel{
private static final long serialVersionUID = 1L;
private BufferedImage image;
// Create a constructor method
public Meu_Painel(){
super();
}
/**
*converte e escreve uma matriz em um BufferedImagem
* @param matrix Mat of type CV_8UC3 ou CV_8UC1
* @return BufferedImage do tipo TYPE_3BYTE_BGR ou TYPE_BYTE_GRAY
*/
public boolean MatToBufferedImage(Mat matBGR){
long startTime = System.nanoTime();
int width = matBGR.width(), height = matBGR.height(), channels =
matBGR.channels() ;
byte[] sourcePixels = new byte[width * height * channels];
matBGR.get(0, 0, sourcePixels);
//cria uma nova imagem e pega a referencia dados de apoio
image = new BufferedImage(width, height,
BufferedImage.TYPE_3BYTE_BGR);
52 Capítulo 6. Classificando Padrões em OpenCV
final byte[] targetPixels = ((DataBufferByte)
image.getRaster().getDataBuffer()).getData();
System.arraycopy(sourcePixels, 0, targetPixels, 0,
sourcePixels.length);
long endTime = System.nanoTime();
//mostra no console o tempo gasto para a conversão da imagem
System.out.println(String.format("tempo decorrigo: %.2f ms",
(float)(endTime - startTime)/1000000));
return true;
}
//metodo de desenhar a imagem no painel
@Override
public void paintComponent(Graphics g){
super.paintComponent(g);
if (this.image==null) return;
g.drawImage(this.image,10,10,this.image.getWidth(),this.image.getHeight(), null);
//g.drawString("This is my custom Panel!",10,20);
}
}
6.2.2 | Classe Processador
package Window;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
class processador {
6.2. Algoritmo 53
//objeto que representa o classificador usado
private final CascadeClassifier face_cascade;
public processador(){
//carrega o arquivo do classificador treinado
//no local, coloque onde voce salvou o arquivo
face_cascade=new
CascadeClassifier("Local/haarcascade_frontalface_alt.xml");
//verifica o classificador foi carregado com sucesso
if(face_cascade.empty())
{
System.out.println("--(!)Error loading A\n");
}
else
{
System.out.println("Face classifier loaded up");
}
}
//metodo de deteccao das faces
public Mat detect(Mat inputframe){
//matriz da imagem em RGB
Mat mRgba=new Mat();
//Mmatriz para a imagem em escala de cinza
Mat mGrey=new Mat();
//matriz que guardara as faces detectadas
MatOfRect faces = new MatOfRect();
//armazenando a imagem nas matrizes
inputframe.copyTo(mRgba);
inputframe.copyTo(mGrey);
//conversao das imagem em escala de cinza
Imgproc.cvtColor( mRgba, mGrey, Imgproc.COLOR_BGR2GRAY);
//equalização de histograma da imagem em escola de cinza
Imgproc.equalizeHist( mGrey, mGrey );
54 Capítulo 6. Classificando Padrões em OpenCV
//realizando a detecção das faces
face_cascade.detectMultiScale(mGrey, faces);
//imprime no console a quantidade de faces detectadas
System.out.println(String.format("Detected %s faces",
faces.toArray().length));
//destaque das faces detectadas na imagem em RGB
for(Rect rect:faces.toArray())
{
Point center= new Point(rect.x + rect.width*0.5, rect.y +
rect.height*0.5 );
Core.ellipse( mRgba, center, new Size( rect.width*0.5,
rect.height*0.5)
, 0, 0, 360, new Scalar( 255, 170, 30 ), 4, 8, 0 );
}
return mRgba;
}
}
6.2.3 | Classe Janela
package Window;
import javax.swing.*;
import org.opencv.core.Mat;
import org.opencv.highgui.VideoCapture;
public class Janela {
public static void main(String arg[]){
// carrengando a biblioteca do opencv
System.loadLibrary("opencv_java249");
String window_name = "Capture - Face detection";
JFrame frame = new JFrame(window_name);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(600,1000);
processador my_processor=new processador();
Meu_Painel my_panel = new Meu_Painel();
frame.setContentPane(my_panel);
frame.setVisible(true);
6.2. Algoritmo 55
//-- 2. ler o canal de video
Mat webcam_image=new Mat();
VideoCapture capture =new VideoCapture(0);
if( capture.isOpened())
{
while( true )
{
capture.read(webcam_image);
if( !webcam_image.empty() )
{
frame.setSize(webcam_image.width()+ 40,
webcam_image.height() +60);
//-- 3. Aplica o classificador na imagem
webcam_image=my_processor.detect(webcam_image);
//-- 4. deseja a imagem no painel criado
my_panel.MatToBufferedImage(webcam_image);
my_panel.repaint();
}
else
{
System.out.println(" --(!) frame nao capturado --
Break!");
break;
}
}
}
}
}
56 Capítulo 6. Classificando Padrões em OpenCV
6.2.4 | Resultado
Ao executar o projeto é mostrada a janela a seguir:
(a)
(b)
Figura 25 – detecção de faces
57
Referências
BRADSKI, G.; KAEHLER, A. Learning OpenCV: Computer Vision in C++ with the
OpenCV Library. [S.l.]: O’Reilly’, 2008.
BRADSKYI, G.; KAEHLE, A. Learning OpenCV: Computer vision with the OpenCV
Library. [S.l.]: Sebastopol, 2008.
BYTEDECO. Acessado em 10 de Dezembro de 2014. Disponível em: <https:
//github.com/bytedeco/javacv>.
ITSEEZ. The OpenCV Reference Manual Release 2.4.9.0. [S.l.], 2014.
	Folha de rosto
	Sumário
	O que é OPENCV?
	A Visão Computacional
	Breve Histórico
	Módulos do OPENCV
	Módulo CXCORE
	Estrutura Básica
	Operações com Arrays
	Funções de Desenho
	Persistência XML/YAML
	Funções do Sistema e Utilidade
	Clustering
	Módulo HIGHGUI
	Criando uma janela
	Módulo ML
	Instalando o OPENCV
	WINDOWS
	Utilizando o OPENCV Com O NETBEANS
	LINUX
	Integrando o OpenCV em um projeto Java do NetBeans
	Interface JavaCV
	Exemplo em JavaCV
	Transformações de Imagens
	Exemplo de Aplicação
	Trabalhando com vídeo
	Código
	jfmPrincipal
	VideoCaptura
	ExibeQuadro
	Classificando Padrões em OpenCV
	Classificador em cascata de Haar
	Algoritmo
	Classe Meu_Painel
	Classe Processador
	Classe Janela
	Resultado
	Referências