Sie sind auf Seite 1von 26

Universidade da Beira Interior

Departamento de Informtica

Inteligncia Artificial - 2016: Pratical Project


Elaborado por:
Miguel Pereira - 34323
Srgio Santos - 34717

Orientador:
Professor Doutor Lus Alexandre

6 de Dexembro de 2017

Contedo
Contedo

Lista de Figuras

.
.
.
.

1
1
1
1
1

Tecnologias e Ferramentas Utilizadas


2.1 Introduo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.1 ROV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.2 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3
3
3
3

Raciocnio do Agente
3.1 Introduo . . . . .
3.2 Estruturas de Dados
3.3 Algoritmos . . . .
3.4 Dificuldades . . . .
3.5 Concluses . . . .

Introduo
1.1 Enquadramento . . . . . . .
1.2 Objetivos . . . . . . . . . .
1.3 Organizao do Documento .
1.4 Diviso do Trabalho . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.
.

4
4
4
5
16
21

Concluses e Trabalho Futuro


4.1 Concluses Principais . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Trabalho Futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

23
23
23

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

Lista de Figuras
3.1
3.2
3.3
3.4
3.5
3.6
3.7

Viso robot com movimento vertical no instante deteco objeto


Trilaterao . . . . . . . . . . . . . . . . . . . . . . . . . . .
Primeiro passo algoritmo passar quartos . . . . . . . . . . . .
Segundo passo algoritmo passar quartos . . . . . . . . . . . .
Terceiro passo algoritmo passar quartos . . . . . . . . . . . .
Quarto passo algoritmo passar quartos . . . . . . . . . . . . .
Passo final algoritmo passar quartos . . . . . . . . . . . . . .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

17
18
20
20
20
21
21

Captulo 1

Introduo
1.1

Enquadramento

O projecto do qual este relatrio se refere, trata um certo robot que ir percorrer um
ambiente,passando assim por vrios objectos. Esses mesmos objectos iro ajud-lo a
responder a certas perguntas, propostas pelo utilizador.

1.2

Objetivos

1.3

Organizao do Documento

De modo a refletir o trabalho que foi feito, este documento encontra-se estruturado da
seguinte forma:
1. O primeiro captulo Introduo apresenta o projeto, a motivao para a
sua escolha, o enquadramento para o mesmo, os seus objetivos e a respetiva
organizao do documento.
2. O segundo captulo Tecnologias Utilizadas descreve os conceitos mais importantes no mbito deste projeto, bem como as tecnologias utilizadas durante
do desenvolvimento da aplicao.
3. O terceiro captulo Raciocio do Agente descreve os vrios algoritmos usados
no processo de raciocnio do agente bem como a explicao em python de certas
pores de cdigo.

1.4

Diviso do Trabalho

Visto o trabalho ter sido feito em conjunto a seguinte lista representa de forma abstracta
o trabalho feito por cada um.

1.4 Diviso do Trabalho


Pergunta 1 - Srgio;
Pergunta 2 - Srgio;
Pergunta 3 - Miguel;
Pergunta 4 - Srgio;
Pergunta 5 - Srgio;
Pergunta 6 - Miguel;
Pergunta 7 - Miguel;
Pergunta 8 - Srgio;
Pergunta 9 - Miguel;
Pergunta 10 - Miguel;
Pergunta 11 - Srgio;
Pergunta 12 - Miguel;
Pergunta 13 - Srgio;
Pergunta 14 - Miguel;
Pergunta 15 - Miguel;
Pergunta 16 - Miguel;

Captulo 2

Tecnologias e Ferramentas
Utilizadas
2.1

Introduo

Neste capitulo iremos explicar as ferramentas usadas por ns:

2.1.1

ROV

Este projecto correu num sistema operativo, ligeiramente modificado pelo professor,o
ROV. Sendo este sido assente numa maquina virtual.

2.1.2

Python

Todo o desenvolvimento da aplicao foi feito na linguaguem Python.

Captulo 3

Raciocnio do Agente
3.1

Introduo

Neste captulo vamos explicar como o agente usa o conhecimento que tem e que obtm
ao longo do tempo atravs dos seus sensores para tomar a melhor deciso possvel no
momento de modo a responder s perguntas do anteriormente referidas. para ver

3.2

Estruturas de Dados

O trecho de cdigo seguinte mostra todas as definies de variveis de modo a explicar


as estruturas e a sua aplicao:
x_ant = 0
y_ant = 0
# obj_ant =
listaObj = []
listaPosx = []
listaPosy = []
l i s t a Q u a r t o V i s i t a d o =[ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , ]
l i s t a T i p o s Q u a r t o =[ " " , " " , " " , " " , " " , " " , " " , " " , " " , " " , " " , " " , ]
estruturaObjetos = [ [] , [] , [] , [] , [] ]
estruturaPosObjetos = [ [ () ] ,[ () ] ,[ () ] ,[ () ] ,[ () ] ]

Listing 3.1: Trecho de cdigo usado no projeto.

3.3 Algoritmos

x ant , y ant so as coordenadas x e y, respetivamente, do robot


no mundo, sempre que existem alteraes nestas variveis, elas vo ser
atualizadas.

obj ant uma varivel do tipo string que guardava o valor do objeto
visto mais recentemente. De facto, esta foi a primeira abordagem para
resolver a primeira questo do trabalho prtico, acabou por ser substituida pela prxima estrutura de dados.

listaObj uma lista do tipo string que guarda o valor de todos os


objetos que foram detetados. listaPosx, listaPosy so listas que
so usadas juntamente com a listaObj. A ideia o indice de valores,ou
seja, listaObj[0],listaPosx[0],listaPosy[0] remete para o mesmo objeto.
Assim temos acesso informao do nome do objeto reconhecido e s
suas coordenadas(x,y)*.
listaQuartoVisitado uma lista do tipo int que guardava o valor
de 12 quartos. Sendo 0 quando o robot ainda no navegou nesse quarto
e tem valor 1 quando o robot o navegou.

listaTiposQuarto uma lista do tipo string que guardava o valor de 12 quartos. E tm os possveis valores: "waiting room","study
room","computer lab","meeting room","generic room".

estruturaObjetos,EstruturaPosObjetos so as estruturas fun-

damentais no trabalho, no sentido que so usadas nas funes mais complexas. A ideia similar s listas abordadas anteriormente, a ideia adicional que vou fazer uma lista de 5 posies, Livros,Cadeiras,Mesas,Computadores,Pessoas
Desta forma vou agrupar,classificar cada objeto no grupo correspondente.Dentro de cada lista vou ter ento uma lista de strings que remete
ao nome do objeto. A EstruturaPosObjetos usada para auxiliar
esta ltima estrutura para ter as coordenadas de cada objeto.A escolha
de tuplos para guardar o par x,y meramente para evitar criar 2 listas.

3.3

Algoritmos

# odometry c a l l b a c k
def callback ( data ) :

3.3 Algoritmos

g l o b a l x_ant , y_ant
x= d a t a . p o s e . p o s e . p o s i t i o n . x
y= d a t a . p o s e . p o s e . p o s i t i o n . y
quarto = descobreQuarto ( f l o a t ( x ) , f l o a t ( y ) )
l i s t a Q u a r t o V i s i t a d o [ q u a r t o 1 ] = 1 ;

Listing 3.2: Trecho de cdigo usado no projeto.

Nesta funo que atualiza as coordenadas x e y do robot quando ele


se mexe, a minha alterao foi usar outra funo descobreQuarto* que
diz o nmero do quarto consoante as variveis que enviamos. Usamos a
funo nesta parte porque aqui que temos os valores do robot imediatos. Depois de sabermos a qual quarto o robot est vamos preencher a
listaQuartoVisitado para responder a perguntas mais tarde.
# parte tuplos
def parteTuplos ( data ) :
g l o b a l l i s t a O b j , l i s t a P o s x , l i s t a P o s y , x_ant , y_ant
g = data . data . s p l i t ( " , " )
tam = l e n ( g )
f o r a i n r a n g e ( 0 , tam ) :
l i s t a O b j . append ( g [ a ] )
l i s t a P o s x . append ( x_ant )
l i s t a P o s y . append ( y_ant )
p r e e n c h e E s t r u t u r a ( g [ a ] , x_ant , y_ant )

Listing 3.3: Trecho de cdigo usado no projeto.

A ideia desta funo resolver um problema abordado na prxima


seo deste captulo. A ideia us-la no reconhecimento de objetos.
Assim recebendo a string do objeto, vamos preencher as estruturas, listaObj,listaPos e vamos classificar o objeto preenchendo o objeto com a
funo preencheEstrutura(falado mais frente). O split usado quando
o robot deteta mais do que 1 objeto

3.3 Algoritmos

# main d a s p e r g u n t a s
def questaoMain ( data ) :
i f d a t a . d a t a == " a " :
questaoA ( )
i f d a t a . d a t a == " b " :
questaoB ( )
...

Listing 3.4: Trecho de cdigo usado no projeto.

Esta bastante simples, apenas recebo o valor remetido pelo nodo


que envia perguntas, assim comparo o valor recebido e chamo a funo
respetiva para responder ao problema.
def questaoA ( ) :
global listaObj
tam = l e n ( l i s t a O b j )
i f tam > 0 :
p r i n t " R e s p o s t a QA : O b j e t o > %s " % l i s t a O b j [ tam 1]
i f tam <= 0 :
p r i n t " R e s p o s t a QA : N o e x i s t e m o b j e t o s v i s t o s "

Listing 3.5: Trecho de cdigo usado no projeto.

Esta funo responde pergunta: Qual foi o ltimo objeto visto?


Quando no existem objetos o tamanho da lista 0 pois no foram adicionados objetos para a lista. Quando existem vamos imprimir o ltimo
elemento dessa mesma lista.
def questaoB ( ) :
global listaObj
tam = l e n ( l i s t a O b j )
f o r b i n r a n g e ( 0 , tam ) :
print listaObj [b]
p r i n t " R e s p o s t a QB : O b j e t o s v i s t o s > %d " % l e n ( l i s t a O b j )

Listing 3.6: Trecho de cdigo usado no projeto.

Nesta funo queremos responder pergunta: Quantos objetos j vi.


Apenas imprimimos o tamanho da listaObj.

3.3 Algoritmos

def questaoC ( ) :
g l o b a l l i s t a O b j , l i s t a P o s x , l i s t a P o s y , x_ant , y_ant
tam = l e n ( l i s t a O b j )
m u i t o G r a n d e = 99999999999
indice = 0
f o r a i n r a n g e ( 0 , tam ) :
aux = math . s q r t ( pow ( 2 , ( x _ a n t l i s t a P o s x [ a ] ) ) + pow ( 2 , ( y _ a n t
listaPosy [a ]) ) )
i f m u i t o G r a n d e > aux :
m u i t o G r a n d e = aux
indice = a
p r i n t " R e s p o s t a QC : O b j e t o m a i s p r x i m o > %s " % l i s t a O b j [ i n d i c e ]

Listing 3.7: Trecho de cdigo usado no projeto.

Nesta funo queremos responder pergunta: Qual o objeto mais


prximo de mim. Antes de mais queria destacar que este foi um ponto
crtico do trabalho no sentido que no consegui arranjar uma soluo
perfeita e penso que seja um dos pontos mais dificeis do trabalho,vai
ser discutido na seo das Dificuldades. Quanto ao algoritmo que tenho
agora. Limito-me a fazer a distncia Euclediana de todos os objetos e
seleciono o objeto mais perto.
def questaoD ( ) :
global listaObj , listaPosx , listaPosy
tam = l e n ( l i s t a O b j )
flag = 0
f o r a i n r a n g e ( 0 , tam ) :
i f l i s t a O b j [ a ] == " p e r s o n _ j o e " :
flag = 1
x = listaPosx [a]
y = listaPosy [a]
i f f l a g == 1 :
m u i t o G r a n d e = 99999999999
indice = 0
f o r a i n r a n g e ( 0 , tam ) :
aux = math . s q r t ( pow ( 2 , ( x l i s t a P o s x [ a ] ) ) + pow ( 2 , ( y
listaPosy [a ]) ) )
i f m u i t o G r a n d e > aux :
m u i t o G r a n d e = aux
indice = a

Listing 3.8: Trecho de cdigo usado no projeto.

Nesta funo responde-se pergunta: Qual o objeto mais perto do


joe. Tento encontrar o objeto person joe e se o encontrar guardo as suas
coordenadas. Desta forma vou calcular a distncia euclediana do joe
para qualquer objeto que exista. Imprimo o mais prximo.
def questaoE ( ) :
global listaObj
tam = l e n ( l i s t a O b j )
cont = 0

3.3 Algoritmos

f o r a i n r a n g e ( 0 , tam ) :
aux = l i s t a O b j [ a ]
l i v r o = aux [ : 5 ]
i f l i v r o == " book_ " :
c o n t = c o n t +1
p r i n t " R e s p o s t a QE : L i v r o s v i s t o s > %d " % c o n t

Listing 3.9: Trecho de cdigo usado no projeto.

Nesta funo respondo questo: Quantos livros j vi. Limito-me a


fazer substring de cada objeto para detetar a keyword "book"assim vou
contar+1.
def questaoF ( ) :
global listaObj , listaPosx , listaPosy
tam = l e n ( l i s t a O b j )
flag = 0
f o r a i n r a n g e ( 0 , tam ) :
i f l i s t a O b j [ a ] == " p e r s o n _ m a r y " :
flag = 1
x = listaPosx [a]
y = listaPosy [a]
if flag
print
print
print
if flag
print

== 1 :
" R e s p o s t a QF : J
v i a Mary . "
" Est
n a s c o o r d e n a d a s x>%s " % x
" y>%s " % y
== 0 :
" R e s p o s t a QF : Ainda n o v i a Mary "

Listing 3.10: Trecho de cdigo usado no projeto.

Nesta funo respondo pergunta:Onde est a Mary. Tento encontrar


a Mary em todos os objetos e imprimo juntamente as suas coordenadas.

3.3 Algoritmos

10

def descobreQuarto (x , y ) :
i f y <= 1 . 2 :
i f x >= 0.7:
return 1
i f x >= 5.7 and x < 0.7:
return 2
i f x >= 10.7 and x < 5.7:
return 3
i f x < 10.7:
return 4
i f y > 1 . 2 and y<= 6 . 2 :
i f x >= 0.7:
return 5
i f x >= 5.7 and x < 0.7:
return 6
i f x >= 10.7 and x < 5.7:
return 7
i f x < 10.7:
return 8
i f y >= 6 . 2 :
i f x >= 0.7:
return 9
i f x >= 5.7 and x < 0.7:
r e t u r n 10
i f x >= 10.7 and x < 5.7:
r e t u r n 11
i f x < 10.7:
r e t u r n 12

Listing 3.11: Trecho de cdigo usado no projeto.

Esta uma funo auxiliar, que consoante as coordenadas recebidas


como parametros diz em que quarto o objeto/robot est.Tem uma limitao que vai ser falada na seo de Dificuldades.
def questaoG ( ) :
global listaObj , listaPosx , listaPosy
flag = 0
for a in range (0 , len ( l i s t a O b j ) ) :
i f l i s t a O b j [ a ] == " p e r s o n _ j o e " :
flag = 1
x = listaPosx [a]
y = listaPosy [a]
i f f l a g == 1 :
quarto = descobreQuarto ( f l o a t ( x ) , f l o a t ( y ) )
p r i n t " R e s p o s t a QG : O J o e e s t
no q u a r t o >%d " % q u a r t o

Listing 3.12: Trecho de cdigo usado no projeto.

Nesta funo responde-mos pergunta: Em que quarto est o Joe,


ento s usar a funo j feita DescobreQuarto.
def questaoH ( ) :
global listaObj , listaPosx , listaPosy
tam = l e n ( l i s t a O b j )
flag = 0
lisx = []

3.3 Algoritmos

11

lisy = []
f o r a i n r a n g e ( 0 , tam ) :
aux = l i s t a O b j [ a ]
s u b a u x = aux [ : 6 ]
i f s u b a u x == " t a b l e _ " :
f l a g =1
l i s x . append ( l i s t a P o s x [ a ] )
l i s y . append ( l i s t a P o s y [ a ] )
i f f l a g == 1 :
tam1 = l e n ( l i s x )
p r i n t " R e s p o s t a QH : Os s e g u i n t e s q u a r t o s t m += 1 mesa : "
f o r a i n r a n g e ( 0 , tam1 ) :
quarto = descobreQuarto ( l i s x [ a ] , l i s y [ a ] )
p r i n t " q u a r t o %d " % q u a r t o
i f f l a g == 0 :
p r i n t " R e s p o s t a QH : Ainda n o v i mesas "

Listing 3.13: Trecho de cdigo usado no projeto.

Nesta funo responde-mos funo: Quais quartos tm mais que


uma mesa. Assim uso duas listas locais para x e y e vejo quais os objetos
que so mesas. Mais tarde calculo qual o quarto correspondente a cada
coordenada de mesa.
global listaObj , listaPosx , listaPosy , listaQuartoVisitado
tam = l e n ( l i s t a Q u a r t o V i s i t a d o )
p r i n t " R e s p o s t a QI : J
v i s i t e i os s e g u i n t e s q u a r t o s : "
f o r a i n r a n g e ( 0 , tam ) :
i f l i s t a Q u a r t o V i s i t a d o [ a ] == 1 :
p r i n t " Q u a r t o >%d " % ( a + 1 )

Listing 3.14: Trecho de cdigo usado no projeto.

Nesta funo respondemos pergunta: Quais quartos visitei? usando


a lista apresentada na seo anterior facil de ver o que est a ser feito
aqui.
Falta pergunta J K

Listing 3.15: Trecho de cdigo usado no projeto.


def p r e e n c h e E s t r u t u r a ( obj , x , y ) :
global estruturaObjetos , estruturaPosObjetos
l i v r o = obj [ : 5 ]
i f l i v r o == " book_ " :
e s t r u t u r a O b j e t o s [ 0 ] . append ( obj )
e s t r u t u r a P o s O b j e t o s [ 0 ] . append ( ( x , y ) )
cadeira = obj [ : 6 ]
i f c a d e i r a == " c h a i r _ " :
e s t r u t u r a O b j e t o s [ 1 ] . append ( obj )
e s t r u t u r a P o s O b j e t o s [ 1 ] . append ( ( x , y ) )
mesa = o b j [ : 6 ]
i f mesa == " t a b l e _ " :
e s t r u t u r a O b j e t o s [ 2 ] . append ( obj )
e s t r u t u r a P o s O b j e t o s [ 2 ] . append ( ( x , y ) )

3.3 Algoritmos

12

pc = o b j [ : 9 ]
i f pc == " c o m p u t e r _ " :
e s t r u t u r a O b j e t o s [ 3 ] . append ( obj )
e s t r u t u r a P o s O b j e t o s [ 3 ] . append ( ( x , y ) )
pessoa = obj [ : 7 ]
i f p e s s o a == " p e r s o n _ " :
e s t r u t u r a O b j e t o s [ 4 ] . append ( obj )
e s t r u t u r a P o s O b j e t o s [ 4 ] . append ( ( x , y ) )

Listing 3.16: Trecho de cdigo usado no projeto.

Nesta funo auxiliar vou preencher a minhas ltimas duas estruturas


de dados de modo a agrupar os objetos. Esta funo usada na parteTuplos.Tambm preencho as coordenadas nos tuplos. H que notar que as
perguntas anteriores poderiam ter sido resolvidas e otimizadas com esta
estrutura. No entanto ela surgiu mais tarde pelo que apenas as perguntas
mais complexas a usam no seu processo de resolvimento.
def pertenceTipoQuarto ( quarto , indice ) :
global estruturaPosObjetos
f o r pos1 i n range ( 1 , l e n ( e s t r u t u r a P o s O b j e t o s [ i n d i c e ] ) ) :
tuplox , t u p l o y = e s t r u t u r a P o s O b j e t o s [ i n d i c e ] [ pos1 ]
i f d e s c o b r e Q u a r t o ( t u p l o x , t u p l o y ) == q u a r t o :
return 1
return 0

Listing 3.17: Trecho de cdigo usado no projeto.

Nesta funo auxiliar calculo com ajuda da estruturaPosObje o parametro indice que remete para: livro,cadeira,mesa... pertence ao mesmo
quarto enviado para parametro. Isto usado na funo preencheTipoQuarto e a ideia confirmar se um tipo de grupo de objeto est no quarto
do robot.
def preencheTipoQuarto ( quarto ) :
global estruturaObjetos , listaTiposQuarto , estruturaPosObjetos
tam = l e n ( l i s t a T i p o s Q u a r t o )
f o r p o s i n r a n g e ( 0 , tam ) :
flag = 0
i f e s t r u t u r a O b j e t o s [ 0 ] == [ ] and e s t r u t u r a O b j e t o s [ 1 ] ! = [ ] and
e s t r u t u r a O b j e t o s [ 2 ] == [ ] and e s t r u t u r a O b j e t o s [ 3 ] == [ ] and
e s t r u t u r a O b j e t o s [ 4 ] == [ ] :
i f p e r t e n c e T i p o Q u a r t o ( q u a r t o , 1 ) == 1 :
l i s t a T i p o s Q u a r t o [ p o s ] = " w a i t i n g room "
flag = 1
i f e s t r u t u r a O b j e t o s [ 0 ] ! = [ ] and e s t r u t u r a O b j e t o s [ 1 ] ! = [ ] and
e s t r u t u r a O b j e t o s [ 2 ] ! = [ ] and e s t r u t u r a O b j e t o s [ 3 ] == [ ] :
flag1 = 0
i f p e r t e n c e T i p o Q u a r t o ( q u a r t o , 1 ) == 1 :
flag1 = flag1 + 1
i f p e r t e n c e T i p o Q u a r t o ( q u a r t o , 0 ) == 1 :
flag1 = flag1 + 1

3.3 Algoritmos

13

i f p e r t e n c e T i p o Q u a r t o ( q u a r t o , 2 ) == 1 :
flag1 = flag1 + 1
i f f l a g 1 == 3 :
l i s t a T i p o s Q u a r t o [ p o s ] = " s t u d y room "
flag = 1
if

e s t r u t u r a O b j e t o s [ 1 ] ! = [ ] and e s t r u t u r a O b j e t o s [ 2 ] ! = [ ] and
e s t r u t u r a O b j e t o s [ 3 ] != [ ] :
flag2 = 0
i f p e r t e n c e T i p o Q u a r t o ( q u a r t o , 1 ) == 1 :
flag2 = flag2 + 1
i f p e r t e n c e T i p o Q u a r t o ( q u a r t o , 2 ) == 1 :
flag2 = flag2 + 1
i f p e r t e n c e T i p o Q u a r t o ( q u a r t o , 3 ) == 1 :
flag2 = flag2 + 1
i f f l a g 2 == 3 :
l i s t a T i p o s Q u a r t o [ pos ] = " computer l a b "
flag = 1
i f l e n ( e s t r u t u r a O b j e t o s [ 1 ] ) >= 3 and l e n ( e s t r u t u r a O b j e t o s [ 2 ] ) == 1 :
# s e v e r a l c h a i r s d e f i n i d o como >=3
flag2 = 0
cont = 0
tam = l e n ( e s t r u t u r a P o s O b j e t o s [ v a l o r ] )
f o r p o s 1 i n r a n g e ( 1 , tam ) :
tuplox , t u p l o y = e s t r u t u r a P o s O b j e t o s [ v a l o r ] [ pos1 ]
i f d e s c o b r e Q u a r t o ( t u p l o x , t u p l o y ) == q u a r t o :
c o n t = c o n t +1 # nao pude r e u t i l i z a r e s t a f u n c a o p o i s t i n h a de
c o n t a r 3 t u p l o s dum mesmo q u a r t o
i f p e r t e n c e T i p o Q u a r t o ( q u a r t o , 2 ) == 1 :
flag2 = 1
i f f l a g 2 == 1 and c o n t >=3:
l i s t a T i p o s Q u a r t o [ p o s ] = " m e e t i n g room "
flag = 1
i f f l a g == 0 :
l i s t a T i p o s Q u a r t o [ p o s ] = " g e n e r i c room "

Listing 3.18: Trecho de cdigo usado no projeto.

Nesta funo auxiliar calculamos em que tipo de quarto estou. A


ideia vou ver que tipo de quarto e se for algum tipo possvel ento vou
calcular se: no primeiro caso o livro,a cadeira, e a mesa so do mesmo
quarto passado no parametro quarto. O mesmo raciocinio efetuado nos
outros tipos de quarto. Uso nestes clculos a funo pertenceTipoQuarto
descrita anteriormente.
def questaoL ( ) :
g l o b a l x_ant , y_ant , l i s t a T i p o s Q u a r t o
x = f l o a t ( x_ant )
y = f l o a t ( y_ant )
quarto = descobreQuarto (x , y )
preencheTipoQuarto ( quarto )
p r i n t " R e s p o s t a QL : O q u a r t o onde e s t o u
listaTiposQuarto [ quarto ]

do t i p o > %s " %

3.3 Algoritmos

14

Listing 3.19: Trecho de cdigo usado no projeto.

Nesta funo responde-mos pergunta: Em que tipo de quarto estou.


Apenas uso a lista calculada anteriormente.

3.3 Algoritmos

15

d e f questaoM ( ) :
g l o b a l x_ant , y_ant
x = f l o a t ( x_ant )
y = f l o a t ( y_ant )
quarto = descobreQuarto (x , y )
#atualiza
o da e s t r u t u r a O b j e t o s
e Pos na p e r g u n t a M e L
preencheTipoQuarto ( quarto )
p r i n t " R e s p o s t a QM: Os s e g u i n t e s q u a r t o s n o e s t o o c u p a d o s , com a
informa
o c o r r e n t e >"
for a in range (0 ,12) :
i f p e r t e n c e T i p o Q u a r t o ( a , 4 ) == 0 :
p r i n t " Q u a r t o %d " % ( a + 1 )

Listing 3.20: Trecho de cdigo usado no projeto.

Nesta funo chamo a funo de preencher a estrutura para atualizar


os valores. De seguida vejo o indice 4 da estrutura,pessoa, e calculo os
quartos que no tm pessoas.
g l o b a l l i s t a O b j , l i s t a P o s x , l i s t a P o s y , x_ant , y_ant , e s t r u t u r a O b j e t o s ,
estruturaPosObjetos , listaTiposQuarto
tam = l e n ( e s t r u t u r a O b j e t o s [ 4 ] )
flag = 0
f o r a i n r a n g e ( 0 , tam ) :
i f e s t r u t u r a O b j e t o s [ 4 ] [ a ] == " p e r s o n _ m a r y " :
flag = 1
x , y = estruturaPosObjetos [4][ a]
i f f l a g == 1 :
tam = l e n ( e s t r u t u r a O b j e t o s [ 3 ] )
flag1 = 0
menor =99999999
indice = 0
f o r a i n r a n g e ( 0 , tam ) :
aux = e s t r u t u r a O b j e t o s [ 3 ] [ a ]
auxSub = aux [ : 1 4 ]
i f auxSub == " c o m p u t e r _ a p p l e " :
flag1 = 1
xPc , yPc = e s t r u t u r a P o s O b j e t o s [ 3 ] [ a ]
aux = math . s q r t ( pow ( 2 , ( x xPc ) ) + pow ( 2 , ( y yPc ) ) )
i f menor > aux :
menor = aux
indice = a
auxSub = aux [ : 1 6 ]
i f auxSub == " c o m p u t e r _ w i n d o w s " :
flag1 = 1
xPc , yPc = e s t r u t u r a P o s O b j e t o s [ 3 ] [ a ]
aux = math . s q r t ( pow ( 2 , ( x xPc ) ) + pow ( 2 , ( y yPc ) ) )
i f menor > aux :
menor = aux
indice = a
i f f l a g 1 == 0 :
p r i n t " R e s p o s t a QN : Ainda n o v i c o m p u t a d o r e s . "
i f f l a g 1 == 1 :
aux = e s t r u t u r a O b j e t o s [ 3 ] [ a ]

3.4 Dificuldades

16

auxSub = aux [ : 1 4 ]
i f auxSub == " c o m p u t e r _ a p p l e " :
p r i n t " R e s p o s t a QN : A Mary p r e f e r e c o m p u t a d o r e s da Apple "
auxSub = aux [ : 1 6 ]
i f auxSub == " c o m p u t e r _ w i n d o w s " :
p r i n t " R e s p o s t a QN : A Mary p r e f e r e c o m p u t a d o r e s Windows "
i f f l a g == 0 :
p r i n t " R e s p o s t a QN : Ainda n o v i a Mary "

Listing 3.21: Trecho de cdigo usado no projeto.

Nesta funo responde-mos pergunta: A mary prefere computadores da Apple ou Windows. A ideia calcular as coordenadas da Mary e
usar as coordenadas dos computadores observados para calcular a distncia euclediana e verifico o mais prximo a Mary. Desta maneira concluo
o que preferido.
Falta O P

Listing 3.22: Trecho de cdigo usado no projeto.


def agent ( ) :
rospy . init_node ( agent )
rospy
rospy
rospy
rospy

.
.
.
.

Subscriber ( " questions_keyboard " , String , callback2 )


Subscriber ( " object_recognition " , String , callback1 )
S u b s c r i b e r ( " questions_keyboard " , String , questaoMain )
S u b s c r i b e r ( " odom " , Odometry , c a l l b a c k )

rospy . spin ( )

Listing 3.23: Trecho de cdigo usado no projeto.

Apesar do conhecimento limitado da bibliotecas usadas no ROS, nomeadamente a funo roscpy. Altera-mos uma linha de modo a subscrever um novo mtodo,mainperguntas,ou seja, quando feita uma pergunta chamada uma funo criada por ns. E a partir daqui todo o
programa se origina.

3.4

Dificuldades

No inicio do projeto a dificuldade estava em perceber como funcionavam as funes de devolver valores pelos sensores. Um dos problemas
que nos apercebe-mos ao testar o robot no mundo foi que ele reconhecia
objetos vazios que no existiam. S mais tarde com ajuda do professor
percebemos que isto na realidade era rudo no sensor(algo que acontece
tambm na realidade). Ultrapassa-mos esta dificuldade inserindo apenas objetos que no fossem nulos. Quando come-mos a resolver as

3.4 Dificuldades

17

respostas para as perguntas, surgiu outra dificuldade: por vezes o robot detetava vrios objetos,estava a menos de 1 metro de dois objetos,
ultrapass-mos este problema com a funo parteTuplos que usava o split
com o delimitador ",".
Um dos problemas mais complexos foi o de definir quartos, o problema quando o robot no comea no quarto 1 dificil difinir os outros
por comparao. A soluo talvez seria uma lista circular onde 12 apontaria para 1.
O problema mais complexo e sem dvida o que perde-mos mais
tempo tanto a pensar numa soluo como a implementar, foi a de calcular a posio de um objeto. Neste momento estamos a assumir que as
coordenadas de deteo de um objeto so as coordenadas desse objeto,
mas isso no verdade.
Se pensarmos num circulo volta do robot e assumirmos que ele est
a dirigir-se na direo de sentido vertical no instante de deteo de um
objeto(fig.4.1)

Figura 3.1: Viso robot com movimento vertical no instante deteco objeto

3.4 Dificuldades

18

Assim percebe-mos que quando o robot, que est no centro do circulo, est nesse instante . Ento as coordenadas do objeto no so o
centro do crculo. As suas coordenadas so umas quaisquer no arco da
circunferncia dentro dos 180o da direo do robot.
Tentamos calcular o ponto mdio do arco, algo que no conseguimos,
no entanto penso que esta estratgia no iria funcionar pois no algo
calculvel. Usmos clculo de reas,trigonometria.
A prxima abordagem que nos despertou interesse foi trilaterao(fig.1.2)

Figura 3.2: Trilaterao

3.4 Dificuldades

19

Na realidade a trilaterao no nos interessa diretamente porque ela


lida com 3 dimenses e neste trabalho prtico trabalhamos com 2 dimenses. No entanto ela introduz-nos uma nova forma de raciocnio que
usar intersees de circulos de forma a estimar/calcular a posio do objeto.
.expandir isto.
Outro problema que nos surjiu foi como calcular como passar de um
quarto para outro. A primeira abordagem que tivmos foi a de guardar
um histrico de todos os quartos que o robot passou. Assim, observvamos esta lista, e se o quarto 9 l estivesse, iamos procurar os quartos
anteriores e caso estivesse o quarto 7 ento a concluso seria de que teramos obrigatriamente de passar no quarto 7 para chegar ao quarto 9.
Caso contrrio, no era obrigatrio.
No entanto esta abordagem sofria um problema. Por exemplo no mundo
predefinido, o robot pode ir at o quarto 7 e ir at o quarto 9 e ns
respondia-mos que precisamos de passar no quarto 7 obrigatriamente.
Mas o robot pode ir pelas paredes exteriores, a parte de fora, e portanto a
concluso correta seria de que no obrigatrio passar no quarto 7 para
chegar ao quarto 9.
Resolv-mos este problema com o seguinte algoritmo:
Usamos uma lista que tem o tamanho 12, todos os quartos e que tem 3
valores possveis. 0,1 ou 2. No inicio todos os quartos tm valor 0 excepto o quarto 9 que tem 1. A ideia , vou ver os quartos adjacentes que
tenho uma porta e se tiver, esse quarto muda para 1. A nica exceo
deste raciocnio se for o quarto 7, nesse caso tem sempre 0. Faz-se isto
at ter visto os meus vizinhos todos. Depois o estado que se estava a verificar muda para 2. Faz-se isto sucessivamente at j no existirem mais
mudanas de estado. As prximas figuras vo ilustrar como o algoritmo
se comporta.

3.4 Dificuldades

20

Figura 3.3: Primeiro passo algoritmo passar quartos

Figura 3.4: Segundo passo algoritmo passar quartos

Figura 3.5: Terceiro passo algoritmo passar quartos

3.5 Concluses

21

Figura 3.6: Quarto passo algoritmo passar quartos

Figura 3.7: Passo final algoritmo passar quartos

A figura 4.7, ilustra o aspeto da lista usada no algoritmo na fase final.


Agora a concluso que faz-mos a seguinte. Primeiro temos de descobrir o quarto onde o robot est. No final esta lista tem 0 ou 2. Se o quarto
tiver 2 porque no preciso passar no quarto 7 para chegar ao quarto
9. Se tiver 0 porque preciso passar no quarto 7 para chegar ao 9.
Embora este caso tenha sido simples, pois quase todos os quartos tm
portas entre eles prprios, se a distribuio de portas fosse mais restritiva, existiriam mais quartos com 0, que seriam quartos de sentido nico.
Outro problema que nos surjiu foi como calcular probabilidades. Neste
momento apenas conseguimos calcular as funes de forma incompleta.

3.5

Concluses

Apesar de conseguimos dar respostas mdias, boas ou perfeitas para cada


pergunta o mais importante ter uma base,estrutura que seja lgica e que

3.5 Concluses

22

quanto mais tempo perder-mos a construi-la mais fcil vai ser o desenvolvimento de funes e reparao de bugs. Por vezes existem situaes
onde no h respostas perfeitas ou boas, cabe-nos a ns programadores
escolher e programar a melhor resposta possvel na situao correspondente.

Captulo 4

Concluses e Trabalho Futuro


4.1

Concluses Principais

Este tipo de trabalho permitiu-nos adquirir uma viso do mundo da Inteligncia artificial e tudo o que se encontra por trs do seu desenvolvimento. O facto de o programa ter interagido com os sensores de um
robot fez com que nos apercebssemos de uma forma mais realista, dos
passos que se tm em conta para construir um robot.

4.2

Trabalho Futuro

Deveramos ter feito as perguntas que no resolvemos de forma correta.


So elas, as perguntas de probabilidades. A razo pela qual no as fizmos, foi porque ns tentamos resolv-las com redes Bayesianas. Desta
forma o projeto iria ficar muito mais completo porque a alternativa seria
calcular por fora bruta a probabilidade pedida. Ao resolver a rede Bayesiana de forma correta poderiamos responder a qualquer probabilidade
condicionada possvel. A nosso ver prefermos ter uma forma eficiente
mesmo que no esteja completa do que uma resposta ineficiente.
Existem algumas ideias que no implementmos por no ter capacidades e tempo.
Uma das ideias mais interessantes seria fazer o robot andar autonomamente, e ele ia mapeando o mundo e tentava conhecer o maior nmero
de objetos possveis. A outra ideia era fazer uma base de dados e fazer
testes com o cdigo para o agente ir treinando para ele ir aprendndo.

23