Reconhecimento de Objetos em Tempo Real Utilizando

Transcrição

DEPARTAMENTO ACADÊMICO DE SISTEMAS, PROCESSOS E
CONTROLES ELETRO-ELETRÔNICO
COORDENAÇÃO DE SISTEMAS DE INFORMAÇÃO
Reconhecimento de Objetos em Tempo
Real Utilizando Visão Computacional
para o Futebol de Robôs
Felype Nery de O. Vasconcelos
Raphael Passos Gibson
Recife
Agosto - 2014
Felype Nery de O. Vasconcelos
Raphael Passos Gibson
Reconhecimento de Objetos em Tempo Real Utilizando Visão
Computacional para o Futebol de Robôs
Trabalho de Conclusão de Curso apresentado
ao curso de Tecnologia em Análise e
Desenvolvimento de Sistemas, como prérequisito para obtenção do título de Tecnólogo
em Análise e Desenvolvimento de Sistemas
pelo Instituto Federal de Educação, Ciência e
Tecnologia de Pernambuco - IFPE.
Orientador: Prof. Msc. Paulo Abadie Guedes
Recife
Agosto – 2014
ii
iii
AGRADECIMENTOS
Agradecemos primeiramente a Deus e às nossas famílias por todo apoio e confiança, sem eles
nada seria possível. Ao professor Paulo Abadie por toda a dedicação e paciência conosco
durante a graduação e orientação neste trabalho, ao professor Anderson Moreira por sempre
se mostrar disponível para ajudar e contribuir com o projeto e aos outros professores e
funcionários do curso que de alguma forma contribuíram com o nosso amadurecimento
profissional, pessoal e acadêmico. Agradecemos também às amizades que fizemos durante o
curso que sempre nos incentivaram e tornaram nossa graduação mais divertida, não temos
dúvidas que todos serão excelentes profissionais.
iv
LISTA DE ACRÔNIMOS
BPP
Bit Per Pixel
F180
Categoria Small Size Robot Soccer
FIRA
Federation International of Robot soccer Association
EAPH
Exoesqueletos para Aumento de Performance Humana
GPU
Graphics Processing Unit
GUI
Graphical User Interface
HSI
Hue, Saturation and Intensity
HSV
Hue, Saturation and Value
IDE
Ambiente Integrado de Desenvolvimento
IEEE
Institute of Electrical and Electronics Engineers
IFPE
Instituto Federal de Educação, Ciência e Tecnologia de Pernambuco
NASA
National Aeronautics and Space Administration
OpenCV
Open Source Computer Vision Library
PERCRO
Perceptual Robotics Laboratory
RAM
Random Access Memory
RGB
Red, Green , Blue
RoboCup
Robot World Cup Initiative
ROI
Region of Interest
SSL
Small Size League
SVC
Sistema de Visão Computacional
VM
Virtual Machine
VRAM
Video RAM
v
LISTA DE EQUAÇÕES
Equação 1 - Convolução Contínua ........................................................................................... 19
Equação 2 - Convolução Discreta ............................................................................................ 19
Equação 3- Transformação de RGB para HSI.......................................................................... 21
Equação 4 - Transformação de HSI para RGB......................................................................... 21
Equação 5 - Erosão de A por B ................................................................................................ 22
Equação 6 - Dilatação de A por B ............................................................................................ 22
Equação 7 - Condição de Limiarização .................................................................................... 23
Equação 8 - Momentos de ordem p+q ...................................................................................... 26
Equação 9 - Momentos aplicados a imagens ............................................................................ 26
Equação 10 - Momentos centrais.............................................................................................. 26
Equação 11 - Variância em X e Y ............................................................................................ 27
Equação 12 - Direção do Objeto............................................................................................... 27
vi
LISTA DE FIGURAS
Figura 1 - Imagem do PERCRO BE.......................................................................................... 5
Figura 2 - Projeto Andar Denovo ............................................................................................... 6
Figura 3 - Humanoid League ...................................................................................................... 8
Figura 4 - Middle Size League ................................................................................................... 8
Figura 5 - Simulation League 2D e 3D, respectivamente........................................................... 9
Figura 6 - Robôs Aibo e Nao, respectivamente ......................................................................... 9
Figura 7 - Robôs da categoria F180.......................................................................................... 10
Figura 8 - Sistema do Futebol de Robôs .................................................................................. 11
Figura 9 - Representação de um sistema de visão computacional genérico ............................. 13
Figura 10 - Adaptador gráfico simples ..................................................................................... 15
Figura 11 - 256 Níveis de intensidade ...................................................................................... 15
Figura 12 - Monitor colorido .................................................................................................... 16
Figura 13 – Versão 8 bits, 16 bits e 64 bits do personagens Mario .......................................... 17
Figura 14 - Conceito de 4-vizinhança, vizinhança diagonal e 8-vizinhança ............................ 18
Figura 15 - Representação do cubo RGB ................................................................................ 20
Figura 16 - Repreentação do cone HSI..................................................................................... 20
Figura 17 - Exemplo de Binarização ........................................................................................ 24
Figura 18 - Tela do SSL-Vision ............................................................................................... 28
Figura 19 - Tela do Projeto Find-Object ................................................................................. 30
Figura 20 - Exemplo de detecção de faces com OpenCV ........................................................ 31
Figura 21 - Câmera na posição vertical .................................................................................... 34
Figura 22 - Campo Colocado na Parede .................................................................................. 34
Figura 23 - Passos para a calibração da câmera ...................................................................... 35
Figura 24 - Definição da Região de Interesse........................................................................... 35
Figura 25 - Calibração das cores dos marcadores .................................................................... 36
Figura 26 - Fluxograma do processamento .............................................................................. 37
Figura 27 - Identificação dos objetos no campo ....................................................................... 38
Figura 28 - Significado dos marcadores nos robôs................................................................... 39
Figura 29 - Reconhecimento dos robôs e da bola ..................................................................... 40
Figura 30 - Gráfico do tempo em segundos Vs Quantidade de robôs ...................................... 42
Figura 31 - Criando um exemplo no Qt Studio ........................................................................ 53
Figura 32 - Qt Studio configurado com o OpenCV.................................................................. 54
vii
Figura 33 - Vista em corte do olho humano ............................................................................. 75
Figura 34 - Como a imagem chega ao cérebro ......................................................................... 75
Figura 35 - Abertura e fechamento da córnea .......................................................................... 76
viii
RESUMO
O futebol de robôs se apresenta à comunidade científica com o intuito de ser um problema
padrão para a pesquisa nas áreas de inteligência artificial, robótica e visão computacional. O
problema consiste em realizar uma partida de futebol utilizando robôs autônomos como
jogadores. Este tipo cenário envolve diversos problemas relacionados a muitas áreas do
conhecimento, fazendo com que os participantes apliquem soluções com uma equipe
multidisciplinar. Este trabalho descreve o projeto e a implementação de um módulo de visão
computacional para futebol de robôs que utiliza uma abordagem por espaço de cores HSV e
descritores,
de forma que utilizam o método estatístico dos momentos.
O módulo
desenvolvido foi capaz de oferecer informações sobre a posição e identificação dos jogadores
e da bola através da aquisição e processamento de imagens em tempo real, permitindo que
ações possam ser tomadas automaticamente pela equipe.
Palavras-chave: Visão Computacional, Futebol de Robôs, OpenCV, Descritores, HSV
ix
ABSTRACT
The robot soccer presents itself to the scientific community in order to be a standard problem
for research in the areas of artificial intelligence, robotics and computer vision. The problem
consists in bringing a soccer match using autonomous robots as players where this scenario
involves several kinds of issues relating to many areas of knowledge, causing the participants
to apply technical solutions with a multidisciplinary team. This work describes the project and
the implementation of a computer vision module for robot soccer that uses an approach by the
HSV color space and shape descriptors using the statistical method of moments. The module
developed was able to providing information about the location and identification of the
players also the ball through the acquisition and processing of images in real time, allowing
actions to be taken automatically by the team.
Keywords: Computer Vision, Robot Soccer, OpenCV, Descriptors, HSV
x
SUMÁRIO
1.
2.
INTRODUÇÃO ............................................................................................................................................ 1
1.1.
MOTIVAÇÃO ........................................................................................................................................... 1
1.2.
OBJETIVO GERAL.................................................................................................................................... 2
1.3.
OBJETIVOS ESPECÍFICOS ......................................................................................................................... 2
FUNDAMENTAÇÃO TEÓRICA ............................................................................................................... 4
2.1.
ROBÓTICA............................................................................................................................................... 4
2.2.
FUTEBOL DE ROBÔS ................................................................................................................................ 6
2.2.1.
Modalidades .................................................................................................................... 7
2.2.2.
Small Size League ......................................................................................................... 10
2.3.
MÓDULO DE VISÃO DO FUTEBOL DE ROBÔS ......................................................................................... 11
2.4.
VISÃO COMPUTACIONAL ...................................................................................................................... 12
2.5.
PROCESSAMENTO DE IMAGENS ............................................................................................................. 14
2.5.1.
Imagem Digital .............................................................................................................. 14
2.5.2.
Vizinhanças de um Pixel ............................................................................................... 17
2.5.3.
Conectividade ................................................................................................................ 18
2.5.4.
Convolução com Máscaras............................................................................................ 18
2.5.5.
Modelos de Cor ............................................................................................................. 19
2.5.6.
Operações Morfológicas ............................................................................................... 21
2.5.7.
Limiarização .................................................................................................................. 23
2.5.8.
Região de Interesse........................................................................................................ 24
2.5.9.
Segmentação.................................................................................................................. 24
2.5.10.
Descritores de Forma .................................................................................................... 25
2.5.11.
Momentos ...................................................................................................................... 25
2.6.
3.
FERRAMENTAS...................................................................................................................................... 27
2.6.1.
SSL-Vision .................................................................................................................... 27
2.6.2.
Find-Object.................................................................................................................... 29
2.6.3.
OpenCV......................................................................................................................... 30
2.6.4.
IDEs............................................................................................................................... 32
METODOLOGIA ....................................................................................................................................... 33
3.1.
CAPTURA DA IMAGEM .......................................................................................................................... 33
xi
3.2.
CALIBRAÇÃO ........................................................................................................................................ 35
3.3.
PROCESSAMENTO ................................................................................................................................. 37
3.4.
EXIBIÇÃO DAS INFORMAÇÕES ............................................................................................................... 39
4.
RESULTADOS ........................................................................................................................................... 41
5.
CONCLUSÕES E TRABALHOS FUTUROS ......................................................................................... 43
6.
BIBLIOGRAFIA ........................................................................................................................................ 44
7.
APÊNDICES ............................................................................................................................................... 50
7.1.
APÊNDICE 1 - INSTALAÇÃO DO OPENCV .............................................................................................. 50
7.2.
APÊNDICE 2 - CONFIGURAR O ECLIPSE, NETBEANS E QT STUDIO ......................................................... 51
7.2.1.
Eclipse ........................................................................................................................... 51
7.2.2.
NetBeans ....................................................................................................................... 51
7.2.3.
Qt Studio ....................................................................................................................... 52
7.3.
7.3.1.
tcc.pro ............................................................................................................................ 55
7.3.2.
main.cpp ........................................................................................................................ 55
7.3.3.
mainwindow.ui .............................................................................................................. 60
7.3.4.
mainwindow.h ............................................................................................................... 61
7.3.5.
mainwindow.cpp ........................................................................................................... 61
7.3.6.
Objeto.h ......................................................................................................................... 61
7.3.7.
Objeto.cpp ..................................................................................................................... 62
7.3.8.
Bola.h ............................................................................................................................ 64
7.3.9.
Bola.cpp......................................................................................................................... 64
7.3.10.
Marcador.h .................................................................................................................... 64
7.3.11.
Marcador.cpp................................................................................................................. 65
7.3.12.
Robo.h ........................................................................................................................... 66
7.3.13.
Robo.cpp ....................................................................................................................... 67
7.4.
8.
APÊNDICE 3 – CÓDIGO-FONTE DO TRABALHO ...................................................................................... 55
APÊNDICE 4 – BUG: UVCVIDEO ............................................................................................................ 72
ANEXOS...................................................................................................................................................... 74
8.1.
SISTEMA DE VISÃO HUMANA ............................................................................................................... 74
xii
“No! Try not! Do... or do not. There is no try”
Master Yoda, Star Wars V
1. Introdução
Este capítulo tem como objetivo introduzir o tema da pesquisa. Para isto, será
explanado de forma simples o que incitou a pesquisa e por qual razão desenvolvê-la, bem
como os objetivos gerais e específicos deste trabalho.
1.1. Motivação
Encontramos diversas pesquisas no meio acadêmico sobre a utilização de sistemas de
visão por máquina. Sua aplicabilidade é imensa, desde a robótica na exploração espacial até a
medicina com a detecção de tumores. Dessa forma podemos afirmar que não existe uma
implementação padrão para a resolução destas aplicações, o desenvolvimento vai depender
dos objetivos de cada problema.
Muitas vezes é necessário utilizar técnicas de inteligência artificial para poder avaliar
o resultado encontrado de forma autônoma ou mesmo melhorar os parâmetros de entrada do
sistema, tornando mais complexo de ser desenvolvido, porém mais robusto. A utilização
destes algoritmos não estão limitados ao meio acadêmico e científico.
Encontramos soluções com a utilização das técnicas na indústria e no comércio,
como por exemplo, na automação industrial e no controle de qualidade (RUDEK; COELHO;
CANCIGLIERI, 2001). Já o futebol de robôs é um desafio que é fortemente utilizado para
estudos em diversas áreas como na eletrônica, mecânica e computação.
Essa complexidade vem atraindo os olhares da comunidade acadêmica já que em um
único campo de pesquisa podemos unir o fascínio do esporte com os desafios da robótica.
Como é um ambiente dinâmico e de tempo real1, o futebol de robôs torna-se um ótimo campo
de estudo de caso para as técnicas de análise e processamento de imagens com objetivo de
1
Um sistema em tempo real é aquele que tem um tempo de resposta limite a um evento é pré-definido. Esse
tempo de resposta é chamado de prazo da tarefa e a perda de um prazo, isto é, o não cumprimento de uma tarefa
dentro do prazo esperado, caracteriza uma falha do sistema, que no nosso caso seria a não identificação do robô
em um tempo limite de alguns milisegundos.
Introdução
reconhecer a posição e o movimento de cada objeto com a necessidade que ocorra um retorno
rápido e preciso para o sucesso na partida de futebol.
Uma das etapas mais importantes para o desenvolvimento de uma equipe de futebol
de robôs é a implementação de seu sistema de visão. Basicamente, o sistema de visão
computacional será responsável por localizar os elementos participantes (a bola e jogadores) e
interpretar as informações adquiridas para a definição da melhor estratégia e ações a serem
tomadas.
1.2. Objetivo Geral
O objetivo do nosso trabalho é o desenvolvimento do módulo de visão
computacional do time de futebol de robôs do IFPE que identifique os robôs e a bola no
campo, através de ferramentas de código aberto.
1.3. Objetivos Específicos

Desenvolver um módulo de visão computacional com base nos resultados obtidos com
o OpenCV e com outros projetos que foram pesquisados e documentados neste
trabalho com ferramentas open-sources. O módulo deve implementar um algoritmo
para calibração e reconhecimento dos elementos aplicados ao futebol de robôs.

Criar um tutorial simples para a configuração completa do ambiente de
desenvolvimento no Linux, voltado à criação de sistemas de visão computacional.
Antes de aplicar a metodologia escolhida vamos explicar os principais conceitos que
serão necessários para criação de um sistema de visão computacional aplicado à robótica no
capítulo 2. Serão abordados a história da robótica, criação do futebol de robôs bem como suas
organizações e categorias. Depois partiremos para os principais conceitos da visão
computacional e de processamento de imagens.
No capítulo 3 analisamos as bibliotecas que são definidas pelas regras da competição
e outras que são genéricas, mas voltadas para o objetivo do trabalho. Levantamos os custos da
aquisição dos componentes necessários para criação da estrutura de apoio da equipe, como
câmeras e placa de captura. Testamos alguns projetos e por fim implementamos nossa
soluçãoo algoritmo para calibração e reconhecimento dos elementos aplicados ao futebol de
2
Introdução
robôs que esta disponível no apêndice 3. Os resultados encontrados e conclusões estão no
capítulo 4 e 5 respectivamente.
3
Fundamentação Teórica
2. Fundamentação Teórica
Neste capítlo serão abordados a história da robótica, criação do futebol de robôs bem
como suas organizações, categorias e regras. Depois partiremos para os principais conceitos
da visão computacional e de processamento de imagens.
2.1. Robótica
Podemos definir a robótica mais do que a união de conhecimentos da engenharia
eletrônica, mecânica e da computação. A diversidade de tipos de robôs impedem que tenha
uma definição que seja universalmente aceita. Acredita-se que o termo robótica foi usado pela
primeira vez pelo escritor de ficção científica Isaac Asimov.
Em 1941, foi lançada uma de suas mais famosas obras literárias, o livro I, Robot (Eu
Robô). Nessa obra, Isaac Asimov descreveu as três leis da robótica, que segundo o autor,
foram criadas exclusivamente para manter a segurança da humanidade. Segundo (RIA) um
robô é um dispositivo mecânico articulado reprogramável, que de forma autônoma e
recorrente à sua capacidade de processamento obtem informação do meio através de sensores,
toma as decisões do que fazer de acordo com uma base de informações ou manipula objetos
através de atuadores.
Tal preocupação já citadas em obras científicas são justificadas atualmente. Em
muitos setores da indústria existem sistemas de automação com robôs. Seja na realização de
tarefas perigosas para os seres humanos ou atividades repetitivas que necessitam de uma alta
demanda humana, a utilização de robôs no dia a dia é uma realidade. Uma das aplicações que
demostram a importância da robótica é o projeto Mars Exploration Program (NASA, 2004)
que desde 1997 apresenta resultados e descobertas, até então inalcançável através de robôs de
exploração.
Outra execelente aplicação são os Exoesqueletos para Aumento de Performance
Humana que pertencem a uma classe especial de sistemas robóticos que são concebidos
para aumentar as capacidades da força humana como demonstrado em (SIMONE et al.,
2011) e (CASSADIO et al., 2011). A principal característica destes tipos de dispositivos
é que o operador humano "veste" o robô e controla os movimentos do mesmo, movendo seus
membros de forma natural. EHPA são geralmente destinados a aplicações
de dispositivos
4
de apoio aos idosos,
pessoas com deficiências locomotoras, na área militar e em
aplicações no qual a manipulação de materiais pesados em ambientes não estruturados ou
estreitos são necessários.
O
laboratório
PERCRO
da
Scuola
Superiore
Sant’Anna
completou
recentemente o desenvolvimento e avaliação funcional do sistema Extensores Corporais –
BE. O sistema é composto por quatro membros robóticos com cinemática antropomórficas e
tem um total de 22 graus de liberdade como visto na Figura 1. A perna dá locomoção e da
força com uma servo-amplificação onde permite operações em ambientes que são de
difícil acesso pelos convencionais sistemas de manuseio, preservando a sensibilidade
durante a manipulação das tarefas.
Figura 1 - Imagem do PERCRO BE (PERCRO, 2014)
O brasileiro e neurocientista Miguel Nicolelis está desenvolvendo o primeiro
exoesqueleto controlado apenas pela mente no mundo em conjunto com pesquisadores de
vários países. O projeto se chama Walk Again ou Andar de novo (tradução oficial) e é um
resultado de anos de pesquisa de Miguel Nicolelis na Universidade de Duke, EUA
(NICOLELIS, 2014), onde o objetivo inicial seria um cadeirante levantar e andar como na
Figura 2.
5
Figura 2 - Projeto Andar Denovo (BLOGDACOPA, 2014)
O projeto já apresentou resultados positivos com macacos e já está na fase final de
treinamento com seres humanos. Na abertura da Copa do Mundo de Futebol no Brasil, foi
feita a primeira demonstração com seres humanos para bilhões de pessoas em todo mundo,
onde um paraplégico deu o pontapé inicial da primeira partida da Copa de 2014 que foi entre
as seleções do Brasil e Croácia.
Esses projetos e tantos outros, demonstram o poder e a importância da robótica para
a sociedade (MOREIRA; VASCONCELOS, 2010) (YASUTOMI; MIRANDA, 2011)
(BECKER, 2000).
2.2. Futebol de Robôs
Diversas áreas de pesquisa utilizam, como base para seus estudos, problemas de
interesse público, de fácil entendimento e que apresentem resultados práticos. Esta prática
estimula o ingresso de pesquisadores nestas áreas, além de divulgar os trabalhos realizados
para o público em geral. Um problema de crescente aceitação acadêmica é o uso de robôs
autônomos em partidas de futebol (PEREZ et al., 2012).
Problemas de domínio simbólico, como o jogo de xadrez, possuem um ambiente
estático com acesso total às suas informações. Em contraste, o futebol de robôs é realizado em
um ambiente dinâmico e em tempo real. Uma partida de futebol com robôs autônomos pode
ser utilizado como objeto de pesquisa em diversas áreas da engenharia e da ciência da
computação (MEHL et al., 2001). Dentre estas áreas estão a robótica, a inteligência artificial,
os sistemas multiagentes, a visão computacional e os sistemas de tempo real (COSTA;
PEGORARO, 2000) (ASSIS et al., 2005) (DALBEM, 2010) (NEVES; TADDEI;
6
BANDEIRA, 2004).
O objetivo geral de uma equipe pode ser dividido em vários objetivos secundários,
como obter a posse da bola, identificar a posição dos agentes no campo e fazer ou evitar gols.
Levando em consideração a situação do jogo, cada membro da equipe deve ter um
comportamento cooperativo, flexível e rápido para alcançar os objetivos do time.
Os pesquisadores organizaram-se em torno do tema futebol de robôs com o objetivo
de disseminar a utilização deste problema como plataforma de pesquisa. Paralelamente duas
organizações foram criadas, ambas com o intuito de organizar competições internacionais de
futebol de robôs e assim incentivar a produção científica na área e o aperfeiçoamento das
equipes (KITANO et al., 1997). A Federation International of Robot Soccer Association
organiza competições internacionais para a promoção do futebol de robôs desde 1996.
A RoboCup é uma iniciativa internacional que incentiva a pesquisa sobre futebol de
robôs através da organização de competições internacionais anuais desde 1997, (FIRA, 2014)
no qual seu objetivo é em que 2050 o campeão do RoboCup vença o time campeão mundial
humano (BURKHARD et al., 2002).
As competições na RoboCup são divididas em várias modalidades, que variam
quanto aos limites do campo e à forma dos robôs. Além de robôs reais, a FIRA e a RoboCup
possuem modalidades no qual a partida é simulada.
2.2.1. Modalidades
No RoboCup existem outras competições envolvendo robôs autônomos, entre elas
estão as modalidades Rescue que promove a pesquisa e desenvolvimento no domínio
socialmente significativo que é a de resgate em desastres onde a vida humana é colocada em
risco, a modalidade @Work que desenvolvem robôs que operam em cenários relacionados ao
trabalho e a modalidade @Home que visa desenvolver serviços de tecnologia assistida
robótica com alta relevância para futuras aplicações domésticas pessoais. Ainda tem a
modalidade Júnior que envolvem jovens estudantes desde a escola primária até alunos de
graduação envolvidos em desafios de dança, futebol e resgate com robôs. Na parte de futebol,
temos as modalidades:
a. Humanoid: Robôs autônomos com um corpo e sensores parecidos com o de um
humano para jogar futebol um contra o outro. Entre as muitas questões de pesquisa
7
investigadas nesta liga estão as dinâmicas como andar, correr e chutar a bola, manter o
equilíbrio, percepção visual da bola, de outros jogadores, e no campo, a auto
localização e o jogo em equipe como visto na Figura 3.
Figura 3 - Humanoid League (TECHNO, 2011)
c. Middle Size: Robôs de tamanho médio de diâmetro não superior a 50 cm que deve
jogar futebol em equipes de até seis robôs com uma bola de tamanho normal da FIFA
em um campo semelhante a um campo de futebol humano em escala. Todos os
sensores são on-board. Robôs podem usar a rede sem fio para se comunicar. O foco da
pesquisa está em plena autonomia e cooperação a nível do plano e de percepção
mostrado na Figura 4.
Figura 4 - Middle Size League (NIPPON, 2012)
d. Simulation: Esta é uma das ligas mais antigas da RoboCup Soccer. O foco nesta liga
é em inteligência artificial e estratégia da equipe. Em simuladores, agentes de forma e
movimentos independentes jogam futebol em um campo virtual dentro de um
computador. Há duas subligas: 2D e 3D. Na Figura 5 é possível ver como são as ligas.
8
Figura 5 - Simulation League 2D e 3D, respectivamente (DIGPLANET, 2014) (NEXUS, 2009)
e. Standard Platform: Neste campeonato todas as equipes usam robôs padronizados.
Portanto, as equipes se concentram no desenvolvimento do software apenas, enquanto
usam o estado da arte em robôs. Usar visão omnidirecional não é permitido, forçando
a tomada de decisão de compartilhamento do campo de visão de cada robô para a
auto-localização e localização da bola. O campeonato substituiu o grande sucesso
Four-Legged League, baseado nos robôs cão Aibo da Sony, e agora é baseada em
robôs humanóides Nao na Figura 6.
Figura 6 - Robôs Aibo e Nao, respectivamente (IGREBOT, 2014) (IAUBS, 2010)
9
2.2.2. Small Size League
A SSL é uma das diversas modalidades de futebol de robôs da Robocup. Para essa
categoria são utilizados robôs com o modelo especificado nas regras F180 2 (Small Size Robot
Soccer). Segundo o manual da FIRA a modalidade SSL tem como característica o foco na
cooperação entre os agentes e controle inteligente em um ambiente altamente dinâmico, com
um sistema híbrido centralizado mostrado na Figura 7.
Figura 7 - Robôs da categoria F180 (CORAL, 2010)
A competição ocorre entre duas equipes de até seis robôs com medidas limitadas a
18 cm de diâmetro e 15 cm de altura, que participam de uma partida de futebol com uma bola
laranja. Eles são identificados e monitorados por duas câmeras acopladas em cima do campo e
conectadas a um computador como visto na Figura 8.
O campo tem o formato retangular, feito com tapete ou carpete verde e com duas
opções de tamanho, único com 6050mm x 4050mm e o dobrado com 8090mm x 605 mm. As
demarcações do campo são feitas com linhas brancas de 10mm e o sistema de visão através
das duas câmeras, localizadas uma em cada parte do campo, é compartilhada para as duas
equipes onde os dados são enviados via Ethernet seguindo o protocolo do software SSLVision, que será mencionado na metodologia.
2
As regras da modalidade F180 estão disponíveis em http://goo.gl/Up60Y5 Acessao em 2014
10
Figura 8 - Sistema do Futebol de Robôs (LAB, 2008)
2.3. Módulo de Visão do Futebol de Robôs
O módulo de visão computacional envolve as etapas de aquisição e identificação. Ele
deve obter informações referentes aos componentes do jogo visualmente, permitindo a
decisão de estratégia da equipe (SCHOUTE; POEL; HEIJDEN, 2003). Os componentes do
jogo relevantes a este módulo são: os jogadores da equipe adversária, a bola e os jogadores da
própria equipe.
Existem duas abordagens possíveis em um módulo de visão para futebol de robôs:
visão embarcada e visão global (MCMAHAN; BUNTING; MIDDLETON, 2014) (AIRES;
ALSINA; MEDEIROS, 2001) (SCHWARTZ et al., 2003). No modelo de visão embarcada as
imagens são adquiridas com a perspectiva dos jogadores, sendo que cada um dos robôs
carrega consigo uma câmara (ANDRADE; MATOS; FREIRE, 2006). Diferente deste modelo,
a visão global consiste na visualização de todo o campo (GARCIA et al., 2007).
O primeiro passo da identificação visual é localizar a posição da bola e de todos os
robôs, adversários ou não, no campo. Entretanto, antes deste passo o sistema vai naturalmente
precisar de uma etapa de calibração de modo a se adaptar às condições de iluminação do
campo, que será descrita na parte da metodologia deste trabalho.
A representação da posição de cada um destes componentes pode ser feita através da
sua posição relativa ou absoluta. Enquanto a posição relativa é dada pela sua distância em
11
duas dimensões até um determinado ponto, a posição absoluta é representada por um par
ordenado indicando sua posição no plano cartesiano que representa o campo.
Para identificar a movimentação da bola e dos robôs adversários, é necessário
determinar a direção do movimento de cada um e sua velocidade. Esta identificação é feita
através de um acompanhamento temporal da posição global destes componentes. Os robôs
que pertencem à equipe devem ser identificados para que o módulo de estratégia saiba a quem
atribuir as ações (FIRA, 2014).
Esta identificação pode ser feita através de uma associação pelo acompanhamento
temporal ou através de marcas colocadas sobre cada um dos robôs. Marcas também devem ser
utilizadas para possibilitar a identificação da orientação de cada robô, outra informação
necessária para o módulo de estratégia.
Além de responder ao sistema com confiabilidade, exatidão, regularidade e latência
mínima, o módulo de visão deve ser robusto a alterações da iluminação e a mudanças na cor
do campo de jogo, e deve suportar as variações de cores utilizadas pela equipe adversária.
Estas características indicam a qualidade da implementação do módulo e determinam o
sucesso da equipe em competições (BIANCHI; REALI-COSTA, 2000) (MARTINEZGOMEZ; WEITZENFELD, 2004).
2.4. Visão Computacional
Um SVC é um sistema computadorizado capaz de adquirir, processar e interpretar
imagens correspondentes a cenas reais (GONZALES; RICHARD, 2000). As etapas são
semelhantes ao sistema visual humano, como visto no Anexo 1.
A Figura 9 mostra esquematicamente um diagrama de blocos de um SVC, onde as
etapas deste são: aquisição de imagens, pré-processamento, segmentação, extração de
características, reconhecimento e interpretação. Vale ressaltar que nem todos os os SVCs
possuem todas estas etapas (BALLARD; BROWN, 1982).
12
Figura 9 - Representação de um sistema de visão computacional genérico (FILHO; NETO, 1999)
A aquisição da imagem envolve a escolha do tipo de sensor, o conjunto de lentes a
utilizar, as condições de iluminação da cena, os requisitos de velocidade de aquisição
(assumindo que os robôs estariam a todo momento mudando de lugar), a resolução e o
número de níveis de cinza da imagem que poderiam estar digitalizada, dentre outros.
O pré-processamento consiste em aprimorar a qualidade da imagem para as etapas
subsequentes. As operações efetuadas nesta etapa são ditas de baixo nível porque trabalham
diretamente com os valores de intensidade dos pixels. A imagem resultante desta etapa é uma
imagem digitalizada de melhor qualidade (com menos ruídos) que a original.
A tarefa básica da etapa de segmentação é a de dividir uma imagem em suas
unidades significativas, ou seja, nos objetos de interesse que a compõem. Esta tarefa, apesar
de simples de descrever, é uma das mais difíceis de implementar.
Reconhecimento é o processo de atribuição de um rótulo a um objeto baseado em
suas características, traduzidas por seus descritores. A tarefa de interpretação, por outro lado,
consiste em atribuir significado a um conjunto de objetos reconhecidos.
Todas as tarefas das etapas descritas acima pressupõem a existência de um
conhecimento sobre o problema a ser resolvido, armazenado em uma base de conhecimento,
cujo tamanho e complexidade podem variar enormemente. Idealmente, esta base de
conhecimento deveria não somente guiar o funcionamento de cada etapa, mas também
permitir a realimentação entre elas (RUDEK; COELHO; CANCIGLIERI, 2001) (BIANCHI,
2001).
13
2.5. Processamento de Imagens
Como um subcampo do processamento digital de sinais, o processamento digital de
imagem possui algumas vantagens sobre o processamento analógico de imagem como por
exemplo, permitir que uma série mais ampla de algoritmos sejam aplicados aos dados de
entrada e poder evitar problemas como a distorção de sinais durante o processamento e o
acúmulo de ruídos.
Da etapa de aquisição até o reconhecimento e interpretação dos dados é necessário
utilizar várias técnicas (como morfológicas), que serão necessárias para resolver o problema
em questão. As técnicas relevantes para este trabalho serão abordadas posteriormente.
2.5.1. Imagem Digital
Uma imagem digital consiste em um arranjo bidimensional de valores que
representam as características luminosas de objetos em uma cena, sendo cada um destes
elementos chamado de pixel (picture element). Uma imagem digital pode ser representada por
uma função bidimensional f(x,y), onde x indica uma coluna e y uma linha na imagem (FILHO
e NETO, 1999).
Mas antes da imagem ser exibida na tela, ela tem que primeiro ser escrita para locais
de memória RAM endereçáveis. Estes são agora chamados de adaptadores gráficos, mais
precisamente descrito como RAM de vídeo. VRAM locais são então digitalizadas e a saída
resultante de cada célula ativa um pixel correspondente na tela. (HUMPHRIS, 2013)
Na Figura 10 é possível ver um exemplo de um display monocromático de dois
níveis, preto e branco, com 150 pixels. Displays monocromáticos requerem apenas um bit por
pixel que está definido para binário 1 para a ativação do mesmo ou 0 para desliga-lo.
14
Figura 10 - Adaptador gráfico simples (HUMPHRIS, 2013)
Para aumentar a quantidade de tons discretos é preciso aumentar os níveis da
VRAM. Como visto na Figura 11, para se ter 255 tons é preciso ter 8 níveis de VRAM. As
posições de linha e coluna são digitalizada exatamente como antes só que desta vez um
terceiro valor é calculado o qual é derivado a partir da combinação dos oito níveis.
Isso irá produzir um valor equivalente decimal entre 0 e 255, onde desabilita o pixel
e 255 habilita totalmente para o máximo de intensidade. O cálculo da posição superior do
pixel esquerdo é mostrada como um exemplo na Figura 11. Comparando esta com o exemplo
anterior pode-se ver que, para produzir 255 tons requer oito vezes mais memória.
Figura 11 - 256 Níveis de intensidade (HUMPHRIS, 2013)
15
A última etapa no desenvolvimento da compreensão de uma imagem digital, seria a
expansão para as cores, que são as combinações de três matrizes VRAMs para as saídas R, G,
B, representando respectivamente os componentes vermelho, verde e azul da cor da imagem
na posição.
Segundo (HUMPHRIS, 2013), cada cor é tratada separadamente; transformando
quaisquer dois pixels para fora das três, onde a tríade resultaria em um display colorido único
como visto na Figura 12. A mistura de cores é feita dentro do olho humano onde os pixels
vermelhos, verdes e azuis são ativados a vários graus como explicado no Anexo 1.
Figura 12 - Monitor colorido (HUMPHRIS, 2013)
As placas gráficas têm a sua própria memória de vídeo dedicada para armazenar
imagens de tela e quanto mais melhor. Normalmente, uma placa de vídeo com 64 MB ou
128MB irá atender a maioria das aplicações, mas esta deve ser aumentada para 256 MB ou
trabalhar com Gigabytes para lidar com jogos de computador e renderizações, por exemplo.
Segundo (FILHO; NETO, 1999) a profundidade de cor é um termo da computação
gráfica que descreve a quantidade de bits usados para representar a cor de um único pixel
numa imagem. Este conceito é conhecido também como bits por pixel (bpp) e quanto maior a
quantidade de bits presente na imagem, maior é a escala de cores disponível.
16
A Figura 13 mostra um exemplo deste efeito, na diferença do nível de detalhes do
personagem da Nintendo Mario. Neste exemplo, tanto a quantidade de pontos como a
quantidade de cores varia significativamente.
Figura 13 – Versão 8 bits, 16 bits e 64 bits do personagens Mario3 (PODCASTS, 2014)
2.5.2. Vizinhanças de um Pixel
Como dito anteriormente, o pixel p será representado pela coordenada (x,y).
Considerando um pixel p, suas coordenadas terão quatro vizinhos horizontais e verticais cujo
suas localizações no plano serão representadas da seguinte forma:
(x+1, y), ( x-1 , y), (x, y+1) e (x, y-1).
Esse conjunto de pixels é conhecido como vizinhança de 4 de p. Cada pixel está a
uma distância de (x,y), sendo que alguns vizinhos de p poderão ficar de fora se o pixel em
questão estiver em uma borda da imagem digital. Também podemos representar os quatro
vizinhos diagonais de p. Suas coordenadas são:
(x+1, y+1), ( x-1 , y-1), (x-1, y+1) e (x-1, y-1).
Esses pontos junto com a vizinhança de 4 são chamadas de vizinhança de 8 de p. Da
mesma forma que a vizinhança de 4, alguns pontos da imagem poderão estar fora se a mesma
3
Todos os direitos do personagem Mario são reservados à Nintendo Company, Limited
17
se encontrar na borda. Na Figura 14 podemos visualizar os 3 tipos de vizinhanças com os
pontos marcados com cinza.
Figura 14 - Conceito de 4-vizinhança, vizinhança diagonal e 8-vizinhança (GONZALES; RICHARD,
2000)
2.5.3. Conectividade
O conceito de conectividade é fundamental para identificação das bordas e de regiões
de interesse de um objeto em uma imagem. Dois pixels estão conectados se os mesmos de
alguma forma estão inclusos em algum tipo de vizinhança e se são de valores ou níveis de
cinza, similares. (GONZALES; RICHARD, 2000)
2.5.4. Convolução com Máscaras
Em processamento de imagens é muito frequente utilizar técnicas como
digitalização, detecção de bordas e filtragem de ruídos, nas quais são efetuadas a partir do
conceito de convolução de máscaras. A operação de convolução unidimensional entre dois
vetores A e B, denotada A*B, pode ser entendida como um conjunto de somas de produtos
entre os valores de A e B, sendo que inicialmente o vetor B é espelhado e após cada soma de
produtos é deslocado espacialmente de uma posição (FILHO; NETO, 1999).
Este raciocínio pode ser expandido para o caso bidimensional, onde a imagem a ser
processada é uma matriz relativamente grande e corresponde ao conjunto A, enquanto uma
matriz de pequenas dimensões (também chamada máscara ou janela) corresponde ao conjunto
B (JÄHNE, 1991).
A máscara percorrerá todos os pontos da imagem deslocando-se ao longo de cada
linha e entre as várias linhas, da direita para a esquerda, de cima para baixo, até ter processado
18
o último elemento da matriz imagem. O resultado será armazenado em uma matriz de mesmas
dimensões que a imagem original.
Matematicamente, na sua forma contínua ela é definida como a integral do produto
de uma das funções por uma cópia deslocada e invertida da outra; a função resultante h
depende do valor do deslocamento. Se x for a variável independente e u, o deslocamento, a
fórmula pode ser escrita como na Equação 1:
+∞
(𝑓 ∗ 𝑔)(𝑥) = ℎ(𝑥) = ∫ 𝑓(𝑢) ∙ 𝑔(𝑥 − 𝑢)𝑑𝑢
−∞
Equação 1 - Convolução Contínua (WIKIPÉDIA, 2014)
Entretanto, em imagens digitais, é usada a definição de convoluções para funções de
domínio discreto como visto na Equação 2.
𝑘
(𝑓 ∗ 𝑔)(𝑘) = ℎ(𝑘) = ∑ 𝑓(𝑗) ∙ 𝑔(𝑘 − 𝑗)
𝑗=0
Equação 2 - Convolução Discreta (WIKIPÉDIA, 2014)
No qual f e g são sequências de tamanho n e a fórmula fornece o valor do k-ésimo
elemento do resultado. Deve-se notar que o tamanho de h na Equação 2 é 2n-1, isto é, k varia
de 0 a 2n-2.
2.5.5. Modelos de Cor
2.5.5.1. O modelo RGB
O modelo padrão de representação de cores em imagens digitais é chamado de RGB
(Red, Green and Blue). Penharbel, et al. (2004) falam que esse modelo é usado pela
maioria dos dispositivos de aquisição e visualização de imagens, podendo ser visto como
um cubo de cores na Figura 15 onde os componentes vermelho, verde e azul
correspondem aos eixos x, y e z.
19
Figura 15 - Representação do cubo RGB (PENHARBEL et al., 2004)
Os tons de cinza ocorrem quando os três componentes possuem valores iguais,
seguindo a diagonal principal do cubo, com a origem (0,0,0), preta, e a extremidade
inversa (255,255,255), branca.
2.5.5.2. O modelo de cores HSV
O modelo HSV (Hue, Saturation and Value) que tem o formato cilíndrico, também é
conhecido no seu formato cônico como HSI (Hue, Saturation and Intensity) e é o modelo
de cores que mais se aproxima da percepção humana, onde H significa e representa a
matiz e S à saturação visto na Figura 16. O componente V ou I, representa a intensidade
da cor, deslocando verticalmente o vetor da cor.
Figura 16 - Repreentação do cone HSI (PENHARBEL et al., 2004)
20
Segundo (CARDANI, 2004) o espaço de cores HSI tem um formato de cone, com H
variando de 0 a 360 graus e S e I variando de 0 a 100 por cento, como mostrado na anterior.
As equações de transformação do formato de cor do RGB para o HSV, e vice versa, podem
ser vistas nas Equações 3 e 4.
𝐻={
𝛩,
360 − 𝛩,
𝐵≤𝐺
𝐵>𝐺
1
(𝑅
2 − 𝐺) + (𝑅 − 𝐵)
𝛩 = cos −1 (
)
√(𝑅 − 𝐺)2 + (𝑅 − 𝐵)(𝐺 − 𝐵)
𝑆 =1−
3
∙ (𝑚𝑖𝑛(𝑅, 𝐺, 𝐵))
(𝑅 + 𝐺 + 𝐵)
𝐼=
1
(𝑅 + 𝐺 + 𝐵)
3
Equação 3- Transformação de RGB para HSI
𝑅 = 𝐼 (1 +
𝑆 ∙ 𝑐𝑜𝑠(𝐻)
)
cos(60° − 𝐻)
𝐺 = 1 − (𝑅 + 𝐵)
𝐵 = 𝐼(1 − 𝑆)
Equação 4 - Transformação de HSI para RGB
2.5.6. Operações Morfológicas
Um dos grandes problemas em processamento e análise de imagens refere-se à
extração das componentes de interesse contidas na cena original. Os conceitos de
processamento de imagens mais utilizados no trabalho foram as operações morfológicas.
Basicamente a morfologia matemática consiste em extrair as informações relativo às
características de uma imagem e compará-la com um outro conjunto menor e de forma já
conhecida. Chamamos esse outro conjunto de elemento estruturante. Logo, sua base consiste
na teoria dos conjuntos como visto em (JÄHNE, 1991).
As aplicações podem ser utilizadas com objetivos distintos nas várias técnicas para
análise de imagem, como segmentação e reconhecimento de bordas, por exemplo. Tais
técnicas foram muito utilizadas nesse projeto. A seguir iremos detalhar algumas operações
morfológicas importantes e utilizadas nesse trabalho.
21
2.5.6.1. Erosão
Erosão é uma das operações básicas da morfologia matemática. Inicialmente foi
definida para operações com imagens binárias. Porém atualmente sua utilização já foi
estendida para imagens em tons de cinzas (GONZALES; RICHARD, 2000).
Sejam A e B conjuntos no espaço Z² .A erosão de A por B, denotada A θ B, é
definida como:
𝑨𝚯𝑩 = {𝒙|(𝑩)𝒙 ⊆ 𝑨; 𝑨, 𝑩 ∈ 𝒁²}
Equação 5 - Erosão de A por B
Podemos dizer que a erosão de A por B resulta no conjunto de pontos x tais que B,
transladado de x, está contido em A.
2.5.6.2. Dilatação
A operação de dilatação, segundo (FILHO; NETO, 1999) também as vezes chamada
de dilação, é uma transformação morfológica que combina dois conjuntos usando adição
vetorial. Seu símbolo é ⊕. Como o nome diz, o resultado será uma imagem “engordada”.
Geralmente utiliza-se um elemento estruturante para aprofundar e expandir as formas
contidas em uma imagem. Utilizando um elemento estruturante onde todos os valores são
positivos para efetuar uma dilatação numa imagem em níveis de cinza, obtém-se como
imagem resultante uma imagem com detalhes escuros atenuados e detalhes claros acentuados.
A operação de dilatação em tons de cinza fornece como saída uma imagem com as
mesmas dimensões da imagem de entrada e pixels com valores de 0 a 255, para o caso de uma
imagem original com 256 níveis de cinza. Matematicamente, podemos definir a operação de
dilatação da seguinte forma:
̂ ) ⋂ 𝑨 ≠ ⌀; 𝑨, 𝑩 ∈ 𝒁²}
𝑨 ⊕ 𝑩 = {𝒙|(𝑩
𝒙
Equação 6 - Dilatação de A por B
Onde A e B são conjuntos no espaço Z², por exemplo e ⊘ seja o conjunto vazio.
22
2.5.7. Limiarização
Limiarização, ou thresholding, é um processo que se baseia na diferença dos níveis
de cinza que compõe diferentes objetos de uma imagem. Escolhe-se um número (limiar) que
servirá de base para definir dois grupos: o grupo de pixels com níveis de cinza abaixo do
limiar e o grupo de pixels com níveis de cinza acima do limiar. Em uma imagem limiarizada,
atribui-se um valor fixo para todos os pixels de mesmo grupo (FILHO; NETO, 1999).
Matematicamente, a operação de limiarização pode ser descrita como uma técnica de
processamento de imagens na qual uma imagem de entrada f(x,y) de N níveis de cinza produz
à saída uma imagem g(x,y), chamada de imagem limiarizada, cujo número de níveis de cinza
é menor que N. Normalmente, g(x,y) apresenta 2 níveis de cinza, sendo:
𝒈(𝒙, 𝒚) = 𝟏 𝒔𝒆 𝒇(𝒙, 𝒚) ≥ 𝑻
{
𝒈(𝒙, 𝒚) = 𝟎 𝒔𝒆 𝒇(𝒙, 𝒚) ≤ 𝑻
Equação 7 - Condição de Limiarização
No qual os pixels rotulados com 1 correspondem aos objetos e os pixels rotulados
com 0 correspondem ao fundo (background) e T é um valor de tom de cinza pré-definido, ao
qual denominamos limiar. Para este exemplo de limiarização dá-se o nome de binarização.
Na Figura 17 vemos um exemplo de uma imagem original em escala de cinza (a) e
seu histograma (b) e logo abaixo sua imagem binarizada (c) com um limiar indicado em (d).
23
Figura 17 - Exemplo de Binarização (GONZALES; RICHARD, 2000)
2.5.8. Região de Interesse
Para medir um parâmetro dentro de uma imagem, o sistema de processamento
precisa distinguir as áreas de interesse. Esta "região de interesse" ou ROI pode ser
determinada com base em valores da intensidade do pixel ou uma área determinada pelo
usuário (Thresholding and the Region of Interest, 2014).
2.5.9. Segmentação
O processo de separação da região de interesse em uma imagem é chamado de
segmentação. Uma forma simples de segmentação é considerar um intervalo de valores da
intensidade do pixel, para identificação de objetos de interesse em uma imagem. Há outras
formas mais sofisticadas de identificação.
Quando dividimos uma imagem digital em várias regiões com o objetivo de
simplificar sua análise estamos utilizando as técnicas de segmentação de imagens. Com as
técnicas de segmentação é possível localizar objetos de interesse e formas em uma
determinada imagem (BRUCE; BALCH; VELOSO, 2000).
24
Atualmente várias técnicas e algoritmos de segmentação já foram desenvolvidos
porém não há uma solução definitiva e geral para resolução dos problemas. Na maioria das
vezes é necessária uma combinação das técnicas existentes para solução de um determinado
problema.
Dentre os tipos de segmentação podemos abordar as baseadas em formatos que têm
como o objetivo a detecção de pontos, linhas ou bordas por exemplo. As baseadas em
características dos pixels que estão em análise na imagem, baseando-se em suas cores e suas
intensidades e por fim a segmentação baseada no histograma de uma imagem.
Sua aplicação ocorre nas mais diversas áreas, como: no sistema de reconhecimento
de faces, análise de imagens médicas (JÄHNE, 1991) para detecção de tumores, volumes de
tecidos, estruturas anatômicas e por fim, nos sistemas de visão computacional voltados para
robótica como utilizado nesse trabalho.
2.5.10. Descritores de Forma
Depois que a imagem foi segmentada em regiões, os pixels agrupados são geralmente
representado e descritos em formatos apropriados para o processamento das informações. No
qual, de uma maneira simples, podemos representar esta região em termos de suas
características externas (sua fronteira), ou em termos de características internas (os pixels que
compõem a região) (BASSO, 2002).
Geralmente, uma representação externa é escolhida quando o que interessa estiver
voltado para características de forma e na representação interna quando for voltada para
propriedades como cor ou textura. Os descritores de formas são métodos matemáticos que
representam a forma da região ou objeto segmentado, onde idealmente devem possuir
invariância a rotação, ponto de início, translação e escala (SILVA et al., 2007).
2.5.11. Momentos
A forma dos segmentos da fronteira pode ser descritas quantitativamente através dos
momentos. Segundo (SOUZA; PISTORI, 2005) um dos métodos utilizados para a extração
das características da imagem são os momentos da imagem, ou momentos estatísticos.
25
Esses momentos e suas funções podem ser caracterizados como valores numéricos,
calculados a partir de uma imagem previamente segmentada e são utilizados para fornecer
descrições resumidas da distribuição espacial dos pontos contidos na imagem bidimensionais
analisada.
Esses momentos de ordem p + q sobre uma função contínua 2D, de acordo com (HU,
1962) são calculados de acordo com a Equação 8.
+∞ +∞
𝑀𝑝𝑞 = ∫ ∫ 𝑥 𝑝 𝑦 𝑞 𝐼(𝑥, 𝑦)𝑑𝑥𝑑𝑦
−∞ −∞
Equação 8 - Momentos de ordem p+q
Em (SOUZA; PISTORI, 2005) também fala que uma imagem pode ser visualizada
como uma função de duas dimensões discreta F, onde a intensidade de cada pixel é indexada
como F(x,y). A Equação 9, como demonstrado em (HU, 1962) é a derivação da Equação 8 de
momentos aplicados a imagens, visto que quando estamos trabalhando com imagens digitais,
as integrais são substituídas por somatórios.
𝑙𝑎𝑟𝑔𝑢𝑟𝑎 𝑎𝑙𝑡𝑢𝑟𝑎
𝑀𝑝𝑞 =
∑
∑ 𝑥 𝑝 𝑦 𝑞 𝐼(𝑥, 𝑦)
𝑥=1
𝑦=1
Equação 9 - Momentos aplicados a imagens
Em (SILVA et al., 2007) podemos ver que para representar objetos através de
momentos, são considerados apenas os pixels pertencentes ao objeto.
Através dos momentos é possível achar propriedades interessantes, como por
exemplo o centro de massa x e y representados pelos momentos
M10
M00
e
M01
M00
, onde M00 é o
momento que representa a área do objeto. É possível derivar também os momentos centrais
para imagens definidos pela Equação 10.
𝑙𝑎𝑟𝑔𝑢𝑟𝑎 𝑎𝑙𝑡𝑢𝑟𝑎
𝑀𝑝𝑞 =
∑
∑ (𝑥 − 𝑥̅ )𝑝 (𝑦 − 𝑦̅)𝑞 𝐼(𝑥, 𝑦)
𝑥=1
𝑦=1
Equação 10 - Momentos centrais
26
Onde a partir deste momento central, podemos achar propriedades derivadas como
variância em X e Y e a direção do objeto com as fórmulas 11 e 12 (HU, 1962).
𝜎𝑥2 =
𝑢20
𝑢02
, 𝜎𝑦2 =
𝑚00
𝑚00
Equação 11 - Variância em X e Y
𝒕𝒂𝒏 𝜽 =
(𝒖𝟎𝟐 − 𝒖𝟐𝟎 − 𝟐𝒖𝟏𝟏 + 𝝀)
(𝒖𝟎𝟐 − 𝒖𝟐𝟎 + 𝟐𝒖𝟏𝟏 − 𝝀)
Equação 12 - Direção do Objeto
Embora os momentos sejam o método mais popular, eles não são os únicos
descritores que podem ser usados com esse propósito. Por exemplo, um outro método consiste
no cálculo da transformada de Fourier unidimensional, obtendo seu espectro e utilização de
seus primeiros componentes para a descrição da função.
A vantagem dos momentos em relação a outras técnicas é que sua implementação é
direta, além de eles carregarem uma interpretação física da fronteira de uma forma e suas
características serem invariantes à escala, à posição e à orientação (HU, 1962).
2.6. Ferramentas
Encontramos bibliotecas e projetos que ajudaram a entender os conceitos e
aplicações do trabalho, como por exemplo o SSL-Vision, o Find-Object e a biblioteca
OpenCV. A primeira plataforma encontrada para o estudo da visão computacional voltada
para o projeto foi a SSL-Vision. O motivo da escolha dessa plataforma para o inicio da
pesquisa deve-se ao fato da mesma ser atualmente o sistema de captura de vídeo oficial da
Robocup categoria SSL (FIRA, 2014).
2.6.1. SSL-Vision
Em meados de 2009 o comitê organizador da Robocup decidiu criar um sistema de
visão compartilhada para uso de todas as equipes. Esse sistema não só compartilha o software
mas também permite que as duas equipes utilizem o mesmo hardware (câmeras acopladas no
27
suporte acima do campo). Dessa forma é criado um ambiente padrão para realização da
competição por diversas equipes como visto na Figura 18 (About the Small Size League,
2008) (ZICKLER et al., 2010).
Figura 18 - Tela do SSL-Vision (SSL VISION, 2010)
Todas as pesquisas do estado da arte demonstraram resultados satisfatórios dessa
plataforma (KAICK et al., 2001) (MARTINEZ-GOMEZ; WEITZENFELD, 2004)
(MARTINS; TONIDANDEL; BIANCHI, 2006) (SOUSA; PINTO; PINTO, 2010)
(GRITTANI; G.GALLINELLI; RAMŕEZ, 2000) onde mesmo sendo padrão, o ambiente
permite que cada equipe desenvolva sua própria estratégia, focando apenas no
desenvolvimento dos algoritmos sem se preocupar com interface gráfica e outros requisitos
que são essenciais como calibração, comunicação, captura das imagens das duas câmeras e
definição de parâmetros.
Porém como dito anteriormente, para padronizar os recursos utilizados por todas as
equipes da categoria Small Size, as regras definem o tipo de hardware utilizado pelas equipes
para o desenvolvimento de sua estratégia.
Como um dos objetivos do trabalho é ser de baixo custo, não foi possível utilizar o
padrão de câmera e conectores especificado nas regras da categoria. É necessário para
completa utilização desse projeto câmeras do tipo IEEE 1394 / DCAM com placas de captura
com conexão Firewire para obtenção de uma maior largura de banda. Através de pesquisas de
mercado foi identificado o investimento necessário conforme a Tabela 1.
28
Equipamento
Valor
Guppy F-046.A 1/2" CCD Color
R$ 2.232,50
Placa Captura Firewire Ieee 1394a
R$ 139,99
Cabos Firewire Ieee 1394
R$ 22,99
Total
R$ 2.395,48
Tabela 1 - Preço dos Equipamentos
Como observado na Tabela 1, o investimento médio para a ter todos os equipamentos
necessários para a aquisição das imagens do campo é de R$ 2.395,48, tornando uma das
partes mais caras do projeto de uma equipe. Dessa forma cancelamos os testes com o SSLVision e iniciamos uma nova pesquisa focada em uma implementação completa, simples e
eficiente que possa ser utilizada em um ambiente de captura controlado e com baixo
investimento em recursos computacionais.
O novo foco se tornou a procura de uma biblioteca que aceitasse comunicações USB
para utilização de uma webcam. Contudo, vale ressaltar que toda a parte de aquisição e
calibração das imagens já estão implementadas na plataforma, sendo necessário apenas
codificar a parte de processamento de imagens se quiser um melhor desempenho com alguma
técnica específica.
2.6.2. Find-Object
Na procura por novas soluções para o problema encontramos o projeto Find-Object
que são implementações de técnicas de processamento de imagens no OpenCV como SIFT,
SURF, FAST, BRIEF voltadas para reconhecimento de objetos como visto na Figura 19.
29
Figura 19 - Tela do Projeto Find-Object (FIND-OBJECT, 2012)
Como o projeto é um projeto aberto (LABBÉ, 2012), estudamos o seu código e
avaliamos a viabilidade do projeto e das técnicas que utilizam algoritmos de aprendizagem de
máquina e redes neurais. Após alguns testes identificamos que o projeto atende as
expectativas com relação a identificação de objetos em imagens, porém não atende a um dos
principais requisitos necessário nas implementações voltadas para o futebol de robôs: o tempo
de processamento.
Além da preocupação com a precisão e tolerância à variação de luminosidade no
campo, o tempo de processamento é uma dos requisitos fundamentais para o sucesso do
projeto. Como o projeto não conseguiu atender as necessidades de um sistema em tempo real,
resolvemos utilizar a ferramenta de visão computacional que ele utilizava para implementar
os algoritmos de forma mais eficiente e específica.
2.6.3. OpenCV
O
OpenCV
é
uma
biblioteca
multiplataforma
desenvolvida
pela
Intel,
disponibilizando o uso do seu código para utilizar em aplicações tanto comerciais como
acadêmicas. Ele possui módulos de álgebra linear, processamento de imagens e vídeo,
interface gráfica do usuário, estrutura de dados, controle de mouse e teclado, além de mais de
350 algoritmos de visão computacional como: calibração de câmera, filtros de imagem,
análise estrutural, reconhecimento de objetos, processamento em tempo real de imagens e
outros (BRADSKI; KAUHLER, 2013).
30
31
As áreas de aplicações desta biblioteca são muito amplas, alguns exemplos são as
áreas de sistemas de reconhecimento facial, como mostrado na Figura 20, realidade virtual,
identificação de objetos, gravação de vídeos, interface homem-máquina e reconhecimento de
movimentos.
Figura 20 - Exemplo de detecção de faces com OpenCV (PYFACEDETECT, 2010)
Ela foi desenvolvida nas linguagens C/C++ mas tem suporte para as linguagens
Python, Java e Visual Basic onde foi estruturada em módulos, no qual segundo (INTEL,
2000) os módulos principais são:
a) core - um módulo compacto que define as estruturas de dados básicas,
incluindo a matriz multi-dimensional Mat e funções básicas usado por todos os
outros módulos.
b) imgproc - um módulo de processamento de imagem, que inclui filtragem de
imagens linear e não-linear, transformações geométricas de imagem, conversão
de espaço de cores, histogramas, e assim por diante.
c) video - um módulo de análise de vídeo que inclui estimativa de movimento,
subtração de imagens e algoritmos de rastreamento de objetos.
d) calib3d - algoritmos básicos de calibração de câmera única e estereoscópica,
estimativa de objetos e elementos da reconstrução 3D.
e) features2d
-
detectores
de
características
salientes,
descritores
e
identificadores de descritores.
f) objdetect - detecção de objetos e instâncias de classes predefinidas, como por
exemplo: faces, olhos, canecas, pessoas, carros e etc.
g) highgui - uma interface simples de usar de captura de vídeo, imagem e codecs
de vídeo com possibilidade de fazer simples interfaces gráficas como janelas,
botões e barras de rolagem.
h) gpu - algoritmos com aceleração de GPU (unidade de processamento gráfico)
de diferentes módulos do OpenCV.
Tanto o SSL-Vision quanto o Find-Object são projetos que utilizam algoritmos do
OpenCV. Os motivos principais para utilização da biblioteca no nosso projeto são os vários
algoritmos de visão computacional e sua capacidade de realizar processamento de imagens
em tempo real.
2.6.4. IDEs
Primeiro, foi instalado o OpenCV na máquina virtual com o sistema operacional
Ubuntu instalado como mostrado no Apêndice 1. Depois de testarmos um exemplo pelo
terminal, configuramos uma IDE para trabalhar.
Como não conseguimos utilizar os projeto citado anteriormente, começamos a
desenvolver uma aplicação que conseguisse identificar e rastrear os robôs e a bola em campo.
Utilizamos o Git4 e o Meld5 para fazer o controle de versão e gerenciar as mudanças que
ocorreram durante o desenvolvimento no projeto e o Qt Studio como ambiente de
desenvolvimento como mostrado no Apêndice 2.
Depois que configuramos todo o ambiente e começarmos a desenvolver, tivemos
vários problemas com compatibilidade de drivers com a máquina virtual e a camera que
foram solucionados e documentado no Apêndice 4.
De modo geral, o desenvolvimento do projeto teve quatro fases: captura da imagem,
calibração, processamento e exibição das informações na tela.
4
5
Git - https://github.com/
Meld - http://meldmerge.org/
32
Metodologia
3. Metodologia
Um módulo de visão computacional aplicado ao futebol de robôs pode ser
decomposto em algumas partes: transformação do espaço de cores, classificação de cores,
segmentação e localização de objetos. Uma vez que a câmera de vídeo forneça imagens do
campo no formato RGB, uma transformação para o espaço de cores HSV é necessária, onde a
matiz de cada cor independe da luminosidade existente, tornado o sistema mais robusto a
variações da mesma.
Como o formato HSV fornece um número muito grande de cores diferentes, é
preciso alguma forma de classificação das mesmas para o ambiente de futebol de robôs,
fazendo com que todos os pontos que formam a imagem pertençam a um conjunto limitado de
cores diferentes, chamadas de classes de cores. Isto é feito a partir de uma calibração,
definindo intervalos de tons para cada classe.
Com esta classificação o processo de segmentação torna-se mais simples de ser
realizado, tendo como objetivo encontrar manchas (conjunto de pontos adjacentes) de cada
classe de cores.
3.1. Captura da Imagem
Para fazer a parte de captura, teríamos que ter uma imagem dos robôs e da bola, mas
como a proposta do trabalho não é o desenvolvimento dos robôs foram impressos, cículos
grandes que representariam os robôs e circulos menores para representações dos marcadores.
Era necessário colocar a câmera em uma posição que fosse a mais próxima possível
de como seria em uma competição de verdade como é possível ver na Figura 21. Foi colocada
inicialmente no teto mas descobriu-se ao capturar as imagens que havia pouca iluminação do
ambiente e que a câmera estava com defeito pois ficava com muita variação no brilho.
33
Metodologia
Figura 21 - Câmera na posição vertical (AUTORES, 2014)
A posição da câmera e do campo foi trocada para tentar ter a menor interferência
possível das sombras e ter mais iluminação. Após vários testes foi analizado que um bom
local seria a parede, porém havia ainda muito ruído na imagem por causa da reflexão da luz
nos marcadores de papel que refletiam a luz. Trocamos o material dos marcadores e a câmera,
conseguindo imagens melhores como visto na Figura 22.
Figura 22 - Campo Colocado na Parede (AUTORES, 2014)
Após captura da imagem, começou-se a trabalhar com o streaming de câmera, por
causa do requisito do problema que tem que ser em tempo real todo o processamento.
34
Metodologia
3.2. Calibração
Mesmo com a imagem melhor, ainda era um problema as bordas fora do campo e
qual a faixa das cores capturadas na hora em que realizava as binarizações, portanto foi
fundamental a calibração da câmera no ambiente. Para isto seguimos o fluxo da Figura 23:
Figura 23 - Passos para a calibração da câmera (AUTORES, 2014)
Para tirar os ruídos ditos anteriormente utilizamos a técnica de região de interesse
para apenas analisar a área do campo de futebol. Para facilitar a definição dos dois pontos da
diagonal principal da região de interesse foi feito o tratamento de evento do mouse na janela e
para facilitar a identificação da região, foram invertidos os valores das componentes RGB de
cada pixel, negativando a área como visto na Figura 24.
Figura 24 - Definição da Região de Interesse (AUTORES, 2014)
Depois de selecionada a área onde será processada as informações, o passo seguinte
da metodologia foi ver qual o valor do raio e das áreas mínimas de cada objeto em cena. Para
conseguir esses parâmetros, foi utilizado o método dos momentos para saber a media das
áreas dos robôs e da bola.
35
Metodologia
Definidos esses parâmetros, deve-se configurar os limites das cores dos marcadores.
Para isto foi criado uma janela com as barras de saturação, da matiz e do brilho onde
observou-se qual era o melhor valor para cada cor, pois a regra da RoboCup exige que alguns
marcadores sejam sorteados minutos antes das partidas. Assim, a calibração só pode ocorrer
depois que os marcadores tenham sido sorteados pelo juís da partida.
O melhor resultado seria os valores de HSV que filtrariam apenas a cor selecionada
como na Figura 25 que foi filtrada apenas a cor laranja.
Figura 25 - Calibração das cores dos marcadores (AUTORES, 2014)
Após calibração de todas as cores, coloca-se na biblioteca de parâmetros a
quantidade de robôs de cada equipe, quantos marcadores serão utilizados e quais as cores de
cada tipo de robô.
Foi implementado um padrão de identificação com cinco marcadores, atribuindo a
classe do robô um vetor de marcadores com cinco elementos, que seria mais que suficiente
para a identificação e rastreamento de cada robô, visto que apenas com dois já é possível ter o
mesmo resultado e com menos processamento, porém com esta configuração pode-se testar
os limites da abordagem proposta.
36
Metodologia
3.3. Processamento
Depois do sistema ser calibrado, pode-se fazer o processamento da região de
interesse e fazer a identificação dos robôs e da bola em tempo real. O fluxograma visto na
Figura 26, demonstra o processo.
Figura 26 - Fluxograma do processamento (AUTORES, 2014)
Após a captura do frame, que é a imagem capturada do vídeo, e a filtragem da região,
para a identificação dos objetos utilizou-se operações morfológicas e técnicas de
processamento de imagem abordadas na fundamentação teórica, mas para isto foi seguido os
seguintes passos:
1. Transformar o frame de RGB para HSV
2. Limiarizar pela cor para filtrar os robôs ou a bola
3. Erodir e dilatatar o frame para tirar os ruídos
4. Encontrar os contornos dos objetos filtrados com os conceitos de vizinhança e
conectividade, analizar os pontos que são vizinhos e armazenar seu centro em um
vetor
5. Utilizar o método dos momentos para a identificação se o contorno é um objeto
6. Armazenar as coordenadas do centro do objeto
7. Identificar se é bola ou robô e qual o tipo de robô
1. Pegar o ROI do objeto que será identificado
2. Repetir do passo 2 até o 6 para todos os marcadores
37
Metodologia
3. Se todos os marcadores forem identificados com o tipo do robô, atribui o nome
dele, senão repete o passo 7.2
Inicialmente teve a conversão da imagem RGB para HSV para conseguir binarizar
através de um valor mínimo e máximo os pontos de saturação, matiz e brilho. Estes valores
foram encontrados na etapa de calibração onde para encontrar os robôs, colocou-se os valores
de limiarização da cor preta e para encontrar a bola colocou-se a cor laranja.
Com a imagem limiarizada, foi obtida uma imagem ainda com muitos ruídos e se
avançasse para a próxima etapa de detectação de contornos, isso levaria muito mais tempo
pois o número de contornos encontrados seria muito maior, portanto, aplicou-se as técnicas de
erosão e dilatação na imagem para poder eliminar os pequenos ruídos.
Com os contornos encontrados, foi utilizado o método estatístico dos momentos
citado anteriormente e já implementado pela biblioteca do OpenCV, para poder calcular a
área de cada objeto e identificar se é bola, robôs ou apenas ruídos de acordo com os
parâmetros de área mínima definida. Logo em seguida, foi armazenado as coordenadas dos
centros, já conseguindo distinguir entre robôs e bolas como visto na Figura 27:
Figura 27 - Identificação dos objetos no campo (AUTORES, 2014)
Depois de identificado os robôs, o próximo passo é classificá-los. Foram definidos os
marcadores de cada tipo de robô no arquivo de configuração, colocando o nome da cor no
vetor dos marcadores de cada equipe, podendo mudar facilmente a quantidade de marcadores,
as cores e a quantidade de robôs por equipe.
38
Metodologia
Utilizou-se cinco marcadores para analisar o caso de maior complexidade
computacional, visto que na competição, com apenas dois marcadores já daria para classificar
e rastrear os robôs. Para conseguir classificar o robô como atacante, zagueiro ou goleiro foi
necessário calcular a região de interesse apenas do robô que foi detectado e logo em seguida
analisar todos os marcadores com a mesma técnica de antes, porém apenas na ROI escolhida.
Feito isto, encontram-se os cinco marcadores e consegue-se saber através da
filtragem por cores quais são os cinco identificadores e comparou-se com as definições no
arquivo de configuração.
3.4. Exibição das Informações
Depois de classificado, a próxima etapa é colocar as informações processadas na
imagem original. Como tem a informação do centro de cada objeto detectado, nas
coordenadas das suas respectivas regiões de interesse, calculou-se onde ficará cada objeto no
frame original e colocou-se a identificação, o número da equipe e as coordenadas x,y na
imagem. Com estes dados poderia ser calculado em que lugar cada objeto estaria no campo de
verdade, através de proporcionalidade.
Para os testes, foram feitas duas equipes, uma na cor vermelha e outra na cor verde,
definição essa vista no círculo central de cada robô, e cada equipe com dois atacantes, dois
zagueiros e um goleiro cada. O padrão adotado foi o de colocar as rodas com cores iguais e
cores diferentes para o marcador de equipe, o da frente e o de trás como visto na Figura 28.
Figura 28 - Significado dos marcadores nos robôs (AUTORES, 2014)
39
Metodologia
O resultado que obtido foi igual ao mostrado na Figura 29:
Figura 29 - Reconhecimento dos robôs e da bola (AUTORES, 2014)
Percebe-se na figura anterior que foi colocado propositalmente um marcador na cor
preta, no lado esquedo da imagem, para verificar se o algoritmo que foi criado iria identificálo como robô, pois o marcador é da mesma cor, porém como o algoritmo também analiza a
área do contorno com o método estatístico dos momentos, esta possibilidade tornou-se
inexistente.
40
Resultados
4. Resultados
Os testes obtiveram resultados expressivos tanto em relação ao tempo, como em
relação a qualidade de detecção. Foram feitos testes de tempo de processamento para cada
robô inserido no campo em uma máquina virtual com 2 Gb de RAM, 50 Gb de HD e 2 núcleis
conseguimos a Tabela 2.
Quantidade de Robôs
Menor Tempo
Maior Tempo
Média de Tempo
1
0.0174139
0.0467508
0.0243215
2
0.0204348
0.0449992
0.0270491
3
0.0218374
0.0518048
0.0289997
4
0.0233299
0.0531306
0.0298047
5
0.0245468
0.056575
0.0315339
6
0.0297778
0.065182
0.0351073
7
0.0310514
0.0688607
0.0365691
8
0.0325722
0.0699962
0.0377235
9
0.0333919
0.0714980
0.0407741
10
0.0356618
0.0754286
0.0429745
Tabela 2 - Tempo de processamento em segundos
Estes dados foram obtidos a cada mil ciclos de detecção de todos os objetos no
campo, salvando o maior, menor e a média do tempo em segundos para detecção de robôs
com cinco marcadores. O tempo mínimo e máximo variam muito de acordo com as mudanças
de iluminação no campo e execução de outras aplicações no hospedeiro, entretanto, ao
analizar a média de tempo, os dados obtidos foram os esperados, na qual aumentava-se o
tempo médio ao colocar mais robôs no campo, como observado na Figura 30.
41
Resultados
Figura 30 - Gráfico do tempo em segundos Vs Quantidade de robôs (AUTORES, 2014)
Para cada robô inserido no campo o tempo médio subia aproximadamente em 2ms,
resultando no gráfico mostrado. Vale ressaltar que no momento das coletas de dados, não
houveram alterações nas configurações da máquina virtual, portanto, os resultados podem
melhorar mais ao colocarmos mais recursos de processamento na mesma ou colocando o
sistema na máquina hospedeira.
42
Conclusões e trabalhos futuros
5. Conclusões e trabalhos futuros
Vimos que esta área está repleta de desafios e que os problemas encontrados para o
desenvolvimento das técnicas é natural pois exige uma maturidade muito grande do
programador nos conceitos e na linguagem de programação escolhida. Mesmo com muitos
problemas de infra estrutura, conseguimos implementar um algoritmo que alcançou os
objetivos iniciais de detecção dos agentes em campo e que fosse em tempo real.
Os resultados obtidos foram muito bons pois tivemos que encontrar soluções para
melhorar a qualidade da imagem adquirida, calibrar a câmera e utilizamos um número de
marcadores e robôs superiores ao necessário em uma partida de futebol no qual mesmo assim
ainda resultou em um tempo de detecção em média menor do que 45ms como visto na tabela
de resultados, tornando totalmente viável a aplicação em uma competição, onde as equipes
que trabalhavam nessa área obtiveram resultados parecidos.
Como trabalhos futuros, seria muito bom para a continuação deste trabalho adquirir
as câmeras para podermos utilizar o software recomendado SSL-Vision e preparar um
ambiente com as reais dimensões do campo e com uma boa qualidade de iluminação para
diminuir os ruídos nas imagens.
Também seria importante testar o código desenvolvido em uma máquina real, com
um processador de última geração e com mais RAM para coletar mais dados e analizar se há
necessidade de trabalhar com placas de aceleração gráfica.
Implementar outras técnicas de detecção e reconhecimento e comparar com os
resultados das outras equipes como as que envolvem descritores mais sofisticados ou com
aprendizagem de máquina como em (JÜNGEL; HOFFMANN;.LÖTZSCH, 2004) (SIMÕES;
COSTA, 2001) (ARAUJO; MENDONÇA; FREIRE, 2004) (RILLO, 1989) (NUNES;
PRADO, 2002) (DUARTE, 2003) (HOFFMAN; D.SILVA, 2004).
Poderia também
testar o algoritmo desenvolvido no trabalho com variação de
iluminação e no SSL-Vision para analisar o desempenho em comparação com as técnicas que
já vem por padrão no software.
A contribuição mais relevante para o projeto, seria desenvolver o hardware dos
robôs, a parte de comunicação e de estratégia de movimentação para poder juntar com a parte
de visão e competir na próxima RoboCup com um time multidisciplinar de futebol do IFPE.
43
Bibliografia
6. Bibliografia
ABOUT the Small Size League, 2008. Disponivel em: <http://robocupssl.cpe.ku.ac.th>. Acesso em:
Abril 2014.
AIRES, K. R. T.; ALSINA, P. J.; MEDEIROS, A. A. D. A global vision system for mobile mini-robots. SBAI Simpósio Brasileiro de Automaçãao Inteligente, 2001.
ANDRADE, B. T.; MATOS, L. N.; FREIRE, E. O. Um Sistema de Visão Computacional para Robôs Móveis.
XXVI Congresso da SBC, 2006.
ARAUJO, G. M.; MENDONÇA, M. M.; FREIRE, E. O. RECONHECIMENTO AUTOMÁTICO DE OBJETOS
BASEADO EM COR E FORMA PARA APLICAÇÕES EM ROBÓTICA, 2004.
ASSIS, W. O. et al. Desenvolvimento de Robôs Autônomos para Participação em Competição de
Futebol. VII SBAI/ II IEEE LARS , Setembro 2005.
BALLARD, D.; BROWN, C. Computer Vision. Englewood Cliffs: Prentice-Hall, 1982.
BASSO, E. W. Identificação Visual de Posição e Movimento para Futebol de Robôs. Trabalho de
Conclusão de Curso, Universidade Luterana do Brasil, 2002.
BECKER, M. Aplicação de tecnologias assistivas e tecnicas de controle em cadeiras de rodas
inteligentes, 2000.
BIANCHI, A. D. C. VISÃO COMPUTACIONAL APLICADA AO CONTROLE DE MICRO ROBÔS. [S.l.]. 2001.
BIANCHI, R. A.; REALI-COSTA, A. H. O Sistema de Visão Computacional do time FUTEPOLI de Futebol
de Robôs. Congresso Brasileiro de Automática, 2000. Vol. 130, pp. 2156-2162.
BLOGDACOPA. Projeto Andar Denovo, 2014. Disponivel em: <http://goo.gl/SlnOh9>. Acesso em:
Maio 2014.
BRADSKI, G. R.; KAUHLER, A. Learning OpenCV: Computer Vision with the OpenCV Library. Famham:
O'Reilly, 2013.
BRUCE, J.; BALCH, T.; VELOSO, M. Fast and inexpensive color image segmentation for interactive
robots. Intelligent Robots and Systems IEEE/RSJ International Conference. [S.l.]: IEEE. 2000. p. Vol. 3,
pp. 2061-2066.
44
Bibliografia
BURKHARD, H. D. et al. The road to RoboCup 2050. Robotics & Automation Magazine, 2002. 31-38.
CARDANI, D. Adventures in HSV Space, 2004. Disponivel em:
<http://www.buena.com/articles/hsvspace.pdf>. Acesso em: Abril 2004.
CASSADIO, M. et al. Body machine interface: Remapping motor skills after spina cord injury. IEEE
International Conference on Rehabilitation Robotics (ICORR), July 2011. 1-6.
CORAL, C. M. U. Small Size Team. Carnegie Mellon University robot soccer CORAL research group,
2010. Disponivel em: <http://goo.gl/f7elQ4>. Acesso em: Maio 2014.
COSTA, A. H. R.; PEGORARO, R. Construindo robôs autônomos para partidas de futebol: o time
GUARANÁ. SBA Controle & Automação, 2000. 141-149.
DALBEM, C. M. RoboPET - arquitetura e desenvolvimento de um time autônomo de futebol de robôs.
Salão de Iniciação Científica, 22 Outubro 2010. 18-22.
DIGPLANET, 2014. Disponivel em:
<http://www.digplanet.com/wiki/RoboCup_2D_Soccer_Simulation_League>. Acesso em: 2014.
DR. Rui Costa. Página do Facebook, 2013. Disponivel em: <http://goo.gl/3sDjeI>. Acesso em: Janeiro
2014.
DUARTE, G. D. Uso da Transformada de Hough na Detecção de Círculos em Imagens Digitais. Revista
Científica do Centro Federal de Educação Tecnológica, p. 51-58, 2003.
FILHO, O. M.; NETO, H. V. Procesamento Digital de Imagens. Rio de Janeiro: Brasport, 1999.
FIND-OBJECT , 2012. Disponivel em: <https://code.google.com/p/find-object/>. Acesso em: 2014.
FIRA. Small League Mirosot Game Rules, 2014. Disponivel em:
<http://www.fira.net/soccer/mirosot/overview.html>. Acesso em: Janeiro 2014.
GARCIA, R. F. et al. Um arcabouço para a localização de enxames de robôs. Anais do Simpósio
Brasileiro de Automação Inteligente, 2007.
GONZALES, R. C.; RICHARD, E. W. Processamento de Imagens Digitais. São Paulo: Edgard Blucher,
2000.
GRITTANI, G.; G.GALLINELLI; RAMŕEZ, J. Futbot: A vision system for robotic soccer. Advances in
Artificial Intelligence Springer Berlin Heidelberg, 2000. 350-358.
45
Bibliografia
HOFFMAN, L. T.; D.SILVA, J. Um sistema de visão robótica baseada em aprendizagem por reforço.
INPE Programa de Pós-gradução em Computação Aplicada, 2004.
HU, M. K. Visual pattern recognition by moment invariants. Information Theory, 1962. 179-187.
IAUBS. IAUBS Robot Team, 2010. Disponivel em: <http://www.iaubsroboteam.blogfa.com/>. Acesso
em: 2014.
IBRO. Visão humana, International Brain Research Organization, 2014. Disponivel em:
<http://goo.gl/0X93ol>. Acesso em: Janeiro 2014.
IGREBOT, 2014. Disponivel em: <http://wiki.igrebot.fr/images/0/0c/Slides.pdf>. Acesso em: 2014.
INTEL. Open Source Computer Vision Library Reference Manual. Intel Corporation. Open Source
Computer Vision Library Reference Manual, 2000. Disponivel em: <http://developer.intel.com>.
JÄHNE, B. Digital Image Processing: Concepts, Algorithms, and Scientific Applications. Berlin:
Springer-Verlag, 1991.
JÜNGEL, M.; HOFFMANN, J.;.LÖTZSCH, M. A real-time auto-adjusting vision system for robotic soccer.
RoboCup 2003: Robot Soccer World Cup VII Springer Berlin Heidelberg, 2004. 214-225.
KAICK, O. M. V. et al. Identificacao e Rastreamento em Tempo Real de Multiplos Agentes Autonomos,
2001.
KITANO, H. et al. RoboCup: A challenge problem for AI. AI magazine, p. 73, 1997.
LAB, C.-S. A. C. R. Small Size robot, 2008. Disponivel em: <http://goo.gl/oPPqh0>.
LABBÉ, M. Find-Object Project, 2012. Disponivel em: <https://code.google.com/p/find-object/>.
LEFEO. Olho humano, Laboratório de Espectrofotometria e Ensino de Óptica, 2014. Disponivel em:
<http://goo.gl/vZUjQW>.
MARTINEZ-GOMEZ, L. A.; WEITZENFELD, A. Real Time Vision System for a Small Size League Team. 1st
IEEE-RAS Latin American Robotics Symposium, October 2004. 28-29.
MARTINS, M. F.; TONIDANDEL, F.; BIANCHI, R. A. Reconhecimento de Objetos em Tempo Real para
Futebol de Robôs. Anais do XXVI Congresso da Sociedade Brasileira de Computação, 2006. 173-182.
46
Bibliografia
MCMAHAN, W.; BUNTING, J.; MIDDLETON, R. Robocup Vision Processing Background, 2014.
Disponivel em: <http://murray.newcastle.edu.au/users/students/2002/c3012299/bg.html>. Acesso
em: Abril 2014.
MÉDICO de Olhos. Buraco macular: o que é e como tratar, 2011. Disponivel em:
<http://www.medicodeolhos.com.br/2011/08/buraco-macular-o-que-e-e-como-tratar.html>. Acesso
em: Janeiro 2014.
MEHL, E. L. D. M. et al. FUTEBOL DE ROBÔS" COMO FERRAMENTA TECNOLÓGICA PARA O ENSINO
DE ENGENHARIA ELÉTRICA E CIÊNCIA DA COMPUTAÇÃO. [S.l.]. 2001.
MOREIRA, A. L. S.; VASCONCELOS, F. N. O. Uso de Robótica Assistiva no Auxílio de Pessoas com
Deficiências Visuais. V CONNEPI, 2010.
NASA, J. P. L. Mars Exploration Rover Mission: Home. Mars Exploration Rover Mission, Julho 2004.
Disponivel em: <http://marsrovers.jpl.nasa.gov/home/index.html>.
NEVES, R. S. D.; TADDEI, L.; BANDEIRA, I. Visao Computacional e Estrategias de Controle Aplicadas ao
Futebol de Robos. XIX Congresso Regional de Iniciação Científica e Tecnológica em Engenharia –
CRICTE, 2004.
NEXUS. NEXUS RoboCup Soccer Simulation Team, 2009. Disponivel em: <http://nexus.um.ac.ir/>.
Acesso em: 2014.
NICOLELIS. Mind-controlled prostheses offer hope for disabled. the Washington Post, Abril 2014.
Disponivel em: <http://www.washingtonpost.com/national/health-science/mind-controlledprostheses-offer-hope-for-disabled/2013/05/03/fbc1018a-8778-11e2-98a3b3db6b9ac586_story.html>.
NIPPON, 2012. Disponivel em: <http://www.nippon.com/ja/views/b00908/>. Acesso em: 2014.
NUNES, L. E. N. P.; PRADO, P. P. L. Reconhecimento de Objetos contidos em imagens atraves de
Redes Neurais. Revista Ciencias Exatas, 2002.
PENHARBEL, E. A. et al. Filtro de imagem baseado em matriz RGB de cores padrao para futebol de
robos. I Encontro de Robotica Inteligente, 2004.
PERCRO. Perceptual Robotics Laboratory, 2014. Disponivel em: <http://www.percro.org/>.
PEREZ, A. L. F. et al. Desenvolvimento de Robos para Jogos de Futebol de Robos. Revista Técnico
Científica do IFSC, p. 53, 2012.
47
Bibliografia
PODCASTS, H. T. R. SWITCH TO 24 BIT AUDIO IN WINDOWS [HOW TO], Maio 2014. Disponivel em:
<http://www.howtorecordpodcasts.com/switch-24-bit-audio-windows-how-to/>. Acesso em: Maio
2014.
PYFACEDETECT. Brainacle, 2010. Disponivel em: <http://brainacle.com/tag/face-detection.html>.
Acesso em: 2014.
RIA. Robotic Industries Association. Disponivel em: <www.robotics.org>. Acesso em: Agosto 2014.
RILLO, A. H. R. C. Sistema de Visao Binaria com Reconhecimento de Pecas Parcialmente Oclusas.
Dissertacao de mestrado - Faculdade de Engenharia Industrial de Sao Bernardo do Campo, 1989.
RUDEK, M.; COELHO, L. D. S.; CANCIGLIERI, O. Visao Computacional Aplicada a Sistemas Produtivos:
Fundamentos e Estudo de Caso. XXI Encontro Nacional de Engenharia de Producao, 2001.
SCHOUTE, A.; POEL, M.; HEIJDEN, I. F. The development of a vision system for robotic soccer. [S.l.]:
[s.n.], 2003.
SCHWARTZ, W. et al. Reconhecimento em tempo real de agentes autônomos em futebol de robôs. VI
Simpósio Brasileiro de Automaçao Inteligente-SBAI., 2003.
SILVA, J. A. et al. Comparaçao de descritores de formas no reconhecimento de objetos. III Workshop
de Visao Computacional, Outubro 2007.
SIMÕES, A. S.; COSTA, A. H. R. Classificação de cores por redes neurais artificiais: um estudo do uso
de diferentes sistemas de representação de cores no futebol de robôs móveis autônomos. Encontro
Nacional de Inteligência Artificial / XXI Congresso da Sociedade Brasileira de Computação, 2001.
182.
SIMONE, M. et al. Body Extender: whole body exoskeleton for exoskeleton for human power
augmentation. IEEE Intenational Conference on Robotics and Automation, 2011.
SOUSA, B. M.; PINTO, L. S.; PINTO, R. S. Estudo sobre o SSL-VISION. São João Del Rei: Universidade
Federal de São João Del Rei - UFSJ, 2010.
SOUZA, K. P.; PISTORI, H. Implementação de um extrator de características baseado em momentos
da imagem. XVIII Brazilian Symposium on Computer Graphics and Image Processing-SIBGRAPI,
Outubro 2005.
SSL VISION. SSL Vision Project, 2010. Disponivel em: <https://code.google.com/p/sslvision/wiki/ApplicationOverview>. Acesso em: 2014.
48
Bibliografia
TECHNO , 2011. Disponivel em: <http://techno.bigmir.net/technology/1510235-Chempionat-mirapo-futbolu-sredi-robotov-projdet-v-Turcii>. Acesso em: 2014.
THRESHOLDING and the Region of Interest. Thresholding and the Region of Interest, 11 Maio 2014.
Disponivel em: <http://microscopy.berkeley.edu/courses/dib/sections/03IPII/ROI.html>.
WIKIPÉDIA. Convolução - Wikipédia, a enciclopédia livre. Wikipédia, a enciclopédia livre, 2014.
Disponivel em:
<http://pt.wikipedia.org/wiki/Convolu%C3%A7%C3%A3o#Convolu.C3.A7.C3.A3o_discreta>. Acesso
em: abr. 2014.
YASUTOMI, A. Y.; MIRANDA, A. B. W. Exoesqueleto Robótico de Membro Superior para Estudo do
Controle Motor Humano. Monografia de Conclusão de Curso, Escola Politécnica da USP, 2011.
ZEISS. Education in Microscopy and Digital Imaging, 2014. Disponivel em: <http://goo.gl/LqYdJO>.
Acesso em: Abril 2014.
ZICKLER, S. et al. SSL-vision: The shared vision system for the RoboCup Small Size League. RoboCup
2009: Robot Soccer World Cup XIII Springer Berlin Heidelberg. , 2010. 425-436.
49
Apêndices
7. Apêndices
7.1. Apêndice 1 - Instalação do OpenCV
Para instalar o OpenCV no Ubuntu é preciso executar o terminal e instalar os pacotes
essenciais de compilação como o g++ e o cmake com o seguinte comando:
sudo apt-get install build-essential checkinstall cdbs devscripts dh-make fakeroot libxmlparser-perl check avahi-daemon -y
Após instalado os pacotes essenciais, é necessário instalar os pacotes que serão
necessários para compilar um projeto com o OpenCV com os seguinte comando:
sudo apt-get install build-essential checkinstall git cmake ffmpeg libfaac-dev libjack-jackd2dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libsdl1.2-dev libtheoradev libva-dev libvdpau-dev libvorbis-dev libx11-dev libxfixes-dev libxvidcore-dev texi2html
yasm zlib1g-dev libtbb-dev libv4l-dev libopenexr-dev libunicap2-dev libavformat-dev
libswscale-dev libdc1394-22-dev libgstreamer0.10-0 libgstreamer0.10-dev gstreamer0.10tools gstreamer0.10-plugins-base libgstreamer-plugins-base0.10-dev gstreamer0.10-pluginsgood gstreamer0.10-plugins-ugly gstreamer0.10-plugins-bad gstreamer0.10-ffmpeg pythonnumpy && sudo apt-get install libcv2.3 libcv-dev libhighgui2.3 libhighgui-dev libopencv-* -y
Outra maneira de instalar seria adicionando o repositório gijzelaar/opencv2.4,
atualizando e instalando o com os comando abaixo:
sudo add-apt-repository ppa:gijzelaar/opencv2.4 -y && sudo apt-get update
sudo apt-get install libopencv-dev opencv-doc -y
Após a instalação destes pacotes, o Ubuntu estará apto para rodar os algoritmos e
exemplos. Se quiser, é possível também compilar o código fonte e construir apenas os
módulos necessários, mas para isto será necessário seguir os passos do site6 onde também
poderá ser encontrado os passos para a instalação no Windows.7
6
7
Instalação do OpenCV no Linux - Disponível em: http://goo.gl/dzuqWM
Instalação do OpenCV no Windows -Disponível em: http://goo.gl/cVUt1s
50
Apêndices
7.2. Apêndice 2 - Configurar o Eclipse, NetBeans e Qt Studio
Inicialmente foi usado o ambiente Eclipse8 pois atende uma das especificações do
projeto, que é seguir o padrão open-source. É uma IDE implementada em Java e uma das
mais utilizadas em todo mundo. Mesmo sendo implementada em Java, através de plugins
pode-se criar projetos em PHP, Python e C/C++, por exemplo.
Para implementação dos códigos do OpenCV foi utlizado o Eclipse CDT, ambiente
de desenvolvimento voltado para implementação em C/C++. Com os repositórios do Ubuntu,
os pacotes necessários foram instalados e a configuração é mostrado em seguida. Foi
configurado também a IDE NetBeans9 pois é muito utilizada também pelos desenvolvedores e
mais fácil de criar interfaces gráficas, o que não acontece no Eclipse, onde não foi encontrado
uma maneira de desenvolver uma GUI em C++.
7.2.1. Eclipse
● Crie um projeto C/C++ (com o Eclipse CDT ou Eclipse tradicional com os plugins
configurado para poder compilar projetos em C/C++).
● Nas propriedades do projeto, clique em “C/C++ Build” e depois em “Settings”.
● Em “Tool Settings” vá em “GCC C++ Compiler” e na opção de “Directories” insira os
paths do OpenCV.
● Depois vá em GCC C++ Linker e na parte de Libraries adicione na lista as ”libraries”
e o “library search path”.
7.2.2. NetBeans
● Crie um novo projeto C/C++, clique com o botão direito no projeto e acesse a opção
de Propriedades.
8
9
Eclipse IDE - http://www.eclipse.org/
NetBeans IDE - https://netbeans.org/
51
Apêndices
● Em “Build”, clique em “C++ Compiler” e adicione os diretórios na lista em “Include
Directories”.
● Depois vá na opção de “Linker do Build” e adicione as bibliotecas abaixo:
○
○
○
○
○
○
○
○
○
○
○
○
libopencv_calib3d.so
libopencv_contrib.so
libopencv_core.so
libopencv_features2d.so
libopencv_flann.so
libopencv_gpu.so
libopencv_highgui.so
libopencv_imgproc.so
libopencv_legacy.so
libopencv_ml.so
libopencv_objdetect.so
libopencv_video.so
Porém com andamento do trabalho, foi visto que seria necessária a implementação
futura de uma interface gráfica e não foi encontrado muitos plugins que facilitem a
manipulação de interface gráfica em C++. O que não ocorre quando o projeto é desenvolvido
em Java, no qual tanto no NetBeans quanto no Eclipse existem vários plugins onde é possível
desenvolver facilmente interfaces bem acabadas. Esse fator foi de suma importância para
mudarmos para o QtStudio.
7.2.3. Qt Studio
O Qt é um framework para desenvolvimento em C++ multiplataforma. Ele permite
desenvolver aplicativos e bibliotecas e compilá-los para diversas plataformas sem que seja
necessário alterar o código. Essa facilidade oferecida pela ferramenta pesou positivamente
para mudança de IDE do projeto.
Basicamente o Qt resolveu a maior parte das dificuldades encontradas durante a
utilização do Eclipse e do NetBeans, além de uma melhor usabilidade, a implementação de
uma interface gráfica no QtStudio apresentou ser mais prática, tornando uma ferramenta
poderosa para o estudo da visão computacional. A instalação do QtStudio e sua integração
com OpenCV também poderá ser encontrada abaixo.
Como foi utilizado o Qt no trabalho, vamos detalhar um pouco mais a configuração
do mesmo. Para instalar basta colocar no terminal os comandos abaixo:
52
Apêndices
sudo apt-add-repository ppa:ubuntu-sdk-team/ppa -y && sudo apt-get update
sudo apt-get install qtdeclarative5-dev qtdeclarative5-dev-tools qtbase5-* cmake kdelibs5data ubuntu-sdk qtquick1-5-dev -y
Com tudo instalado corretamente, é preciso configurar um projeto no Qt Creator que
rode um exemplo do OpenCV. Para isto, vá em: “File” escolha “New file or project”, clique
em “Qt Widget Project” logo em seguida “Qt GUI Application” e por fim “Choose”. Abra o
arquivo .pro e cole o path e as bibliotecas abaixo e salve.
INCLUDEPATH += /usr/local/include/opencv
INCLUDEPATH += /usr/local/include/opencv2
LIBS += -L/usr/local/lib
LIBS += -lopencv_core
LIBS += -lopencv_imgproc
LIBS += -lopencv_highgui
LIBS += -lopencv_ml
LIBS += -lopencv_video
LIBS += -lopencv_features2d
LIBS += -lopencv_calib3d
LIBS += -lopencv_objdetect
LIBS += -lopencv_contrib
LIBS += -lopencv_legacy
LIBS += -lopencv_flann
Agora abra o arquivo .ui clique e arraste um botão para a janela. Mude seu atributo
“objectName” para btnDisplay e seu atributo “text” para Display. Em seguida, clique com o
botão direito e escolha “Go to Slot” e logo em seguida “clicked()”.
Figura 31 - Criando um exemplo no Qt Studio (AUTORES, 2014)
53
Apêndices
Coloque o código abaixo dentro da função do evento:
1.
2.
3.
4.
5.
6.
7.
8.
cv::namedWindow("Display");
cv::VideoCapture cap(0);
cv::Mat frame;
do{
cap >> frame;
imshow("Display",frame);
}while(cv::waitKey(30)<0)
cv::destroyAllWindows();
Não esquecendo de incluir as bibliotecas “core” e “highgui”. O resultado será uma
janela mostrando sua câmera quando o botão for clicado.
Figura 32 - Qt Studio configurado com o OpenCV (AUTORES, 2014)
Depois de instalado o OpenCV, agora pode-se configurar um projeto C/C++ e
aproveitar todas as vntagens do IDE em um projeto de visão computacional. Depois de muita
pesquisa e testes10, integramos o OpenCV nos ambientes.
10
Todos os tutoriais encontram-se no site www.nerix.org
54
Apêndices
7.3. Apêndice 3 – Código-Fonte do Trabalho
Aqui disponibilizamos o código fonte sobre a licensa GPLv311 desenvolvido durante
o trabalho. Como dito anteriormente na metodologia, não desenvolvemos uma interface
melhor pelo fato de já existir o SSL-Vision com este propósito, aqui focamos mais no
algoritmo necessário de detecção e em alguns pontos importantes da calibração da câmera
mencionados no trabalho.
7.3.1. tcc.pro
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
QT
+= core gui
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
TARGET = tcc
TEMPLATE = app
SOURCES += main.cpp\
mainwindow.cpp \
Robo.cpp \
Bola.cpp \
Marcador.cpp \
Objeto.cpp
HEADERS += mainwindow.h \
Robo.h \
Bola.h \
Marcador.h \
Objeto.h \
Parametros.h
FORMS += mainwindow.ui
INCLUDEPATH += /usr/include/opencv
INCLUDEPATH += /usr/include/opencv2
LIBS += -L/usr/lib
LIBS += -lopencv_core
LIBS += -lopencv_imgproc
LIBS += -lopencv_highgui
LIBS += -lopencv_ml
LIBS += -lopencv_video
LIBS += -lopencv_features2d
LIBS += -lopencv_calib3d
LIBS += -lopencv_objdetect
LIBS += -lopencv_contrib
LIBS += -lopencv_legacy
LIBS += -lopencv_flann
7.3.2. main.cpp
11
Para saber mais sobre a licensa visite: www.gnu.org/licenses/gpl.html
55
Apêndices
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
#include "mainwindow.h"
#include <sstream>
#include <string>
#include <iostream>
#include <QApplication>
#include "Robo.h"
#include "Bola.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#define BILLION 1000000000L;
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
const bool MODO_CALIBRACAO_AREA = false;
cv::Point CALIBRACAO_PONTO1(77,33);//valores iniciais para o ponto 1
cv::Point CALIBRACAO_PONTO2(594,463);//valores iniciais para o ponto 2
const bool MODO_CALIBRACAO = false;
//valores iniciais dos filtros minimo e maximo HSV
//eles serao mudados usando as barras de rolagem
int H_MIN = 0;
int H_MAX = 180; //valor maximo para matiz que no opencv nao eh 360 graus
int S_MIN = 0;
int S_MAX = 255; //valor maximo para a saturaçao
int V_MIN = 0;
int V_MAX = 255; //valor maximo para o brilho
25.
26.
27.
47.
48.
49.
void funcaoCallBackMouse(int event, int x, int y, int flags, void* userdata){
if ( event == EVENT_LBUTTONDOWN ) {
cout << "Ponto1(" << CALIBRACAO_PONTO1.x << "," << CALIBRACAO_PONTO1.y
<< ") Ponto2(" << CALIBRACAO_PONTO2.x << "," << CALIBRACAO_PONTO2.y << ") ";
cout << "Botao esquerdo do mouse foi clicado - posicao (" << x << ", " << y << ")" << endl;
if (x >= CALIBRACAO_PONTO2.x || y >=
CALIBRACAO_PONTO2.y){
cout << "Reposicione o ponto 1!" << endl;
} else {
CALIBRACAO_PONTO1 = Point (x,y);
}
}else if ( event == EVENT_RBUTTONDOWN ) {
<<") Ponto2(" << CALIBRACAO_PONTO2.x << "," << CALIBRACAO_PONTO2.y << ") ";
cout << "Botao direito do mouse foi clicado - posicao (" << x << ", " << y << ")" << endl;
if (CALIBRACAO_PONTO1.x >= x || CALIBRACAO_PONTO1.y >= y){
cout << "reposicione o ponto 2!" << endl;
} else {
CALIBRACAO_PONTO2 = Point (x,y);
}
} else if ( event == EVENT_MBUTTONDOWN ) {
cout<<"Botao scroll do mouse foi clicado - posicao ("<<x <<", "<< y << ")" << endl;
} else if ( event == EVENT_MOUSEMOVE ) {
cout<<"Mouse se movimentando na janela - posicao ("<< x << ", "<< y<< ")"<< endl;
}
}
50.
51.
void on_trackbar( int , void * ){
//Esta funçao eh chamada nao importa
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
56
Apêndices
//se a posicao da barra de rolagem foi mudada
52.
53.
}
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
void criarBarras(){
//cria uma janela para as barras de rolagem
namedWindow(nomeJanelaBarras,0);
//cria memoria para armazenar os nomes das barras na janela
char TrackbarName[50];
sprintf( TrackbarName, "H_MIN", H_MIN);
sprintf( TrackbarName, "H_MAX", H_MAX);
sprintf( TrackbarName, "S_MIN", S_MIN);
sprintf( TrackbarName, "S_MAX", S_MAX);
sprintf( TrackbarName, "V_MIN", V_MIN);
sprintf( TrackbarName, "V_MAX", V_MAX);
//cria as barras e insere elas na janlea
//3 parametros: o endereco da variavel que esta mudando quando a barra eh
movida,
//o valor maximo que a barra pode mover,
//e a funcao que eh chamada onde nao importa se a barra eh movimentada
createTrackbar( "H_MIN", nomeJanelaBarras, &H_MIN, H_MAX, on_trackbar
);
createTrackbar( "H_MAX", nomeJanelaBarras, &H_MAX, H_MAX,
on_trackbar );
createTrackbar( "S_MIN", nomeJanelaBarras, &S_MIN, S_MAX, on_trackbar );
createTrackbar( "S_MAX", nomeJanelaBarras, &S_MAX, S_MAX, on_trackbar );
createTrackbar( "V_MIN", nomeJanelaBarras, &V_MIN, V_MAX, on_trackbar );
createTrackbar( "V_MAX", nomeJanelaBarras, &V_MAX, V_MAX, on_trackbar );
}
76.
77.
78.
79.
void desenhaPontosCalibracao(Mat &frame, Point ponto1, Point ponto2){
cv::circle(frame,ponto1,5, cv:: Scalar (0,0,255));
cv::circle(frame,ponto2,5, cv:: Scalar (255,0,0));
}
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
void operacoesMorfologicas(Mat &limiar){
//cria elementos estruturantes que serao usados para dilataçao e erosao da imagem.
//o elemento escolinho aqui eh um retangulo de 1px por 1px
Mat elementoErosao = getStructuringElement( MORPH_RECT,Size(1,1));
//dilata com um elemento de maior largura para deixar o objeto mais visivel
Mat elementoDilatacao = getStructuringElement(MORPH_RECT,Size(3,3));
erode(limiar,limiar,elementoErosao);
dilate(limiar,limiar,elementoDilatacao);
}
void rastrearObjetosFiltrados(Objeto objeto, Mat limiar, Mat &sementeCamera){
vector <Objeto> objetos;
Mat temp;
limiar.copyTo(temp);
//estes dois vetores sao necessarios para encontrar os contornos
vector < vector < Point > > contours;
vector <Vec4i> hierarchy;
//encontrar os contornos do imagem filtrada
findContours(temp, contours, hierarchy,CV_RETR_CCOMP,CV_CHAIN_APPROX_SIMPLE);
//usa o metodo dos momentos para encontrar o objeto filtrado
if (hierarchy.size() > 0) {
int numObjects = hierarchy.size();
//se o numero de objetos for maior que than NUM_MAX_OBJETOS entao eh porque tem
muito ruido no filtro selecionado
104.
if (numObjects<NUM_MAX_OBJETOS){
105.
for (int index = 0; index >= 0; index = hierarchy[index][0]) {
106.
Moments moment = moments((cv:: Mat)contours[index]);
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
57
Apêndices
double area = moment.m00;
//se a area é menor que 20 px por 20px entao provavelmente é apenas um
107.
108.
ruido
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
//se a area é a mesma que 3/2 do tamanho da imagem, provavelmente é
apenas um filtro mal escolhido
//nós apenas queremos o objeto com a maior área então nos comparamos a
area de cada objeto encontrado
//iteração e comparação da area
if (area>objeto.getAreaMinima()){
Objeto *obj;
if (objeto.getType()=="bola"){
obj = new Bola();
} else if (objeto.getType()=="marcador"){
obj = new Marcador();
} else {
obj = new Robo();
}
obj->setXPos(moment.m10/area);
obj->setYPos(moment.m01/area);
obj->setType(objeto.getType());
obj->setColour(objeto.getColour());
objetos.push_back(*obj);
if (!MODO_CALIBRACAO && objeto.getType()=="robo"){
obj->ident if icar(sementeCamera);
}
obj->desenhar(sementeCamera);
delete obj;
}
} //fim for
} else {
putText(sementeCamera,"Muito ruido!! Ajuste o filtro!", Point (0,50), 1, 2, Scalar
(0,0,255), 2);
}
}
143.
144.
145.
146.
147.
148.
149.
150.
151.
void detectarObjeto(Objeto obj, Mat sementeCamera){
Mat limiar;
Mat HSV;
cvtColor(sementeCamera,HSV,COLOR_BGR2HSV);
if (MODO_CALIBRACAO){
inRange(HSV, Scalar (H_MIN, S_MIN, V_MIN), Scalar (H_MAX, S_MAX, V_MAX),
limiar);
} else {
inRange(HSV,obj.getHSVmin(),obj.getHSVmax(),limiar);
}
operacoesMorfologicas(limiar);
rastrearObjetosFiltrados(obj,limiar,sementeCamera);
imshow(nomeJanela2,limiar);
}
}
152.
153.
154.
155.
156.
157.
158.
159.
int deteccaoHSV(IplImage *frame){
//Matriz para armazenar cada frame da camera
Mat sementeCamera(frame);
//cria as barras para os fltros HSV
criarBarras();
Marcador marcador;
detectarObjeto(marcador,sementeCamera);
137.
138.
139.
140.
141.
142.
58
Apêndices
} else {
Robo robo;
detectarObjeto(robo,sementeCamera);
Bola bola;
detectarObjeto(bola,sementeCamera);
}
return 0;
160.
161.
162.
163.
164.
165.
166.
167.
}
168.
double maiorTempo=0, menorTempo=10000, media=0, contador=0, soma = 0;
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
void medeTempoFuncaoDeteccaoHSV(IplImage *frame){
struct timespec start, stop;
double accum;
if ( clock_gettime( CLOCK_REALTIME, &start) == -1 ) {
perror( "clock gettime" );
}
//system( argv[1] );
deteccaoHSV(frame);
if ( clock_gettime( CLOCK_REALTIME, &stop) == -1 ) {
perror( "clock gettime" );
}
accum = ( stop.tv_sec - start.tv_sec )+ (double)( stop.tv_nsec - start.tv_nsec ) /
(double)BILLION;
contador++;
soma += accum;
menorTempo = accum < menorTempo ? accum : menorTempo;
maiorTempo = accum > maiorTempo ? accum : maiorTempo;
media = soma/contador;
cout << contador<<" - "<<accum <<" - maior: "<< maiorTempo<<" - menor: "<<
menorTempo<<" - media: "<<media<<endl;
}
181.
182.
183.
184.
185.
186.
187.
188.
int main(int argc, char *argv[]){
IplImage *frame = 0;
CvCapture *capture = 0;
int key = 0;
// inicializa a camera
capture = cvCaptureFromCAM( 1 );
// Tenta setar a resoluço da camera para 800 x 600.
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 800);
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 600);
// cria uma janela para o video
cvNamedWindow( "Resultado", CV_WINDOW_AUTOSIZE );
while ( key != 'q' ) {
// pega o frame
frame = cvQueryFrame( capture );
// sempre verifica se existe um frame
if ( !frame ) break;
int largura = CALIBRACAO_PONTO2.x - CALIBRACAO_PONTO1.x;
int altura = CALIBRACAO_PONTO2.y - CALIBRACAO_PONTO1.y;
if (MODO_CALIBRACAO_AREA){
do{
//atribui a chamada de funçao para tratar os eventos do mouse
setMouseCallback("Resultado", funcaoCallBackMouse, NULL);
Mat tmp(frame); //desenhar o ponto 1 e 2 neste frame temporario
desenhaPontosCalibracao(tmp, CALIBRACAO_PONTO1,
CALIBRACAO_PONTO2);
213.
}while(CALIBRACAO_PONTO1.x >= CALIBRACAO_PONTO2.x ||
CALIBRACAO_PONTO1.y >= CALIBRACAO_PONTO2.y);
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
59
Apêndices
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.
235.
236.
237.
/* seta a regiao de interesse (ROI) da imagem*/
cvSetImageROI(frame, cvRect(CALIBRACAO_PONTO1.x,
CALIBRACAO_PONTO1.y, largura, altura));
//inverte a regiao de interesse para ficar mais facil de ver a regiao
selecionada
cvNot(frame,frame);
} else {
/* seta a regiao de interesse (ROI) da imagem*/
cvSetImageROI(frame, cvRect(CALIBRACAO_PONTO1.x,
CALIBRACAO_PONTO1.y,
largura, altura));
medeTempoFuncaoDeteccaoHSV(frame);
}
IplImage *img2 = cvCreateImage(cvGetSize(frame),
frame->depth,
frame-> nChannels);
// copia a sub imagem
cvCopy(frame, img2, NULL);
// sempre reseta a region de interesse
cvResetImageROI(frame);
// mostra o frame atual
cvShowImage( "Resultado", frame );
// sai se o usuario digitar ‘q’
key = cvWaitKey( 1 );
cvReleaseImage(&img2);
}
return 0;
}
7.3.3. mainwindow.ui
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralWidget"/>
<widget class="QMenuBar" name="menuBar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>25</height>
</rect>
</property>
</widget>
<widget class="QToolBar" name="mainToolBar">
60
Apêndices
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
<attribute name="toolBarArea">
<enum>TopToolBarArea</enum>
</attribute>
<attribute name="toolBarBreak">
<bool>false</bool>
</attribute>
</widget>
<widget class="QStatusBar" name="statusBar"/>
</widget>
<layoutdefault spacing="6" margin="11"/>
<resources/>
<connections/>
</ui>
7.3.4. mainwindow.h
1.
2.
3.
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H
7.3.5. mainwindow.cpp
1.
2.
#include "mainwindow.h"
#include "ui_mainwindow.h"
3.
4.
5.
MainWindow::MainWindow(QWidget *parent) :QMainWindow(parent), ui(new Ui::MainWindow){
ui->setupUi(this);
}
6.
7.
8.
MainWindow::~MainWindow(){
delete ui;
}
7.3.6. Objeto.h
61
Apêndices
1.
2.
3.
4.
5.
6.
#pragma once
#include <string>
#include "opencv2/core/core.hpp"
#include "opencv/cv.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "Parametros.h"
7.
8.
using namespace std;
using namespace cv;
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
class Objeto{
public:
Objeto();
~Objeto(void);
int getXPos();
void setXPos(int x);
int getYPos();
void setYPos(int y);
int getAreaMinima();
void setAreaMinima(int area);
Scalar getHSVmin();
Scalar getHSVmax();
void setHSVmin(Scalar min);
void setHSVmax(Scalar max);
string getType();
void setType(string t);
void setTipo(int t); //apenas robos
Scalar getColour();
void setColour(Scalar c);
virtual void desenhar(Mat &frame);
virtual int identificar(Mat &frameMat);
string intToString(int number);
private:
int xPos, yPos, areaMinima;
string type;
Scalar HSVmin, HSVmax;
Scalar Colour;
};
7.3.7. Objeto.cpp
1.
#include "Objeto.h"
2.
3.
4.
5.
6.
7.
Objeto::Objeto(){
setType("Objeto");
setHSVmin(Scalar (17,85,109));
setHSVmax(Scalar (29,255,255));
setColour(Scalar (0,0,0)); //preto
}
8.
9.
Objeto::~Objeto(void){
}
10.
11.
12.
int Objeto::getXPos(){
return Objeto::xPos;
}
62
Apêndices
13.
14.
15.
void Objeto::setXPos(int x){
Objeto::xPos = x;
}
16.
17.
18.
int Objeto::getYPos(){
return Objeto::yPos;
}
19.
20.
21.
void Objeto::setYPos(int y){
Objeto::yPos = y;
}
22.
23.
24.
Scalar Objeto::getHSVmin(){
return Objeto::HSVmin;
}
25.
26.
27.
Scalar Objeto::getHSVmax(){
return Objeto::HSVmax;
}
28.
29.
30.
void Objeto::setHSVmin(Scalar min){
Objeto::HSVmin = min;
}
31.
32.
33.
void Objeto::setHSVmax(Scalar max){
Objeto::HSVmax = max;
}
34.
35.
36.
string Objeto::getType(){
return type;
}
37.
38.
39.
void Objeto::setType(string t){
type = t;
}
40.
41.
void Objeto::setTipo(int t){
}
42.
43.
44.
Scalar Objeto::getColour(){
return Colour;
}
45.
46.
47.
void Objeto::setColour(Scalar c){
Colour = c;
}
48.
49.
50.
int Objeto::getAreaMinima(){
return areaMinima;
}
51.
52.
53.
void Objeto::setAreaMinima(int area){
areaMinima = area;
}
void Objeto::desenhar(Mat &frame){
cv::circle(frame, cv:: Point (getXPos(),getYPos()),RAIO_ROBO, cv:: Scalar (0,0,255));
cv::putText(frame,intToString(getXPos())+ "," + intToString(getYPos()),cv:: Point (getXPos()20,getYPos()+50),1,0.8, Scalar (0,255,0));
57.
cv::putText(frame,getType(),cv:: Point (getXPos()-17,getYPos()-45),1,1,getColour());
54.
55.
56.
63
Apêndices
58.
}
59.
60.
61.
62.
63.
string Objeto::intToString(int number){
std:: stringstream ss;
ss << number;
return ss.str();
}
64.
65.
66.
int Objeto::identificar(Mat &frameMat){
return 5; //nao eh nada
}
7.3.8. Bola.h
1.
2.
3.
#pragma once
#include <string>
#include "Objeto.h"
4.
5.
6.
7.
8.
9.
10.
class Bola: public Objeto{
public:
Bola();
~Bola(void);
void desenhar(Mat &frame);
private:
};
7.3.9. Bola.cpp
1.
#include "Bola.h"
2.
3.
4.
5.
6.
7.
8.
Bola::Bola(){
setType("bola");
setColour(Scalar (0,0,255));
setAreaMinima(AREA_MIN_OBJETO_BOLA);
}
9.
10.
Bola::~Bola(void){
}
void Bola::desenhar(Mat &frame){
cv::circle(frame, cv:: Point (getXPos(),getYPos()),RAIO_BOLA, cv:: Scalar (0,0,255));
14.
15. }
11.
12.
13.
7.3.10. Marcador.h
64
Apêndices
1.
2.
3.
#pragma once
#include <string>
#include "Objeto.h"
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
class Marcador: public Objeto{
public:
Marcador();
~Marcador(void);
void setCor(int cor);
int getCor();
private:
int cor;
};
7.3.11. Marcador.cpp
1.
#include "Marcador.h"
2.
3.
4.
5.
6.
7.
8.
Marcador::Marcador()
setType("marcador");
setColour(Scalar (255,255,255)); //branco
setAreaMinima(AREA_MIN_OBJETO_MARCADOR);
}
9.
10.
Marcador::~Marcador(void){
}
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
void Marcador::setCor(int color){
cor = color;
switch (color) {
case COR_VERMELHO:
break;
case COR_VERDE:
break;
case COR_AMARELO:
break;
case COR_AZUL:
break;
case COR_ROXO:
break;
case COR_BRANCO:
break;
65
Apêndices
case COR_PRETO:
break;
case COR_LARANJA:
break;
default:
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
}
51.
52.
53.
int Marcador::getCor(){
return cor;
}
}
void Marcador::desenhar(Mat &frame){
cv::circle(frame, cv:: Point (getXPos(),getYPos()),RAIO_MARCADOR, cv:: Scalar (0,0,255));
57. }
54.
55.
56.
7.3.12. Robo.h
1.
2.
3.
#pragma once
#include <string>
#include "Marcador.h"
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
class Robo: public Objeto{
public:
Robo();
~Robo(void);
Robo(string name);
Marcador getMarcadorRodas();
void setMarcadorRodas(Marcador rodas);
Marcador getMarcadorFrente();
void setMarcadorFrente(Marcador frente);
Marcador getMarcadorAtras();
void setMarcadorAtras(Marcador atras);
Marcador getMarcadorEquipe();
void setMarcadorEquipe(Marcador equipe);
void setTipo(int t);
int identificar(Mat &frame);
void identificarEquipe1(Mat &frameMat);
void identificarEquipe2(Mat &frameMat);
private:
Marcador marcadorEquipe;
Marcador marcadorRodas;
Marcador marcadorFrente;
Marcador marcadorAtras;
};
66
Apêndices
7.3.13. Robo.cpp
1.
#include "Robo.h"
2.
3.
4.
5.
6.
7.
8.
Robo::Robo(){
setType("robo");
setColour(Scalar (0,0,0));
setAreaMinima(AREA_MIN_OBJETO_ROBO);
}
9.
10.
Robo::~Robo(void){
}
11.
12.
13.
Marcador Robo::getMarcadorRodas(){
return marcadorRodas;
}
14.
15.
16.
void Robo::setMarcadorRodas(Marcador rodas){
marcadorRodas = rodas;
}
17.
18.
19.
Marcador Robo::getMarcadorFrente(){
return marcadorFrente;
}
20.
21.
22.
void Robo::setMarcadorFrente(Marcador frente){
marcadorFrente = frente;
}
23.
24.
25.
Marcador Robo::getMarcadorAtras(){
return marcadorAtras;
}
26.
27.
28.
void Robo::setMarcadorAtras(Marcador atras){
marcadorAtras = atras;
}
29.
30.
31.
Marcador Robo::getMarcadorEquipe(){
return marcadorEquipe;
}
32.
33.
34.
void Robo::setMarcadorEquipe(Marcador equipe){
marcadorEquipe = equipe;
}
void Robo::desenhar(Mat &frame){
cv::circle(frame, cv:: Point (getXPos(),getYPos()),RAIO_ROBO, cv:: Scalar (0,0,255));
38.
39. }
35.
36.
37.
bool estaPertoDe(int numero, int numeroAproximado, int erro){
int modulo = (numero - numeroAproximado) < 0 ? (numeroAproximado-numero) : (numero numeroAproximado);
42.
return modulo <= erro ? true : false;
43. }
40.
41.
67
Apêndices
44.
45.
46.
47.
int Robo::identificar(Mat &frameMat){
identificarEquipe1(frameMat);
identificarEquipe2(frameMat);
}
48.
49.
50.
51.
void Robo::identificarEquipe1(Mat &frameMat){
IplImage frame = frameMat;
try{
cvSetImageROI(&frame, cvRect(getXPos()-RAIO_ROBO, getYPos()-RAIO_ROBO,
2*RAIO_ROBO, 2*RAIO_ROBO));
}catch(Exception e){
cout << "uopa deu excecao :( na hora que fez o cvSetImageROI do Robo." << endl;
}
//achar os marcadores
Mat semente(&frame);
Mat limiar;
Mat HSV;
cvtColor(semente,HSV, COLOR_BGR2HSV);
Marcador obj;
int qtdMarcadoresEncontrados;
int centroMarcadorEquipePosX, centroMarcadorEquipePosY;
for(int i=0; i<QTD_TIPOS_ROBO; i++){
qtdMarcadoresEncontrados = 0;
centroMarcadorEquipePosX = 0;
centroMarcadorEquipePosY = 0;
for (int j=0; j<4; j++){
obj.setCor(TIPO_ROBO[i][j]);
Mat elementoErosao = getStructuringElement(MORPH_RECT,Size(1,1));
Mat temp;
//estes dois vetores são necessarios para mostrar os contornos
vector < Vec4i > hierarchy;
findContours(temp,contours,hierarchy, CV_RETR_CCOMP,
CV_CHAIN_APPROX_SIMPLE);
//usa o método dos momentos para encontrar o objeto selecionado
if (area>obj.getAreaMinima()){
Marcador m;
m.setXPos(moment.m10/area + getXPos()-RAIO_ROBO);
m.setYPos(moment.m01/area + getYPos()-RAIO_ROBO);
m.setCor(TIPO_ROBO[i][j]);
switch (j) {
case 0:
setMarcadorEquipe(m);
centroMarcadorEquipePosX = moment.m10/area;
centroMarcadorEquipePosY = moment.m01/area;
printDebug("setei o marcador da equipe 1");
break;
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
68
Apêndices
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
case 1:
setMarcadorFrente(m);
printDebug("setei o marcador da fente");
break;
case 2:
setMarcadorAtras(m);
printDebug("setei o marcador de tras");
break;
default:
setMarcadorRodas(m);
printDebug("setei o marcador das rodas");
break;
}
qtdMarcadoresEncontrados++;
}
} //fim for
}
} //fim for j
if (qtdMarcadoresEncontrados==5 ){
if (estaPertoDe(centroMarcadorEquipePosX,RAIO_ROBO,3) &&
estaPertoDe(centroMarcadorEquipePosY,RAIO_ROBO,3))
setTipo(i);
//tipo = i; //recebe o indice da linha da matriz de tipos de robos que sera seu tipo.
break;
} else {
if (qtdMarcadoresEncontrados>0){
printDebug("encontrei " + intToString(qtdMarcadoresEncontrados) +"
marcadores!");
}
}
}//fim for i dos marcadores
}
void Robo::identificarEquipe2(Mat &frameMat){
IplImage frame = frameMat;
try{
cvSetImageROI(&frame, cvRect(getXPos()-RAIO_ROBO, getYPos()-RAIO_ROBO,
2*RAIO_ROBO, 2*RAIO_ROBO));
}catch(Exception e){
cout << "uopa deu excecao :( na hora que fez o cvSetImageROI do Robo." << endl;
}
//achar os marcadores
Mat semente(&frame);
Mat limiar;
Mat HSV;
cvtColor(semente,HSV, COLOR_BGR2HSV);
Marcador obj;
int qtdMarcadoresEncontrados;
int centroMarcadorEquipePosX, centroMarcadorEquipePosY;
for(int i=0; i<QTD_TIPOS_ROBO; i++){
qtdMarcadoresEncontrados = 0;
centroMarcadorEquipePosX = 0;
centroMarcadorEquipePosY = 0;
for (int j=0; j<4; j++){
obj.setCor(TIPO_ROBO2[i][j]);
Mat elementoErosao = getStructuringElement(MORPH_RECT,Size(1,1));
69
Apêndices
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
Mat temp;
//estes dois vetores são necessarios para mostrar os contornos
vector < Vec4i > hierarchy;
findContours(temp,contours,hierarchy, CV_RETR_CCOMP,
CV_CHAIN_APPROX_SIMPLE);
//usa o método dos momentos para encontrar o objeto selecionado
if (area>obj.getAreaMinima()){
Marcador m;
m.setXPos(moment.m10/area + getXPos()-RAIO_ROBO);
m.setYPos(moment.m01/area + getYPos()-RAIO_ROBO);
m.setCor(TIPO_ROB2O[i][j]);
switch (j) {
case 0:
setMarcadorEquipe(m);
centroMarcadorEquipePosX = moment.m10/area;
centroMarcadorEquipePosY = moment.m01/area;
printDebug("setei o marcador da equipe 2");
break;
case 1:
setMarcadorFrente(m);
printDebug("setei o marcador da fente");
break;
case 2:
setMarcadorAtras(m);
printDebug("setei o marcador de tras");
break;
default:
setMarcadorRodas(m);
printDebug("setei o marcador das rodas");
break;
}
qtdMarcadoresEncontrados++;
}
} //fim for
}
} //fim for j
if (qtdMarcadoresEncontrados==5 ){
if (estaPertoDe(centroMarcadorEquipePosX,RAIO_ROBO,3) &&
estaPertoDe(centroMarcadorEquipePosY,RAIO_ROBO,3))
setTipo(i);
//tipo = i; //recebe o indice da linha da matriz de tipos de robos que sera seu tipo.
break;
} else {
if (qtdMarcadoresEncontrados>0){
printDebug("encontrei " + intToString(qtdMarcadoresEncontrados) +"
marcadores!");
}
}
}//fim for i dos marcadores
}
70
Apêndices
212.
213.
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.
235.
236.
237.
238.
239.
240.
241.
242.
243.
void Robo::setTipo(int t){
switch (t) {
case 0:
printDebug("setei o atacante 1");
setType("atacante 1");
break;
case 1:
printDebug("setei o zagueiro 1");
setType("zagueiro 1");
break;
case 2:
printDebug("setei o goleiro 1");
setType("goleiro 1");
break;
case 3:
printDebug("setei o atacante 2");
setType("atacante 2");
break;
case 4:
printDebug("setei o zagueiro 2");
setType("zagueiro 2");
break;
case 5:
printDebug("setei o goleiro 2");
setType("goleiro 2");
break;
default:
setType("robo");
printDebug("tipo robo:"+getType());
break;
}
}
71
Apêndices
7.4. Apêndice 4 – BUG: uvcvideo
Este apêndice é para relatar um bug que ocorreu na máquina virtual onde foi feito
este trabalho e que tem relação com um módulo de kernel com defeito. Esse módulo faz a
câmera embutida do pc funcionar por alguns segundos e depois parar com uma falha. O
exemplo foi o que pegava o stream de vídeo da câmera e deixava em tons de cinza. A
mensagem que é mostrada no console do Eclipse quando dava o problema é a seguinte:
VIDIOC_QUERYMENU: Invalid argument
Procuramos sobre sobre o problema e achamos neste link12. Então verificamos o log
do que estava acontecendo por baixo do sistema operacional com o comando DMESG e
encontramos essa linha:
[ 1969.839495] uvcvideo: Failed to resubmit video URB (-27).
Fomos procurar o que significava este erro e encontramos este link13 do bugzilla, e
descobrimos que poderia ser um erro do drive da câmera do notebook com a versão recente
do kernel, ocasionando alguma incompatibilidade. Também encontramos neste link14: no
qual reforça a idéia de probelma de kernel ou por causa de mal escalonamento de tarefas do
S.O. na VM logo após suspender a mesma. Então, procuramos informações sobre o
dispositivo com os comandos MODINFO e achamos essas informações:
modinfo uvcvideo
filename: /lib/modules/3.0.0-16-generic/kernel/drivers/media/video/uvc/uvcvideo.ko
version: v1.1.0
license: GPL
description: USB Video Class driver
author: Laurent Pinchart
srcversion: 7D96DC0E97E200AFF41D401
alias: usb:v*p*d*dc*dsc*dp*ic0Eisc01ip00*
alias: usb:v0458p706Ed*dc*dsc*dp*ic0Eisc01ip00*
depends: videodev
vermagic: 3.0.0-16-generic SMP mod_unload modversions 686
parm: clock:Video buffers timestamp clock
parm: nodrop:Don't drop incomplete frames (uint)
parm: quirks:Forced device quirks (uint)
parm: trace:Trace level bitmask (uint)
parm: timeout:Streaming control requests timeout (uint)
12
Instalação no Windows - http://www.ozbotz.org/opencv-install-troubleshooting/
Red Hat BugZilla - https://bugzilla.redhat.com/show_bug.cgi?id=746914
14
Bug#617976 - https://lists.debian.org/debian-kernel/2011/03/msg00426.html
13
72
Apêndices
Continuamos coletando informações sobre o dispositivos, agora com o comando
LSUSB e conseguimos estes dados:
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 002: ID 090c:c371 Feiya Technology Corp.
Bus 002 Device 002: ID 0e0f:0003 VMware, Inc. Virtual Mouse
Bus 002 Device 003: ID 0e0f:0002 VMware, Inc. Virtual USB Hub
Bus 002 Device 004: ID 0e0f:0008 VMware, Inc.
Finalmente, descobrimos o identificador da câmera do notebook que é o dispositivo
da Feiya Technology Corp com o ID 090c:c371, então procuramos dirves para este
dispositivo neste link15, onde o drive do dispositivo mais próximo encontrado foi para o
dispositivo 090c:b371. Testamos novamente o mesmo código com outra câmera com um
drive apropriado para o kernel em uso na máquina virtual que funcionou normalmente sem
dar nenhum tipo de problema.
O código executado anteriormente funcionava bem porque a câmera original que foi
testada é mas antiga e, consequentemente, possui um suporte mais estável no kernel. O código
na VM não funcionou por causa do hardware diferente. Como solução propomos colocar uma
versão mais antiga do kernel para ver se a câmera do notebook não dá o mesmo problema. Se
continuar o erro, seria bom testar na máquina hospedeira o código ou então uma outra opção
mais eficaz seria a recompilação do kernel mais atual com outros módulos de vídeo.
15
Linux UVC Driver Tool - http://www.ideasonboard.org/uvc/#devices
73
Anexos
8. Anexos
8.1. Sistema De Visão Humana
Segundo (IBRO, 2014), (ZEISS, 2014) e (LEFEO, 2014), o olho é o órgão sensorial
baseado na sensibilidade à luz e é fotossensível. Os órgãos fotorreceptores de todos os seres
vivos se caracterizam por possuírem um ou mais pigmentos fotossensíveis, ou foto-excitáveis,
associados a receptores de membrana. O pigmento responsável pela visão das cores é a
rodopsina, presente em todos os animais que vem as cores, entre eles os o ser humano e todos
os outros primatas.
Nos seres humanos os olhos estão localizados na porção anterior do corpo, a cabeça,
dentro da órbita. A órbita ocular é um compartimento ósseo formado por vários ossos do
crânio, e protege o olho.
Basicamente todo olho possui uma câmara escura, uma camada de células
fotorreceptoras, um sistema de lentes para focalizar a luz que forma a imagem e um sistema
de células nervosas para conduzir os estímulos ao córtex cerebral.
O ser humano possui um olho com três camadas ou túnicas dispostas
concentricamente . A camada externa, formada pela esclera ou esclerótica e pela córnea, a
camada média ou túnica vascular, constituída pela coróide e pela íris e a terceira camada ou a
túnica nervosa, a retina, que se comunica com o cérebro pelo nervo óptico.
Há também a lente ou cristalino, que é uma estrutura biconvexa transparente. Frente
ao cristalino está uma expansão pigmentada e opaca da camada média e o recobre em parte
que é chamada de íris. (IBRO, 2014)
74
Anexos
Figura 33 - Vista em corte do olho humano (Médico de Olhos, 2011)
O interior do olho pode ser dividido em três câmaras: a anterior, que é delimitada
pela íris e a córnea; a câmara posterior, localizada entre a íris e o cristalino; e o espaço vítreo,
situado atrás do cristalino e circundado pela retina. As duas primeiras câmaras são
preenchidas por um líquido que contêm proteínas, é o humor aquoso. (LEFEO, 2014)
O espaço vítreo está cheio do humor ou corpo vítreo, aquoso e gelatinoso. Em várias
regiões do olho são encontradas células pigmentares com melanina, são os melanócitos, que
impedem a entrada absorvendo a luz estranha que pode prejudicar o processo de formação da
imagem. Entre os vertebrados os tipos de células fotorreceptoras são estruturalmente muito
parecidos.
Figura 34 - Como a imagem chega ao cérebro (IBRO, 2014)
75
Anexos
Os cones são as células responsáveis pela visão das cores e, os bastonetes,
respondem pela visão preto e branco. Todos os primatas, inclusive o homem, além de
possuírem visão colorida têm visão tridimensional, em profundidade. A visão tridimensional
acontece porque ha sobreposição, no córtex visual, das informações que chegam dos campos
visuais dos dois olhos simultaneamente.
Nossos olhos estão localizados na frente do rosto, diferente dos cachorros ou cavalos
que têm os olhos posicionados lateralmente na face. Este posicionamento dos olhos permite a
visão do mesmo objeto, ao mesmo tempo, desde dois ângulos ligeiramente diferentes. O
cérebro compara estas duas imagens simultâneas e cria a noção de profundidade.
De uma forma simples e resumida, o funcionamento do olho começa quando a luz
entra no olho e é focada, pela córnea e pela lente, sobre a retina que se localiza na outra
extremidade do globo ocular. Antes de atingir a lente a luz passa pela pupila, que é o espaço
aberto no centro da íris (estrutura que contém pigmento).
A íris, funcionando como um diafragma, pode expandir ou contrair e assim provocar
abertura ou fecho da pupila, dependendo de haver pouca ou muita luz. É normal que se
compare o olho a uma câmara responsável pela captação da imagem do mundo envolvente.
Figura 35 - Abertura e fechamento da córnea (Dr. Rui Costa, 2013)
Uma vez focada a imagem na retina, os 125 milhões de fotorreceptores distribuídos
ao longo da superfície da retina respondem à luz que lhes chega, gerando pequeníssimos
potenciais de ação. Estes sinais passam, através de sinapses, por uma rede complexa de
76
Anexos
células presentes na retina.
Os sinais das diferentes células convergem sobre as células ganglionares da retina de
onde partem os axónios, que em conjunto formam o nervo óptico como mostrado na Figura
35. Desta maneira, os sinais são enviados ao cérebro, no qual geram potenciais de ação que
são distribuídos para diferentes regiões visuais com funções distintas.
77

Reconhecimento de Objetos em Tempo Real Utilizando

Transcrição

Documentos relacionados

Projeto da EESC é premiado em simpósio da Pró

Período: 7º Disciplina: Robótica Industrial Carga Horária Semestral

Entrevista com China

Baixar este arquivo PDF - Revista de Sociologia da UFSCar

JOY-NINA: robôs para desafio de dança da RoboCup Junior.

Clique aqui e baixe o pdf com mídia kit

Aula Tipos de Robôs

Carta de solicitação de emprestimo

Robótica na agricultura Robotics in agriculture Robotique dans l

truly flexible