Realidade Aumentada
Daniel Ribeiro Trindade
___________________________________________________________________________________________________
Trabalho 1 - Detecção de cantos
Objetivo
Criar um programa para detecção de cantos em imagens em video utilizando o detector de cantos de Harris [1].
Como foi feito
O programa foi feito em C e foram utilizadas as seguintes bibliotecas:
- OpenCv [2]
- Opengl [3]
Figura 1
Código e executável
Código
Executável
___________________________________________________________________________________________________
Trabalho 2 - Calibração de Câmera
Objetivo
Calibrar uma câmera a partir de um video de um tabuleiro de xadrez e desenhar um objeto tridimensional que seja coerente com a cena.
Como foi feito
O programa foi feito em C e foram utilizadas as seguintes bibliotecas:
- OpenCv
- Opengl
A calibração da câmera foi feita baseada no método de Tsai [4]. A implementação utilizada pode ser encontrada em [5].
Figura 2
Código e executável
Código
Executável
___________________________________________________________________________________________________
Trabalho 3 - Jogo de Damas em Realidade Aumentada
Objetivo
Criar um jogo de damas que possibilte o embate entre computador e ser humano, e que faça uso de realidade aumentada. O programa deve ser capaz de reconhecer um tabuleiro de damas 8 x 8, assim como os movimentos das peças que estão localizadas sobre ele. A partir dessas informações, o computador também tem de realizar uma jogada contra o oponente real.
Funcionamento do Jogo
Primeiramente, há uma etapa onde é preciso ajustar a função de detecção para que ela possa encontrar o tabuleiro de damas corretamente. Para isso, o usuário deve apertar a tecla 'z' até que uma borda de cor vermelha apareça em volta do tabuleiro, como mostra a figura 3. Essa etapa é necessária devido a variações de luz no ambiente.
Figura 3
Depois que a borda aparece, o jogo já pode começar. Quando o usuário aperta a tecla 'c', o jogo começa. Nesse ponto o programa reconhece as peças e monta um tabuleiro virtual.
Importante:
- As peças devem ser vermelhas e azuis.
- As peças azuis representam o jogador real. As vermelhas representam o computador.
- As peças vermelhas devem estar dispostas inicialmente no lado do tabuleiro mais próximo do circulo preto, e as azuis no lado oposto, como mostra a figura 1.
Quem joga primeiro é sempre o jogador real. Sempre que for a vez desse, o programa vai pedir que seja feita uma jogada no tabuleiro real. O jogador então aperta a tecla 'f' indicando que a jogada foi finalizada. A figura 3 ilustra esse momento.
Figura 3
Quando o jogador aperta a tecla 'f', o programa detecta a nova configuração do tabuleiro real e atualiza o tabuleiro virtual. Logo em seguida, o computador realiza uma jogada. Isso é feito através de uma engine para jogo de damas. Essa engine recebe o tabuleiro virtual e o retorna já atualizado com a jogada do computador. A configuração final do tabuleiro é impressa na tela e o programa pede que o jogador atualize o tabuleiro real ( figura 4 ).
Figura 4
Ao apertar a tecla 'f', a vez volta a ser do jogador e o programa volta a esperar por uma jogada.
No processo descrito acima, a detecção do tabuleiro e das peças só é feita em dois momentos:
1. Na finalização da etapa inicial, quando é necessário montar a configuração inicial do tabuleiro.
2. Toda vez que o usuário terminar uma movimentação de peças e apertar a tecla 'f'.
Ainda, toda vez que é feita uma detecção, conta-se a quantidade de peças azuis e vermelhas existentes no tabuleiro. Isso possibilita que o programa verifique se já há ganhador.
Como foi feito
O desenvolvimento do programa foi feito em C e foram usadas as seguintes bibliotecas:
- ArToolkit [6] -> kit de desenvolvimento de software para Realidade Aumentada.
- Simplech [7] -> Engine de jogo de damas.
- Opengl
O programa consiste nos seguintes passos:
Passo 1: Detecção do tabuleiro
A detecção do tabuleiro é feita através da função arDetectMarker ( ArToolkit ). Essa função é capaz de detectar regiões retangulares na imagem. No caso do tabuleiro de damas, foi posta uma moldura em volta do tabuleiro para melhorar o processo de detecção.
Importante: arDetectMarker detecta não só a moldura do tabuleiro, como também pode detectar alguns dos quadrados menores contidos no próprio tabuleiro. Para evitar que um desses últimos seja usado no processo de calibração, usa-se sempre o retângulo que tem maior área.
Figura 5
Passo 2: Calibração de câmera
A calibração de câmera usando a função arGetTransMat ( ArToolkit ). Essa função recebe o retângulo detectado no passo 1 e retorna a matriz de Modelview. A origem do sistema de coordenadas do sistema 3D resultante é no centro do tabuleiro.
Passo 3: Estabilidade do sistema de coordenadas
O sistema de coordenadas resultante do passo 2 não é estável e pode mudar a direção dos eixos X e Y em relação à imagem. Para evitar que isso aconteça, o sistema de coordenadas é estabecido com base no circulo externo ao tabuleiro. Isso é feito da seguinte forma:
- Faça uma amostragem em uma região qualquer da moldura do tabuleiro, tal que essa região tenha área menor do que a do circulo. Essa amostragem consiste na média das componentes RGB de um conjunto de pixels.
- Faça quatro amostragens, uma em cada lado do tabuleiro, no local onde o circulo deveria estar.
- Compare essas quatro amostragens com a primeira. A que mais se aproximar com a primeira, fornece a posição do circulo.
- Com base na posição do circulo em relação ao sistema de coordenadas estabelecido no passo 2, transforme o sistema de coordenadas para que ele sempre fique com uma orientação fixa em relação ao circulo.
O resultado final pode ser visto na figura 6.
Figura 6
Passo 4: Pré-detecção das peças
A detecção de uma peça no tabuleiro é feita de forma parecida com o processo descrito no passo 3. Faz-se uma amostragem de pixels em uma região do tabuleiro onde há possibilidade de uma peça estar, por exemplo, nos quadrados pretos do tabuleiro. Essa amostragem resulta em uma tupla RGB. Para saber se a posição amostrada contém uma peça branca, azul ou não contem uma peça, é preciso comparar o resultado dessa amostragem com valores RGB referentes a peças vermelhas, azuis ou quadrados sem peças.
O objetivo desse passo é achar esses valores de referência. Para isso, observe que, de posse do sistema de coordenadas estabelecido no passo 3, é possível determinar as posições do tabuleiro com certa precisão, como mostra a figura 7:
Figura 7
Assumindo que no ínicio todas as peças estão em seus lugares corretos, é possível estabelecer os valores RGB de referência da seguinte forma:
- Para cada posição que deveria conter uma peça de determinada cor, faça uma amostragem de pixels.
- Tire a média dessas amostragens. O resultado é o valor RGB de referência para aquele tipo de peça.
Isso é feito não somente para as posições que podem conter peças vermelhas ou azuis, mas também para posições que não contêm nenhuma peça. Dessa forma, ao final existem três valores RGB de referência: um para posições que contém peças vermelhas, um para azuis e um para as que não contém nenhuma peça.
Passo 5: Detecção de peças e construção do tabuleiro virtual
Esse passo consiste em detectar em um dado momento que posições do tabuleiro estão ocupadas e que tipo de peças as estão ocupando. Uma vez que foram determinados os valores RGB de referência para posições com peças vermelhas, azuis ou sem peças, para verificar se uma dada posição do tabuleiro contém ou não uma peça de uma determinada cor, basta realizar uma amostragem de pixels na posição. Através da comparação do resultado dessa amostragem com cada um dos valores de referência é possível determinar o estado em que se encontra a posição. Uma vez feito isso, a construção do tabuleiro virtual é trivial.
Passo 6: Realização de uma jogada por parte do computador
O último passo possibilita que o computador faça uma jogada baseada no estado atual do tabuleiro. Isso é relativamente fácil, uma vez que já existem engines de damas prontas que podem fazer a jogada. A função que realiza uma jogada para o computador é getmove ( Simplech ). Ela recebe o tabuleiro atual e retorna o tabuleiro modificado pela realização de uma jogada automática.
Código e executável
Código
Executável
___________________________________________________________________________________________________
Referências
[1] Chris Harris and Mike Stephens, Proceedings of The Fourth Alvey Vision Conference, Manchester, pp 147-151. 1988
[2] OpenCV, Open Source Computer Vision Library, http://sourceforge.net/projects/opencvlibrary/
[3] OpenGL, www.opengl.org
[4] Roger Y Tsai, A Versatile Camera Calibration Techniaue for High-Accuracy 3D Machine Vision Metrology Using Off-the-shelf TV Cameras and Lenses, IEEE JOURNAL OF ROBOTICS AND AUTOMATION, VOL. RA-3, NO. 4, AUGUST 1987
[5] http://www.tecgraf.puc-rio.br/~mgattass/ra/software/tsai.zip
[6] ARToolKit , http://www.hitl.washington.edu/artoolkit/
[7] http://www.fierz.ch/engines.php