Objectif¶

Pouvoir réaliser rapidement une maquette, en python, d'une interaction avec le robot Furhat, en faisant intervenir :

• synthèse et reconnaissance de parole via Furhat
• détection des interlocuteurs avec la caméra de Furhat
• détection visuelle avec YOLO (cartes vues de dessus par exemple) et une caméra externe
• gestion du regard/orientation de la tête vers les interlocuteurs ou les cartes détectées par YOLO

On découpera l'application sous forme d'un automate réactif, en états simples.
L'environnement d'exécution s'appuie aussi sur YARP [https://yarp.it/latest/], pour permettre la répartition des tâches entre plusieurs machines (windows, Linux...) qui communiqueront par messages.

Squelette minimal :¶

On va s'appuyer sur lib_yarp_APP.py (et indirectement sur my_yarp.py) pour créer nos états et programmer les actions réactives et les transitions entre états.

#! /usr/bin/env python3

# import app, furhat, State, AnyKeywords, yolo_center, yolo_target
from lib_yarp_APP import *

# create and run initial state, through its name
State("main")
app.run("main")

Gestion des évènements :¶

Les états, comme celui nommé "main" dans l'exemple précédent, sont des objets dérivés de la classe State (ou d'une sous-classe). Les états doivent avoir des noms différents.
Pour implémenter des réactions à des évènements, il faut qu'ils fournissent une implémentation de tout ou partie des prototypes :

do_in(self)	appelée lorsqu'on rentre nouvellement dans l'état. Par exemple pour dire un message de bienvenue.
do_out(self)	appelée lorsqu'on quitte l'état.
do_reco(self, key, msg)	msg contient la chaîne de parole reconnue par le robot. key peut faciliter la détection de certaines classes d'intention, indépendamment de leur formulation exacte. Il n'y en a pas beaucoup par défaut : "Oui{}" ou "Non{}" ou "Bonjour{}" "Fini{}" ... Oui{} "je suis d'accord" Oui{}"oui" Oui{}"ok" Unknown{} "C'est complètement l'idée que je me faisais de la chose."
do_detect(self, data,yins,ydel)	Cette méthode est appelée lorsque yolo détecte des apparitions ou disparations de cartes ou de la main du sujet. Ou régulièrement s'il y a des détections. yins et ydel sont des sets python (itérables mais non indexables comme une liste ou un tableau !), possiblement vides. Par exemple {} ou {0,4} ou yins.pop() si yins n'est pas vide. ... Les labels sont accessibles en indexant app.yolo_classes[] : 0 correspond à HAND (une main), 1 à CARD (une carte inconnue), les suivants sont des cartes identifiées ("Bouilloire verte"...). Les coordonnées de tout ce qui est visible sont dans la chaîne data. Si deux mains sont visibles, le set ne contiendra qu'une fois 0 au maximum (au moment de l'insertion ou de la disparition), mais data contiendra les références multiples. ... Le format de la chaîne (str) data est visible sur cet exemple avec 2 détections (séparées par le +) : "id1 confidence x y w h+id2 conf2 x2 y2 w h" len(data.split("+")) vous donne donc le nombre d'objets détectés (peut-être 0...) pour retrouver s'il y a une/des mains : (d for d in data.split("+") if d.startswith("0 ") )
do_user_in(self, user)	un nouvel utilisateur a été détecté par le robot en face de lui. ... l'objet de type User a plusieurs champs: user.id user.location une chaine (str), directement utilisable avec look3D() user.visible vaudra True
do_user_out(self, user)	un utilisateur précédemment détecté n'est plus visible. ... Les champs sont les mêmes que précédemment, à part user.visible qui vaudra False

on peut sous-classer State, comme ici:

class StateParrot(State):

  def do_reco(self,key,msg):
      app.say(msg)

StateParrot("repeat_as_parrot")
app.run("repeat_as_parrot")

ou attacher une méthode, sans sous-classer ou parce qu'elle sert dans plusieurs états :

State("main").set_behaviour(State.do_reco,catch_default_msg)

Actions possibles¶

Dans un état, au moment où on y entre ou à réception d'un évènement, il est possible de générer certaines actions.
On ne peut pas générer d'action régulière (idle), ou au bout d'un certain temps sans passer par ces évènements ou transitions. C'est un choix lié à la vitesse d'exécution sous Python et éviter de se retrouver avec beaucoup d'évènements en retard non traités.

Voici les actions possibles :

app.switch("etat2")	prépare la transition vers un autre état. Elle ne sera pas instantanée, laissant aux évènements déjà en attente d'être dépilés. En clair, c'est la même file d'attente pour les évènements et le changement d'état.
app.sayNB("texte à prononcer")	fait prononcer au robot le texte voulu. La suite du traitement des évènements va reprendre dès que la phrase commencera à être prononcée ( NB = non blocking)
app.say("texte à prononcer")	fait prononcer au robot le texte voulu. Attention, l'appel est bloquant et des évènements risquent de s'empiler dans la pile de traitement, surtout si la phrase est longue...
app.look("x y z",duration=Xms)	demande au robot de regarder aux coordonnées correspondant à la chaine (str) en paramètre. Celle-ci peut être obtenue par yolo ou construite à partir d'un triplet de flottants: "%d d %d"(1,2,3), en mètres (x-axis to the robot's left, the y-axis up, and z-axis to the front). Le repère est centré sur les yeux au repos. Si duration est spécifié (en millisecondes), le regard reviendra sur sa cible initiale une fois ce délai écoulé. Sans ce paramètre, le regard du robot sera changé de façon plus définitive.