Lib yarp APP » Historique » Révision 10
Révision 9 (Frederic Elisei, 22/01/2025 18:34) → Révision 10/25 (Frederic Elisei, 23/01/2025 23:49)
h1. 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, composé d'états 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. h1. 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. <pre><code class="python"> #! /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") </code></pre> h1. Gestion des évènements et perception : 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 suivants : | <code class="python">do_in(self)</code> | class="python">do_in(self)</code>| appelée lorsqu'on rentre nouvellement dans l'état. Par exemple pour dire un message de bienvenue.| # | <code class="python">do_out(self)</code> | class="python">do_out(self)</code>| appelée lorsqu'on quitte l'état.| # | <code class="python">do_reco(self, key, msg)</code> | msg)</code>| *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{}" Oui{} "je suis d'accord" "Oui{}" "oui" Oui{}"oui" "Oui{}" "ok" Oui{}"ok" "unknown{}" Unknown{} "C'est complètement l'idée que je me faisais de la chose." | # | <code class="python">do_user_in(self, user)</code> | un nouvel utilisateur a été détecté par le robot en face de lui. ... l'objet de type User a plusieurs champs: *user.id* qui peut être utilisé avec *app.track()* ou *app.glance()* *user.location* une chaine (str), directement utilisable avec *app.look3D()* *user.visible* vaudra *True* | # | <code class="python">do_user_out(self, user)</code> | l'utilisateur précédemment détecté comme *user.id* n'est plus visible. *user.visible* qui vaudra *False* On ne peut bien sûr plus localiser ou regarder cet utilisateur ! | # | <code class="python">do_detect(self,yins,ydel,detections)</code> | class="python">do_detect(self, data,yins,ydel)</code>| Cette méthode est appelée lorsque YOLO yolo détecte des apparitions ou disparitions (de cartes, disparations de mains...), cartes ou de la main du sujet. Ou régulièrement pour mettre à jour les positions. 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}* {0,4} ou <code class="python">yins.pop()</code> yins.pop() si *yins* yins n'est pas vide. ... Les labels (str) sont accessibles en indexant *app.yolo_classes[]* : 0 correspond à "HAND" HAND (une main), 1 à "CARD" 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 deviennent visibles/invisibles, un sont visibles, le set ne contiendra 0 qu'une fois 0 au maximum (au moment de l'apparition l'insertion ou de la disparition), mais *detections* data contiendra les références multiples, ainsi que les coordonnées. multiples. ... La Le format de la chaîne (str) *detections* contient 0, 1 ou plusieurs détections, toutes concaténées *data* est visible sur cet exemple avec "+". 2 détections (séparées par le +) : *""* ou *"id1 confidence x y w h"* ou *"id1 confidence x y w h+id2 conf2 x2 y2 w h"* etc ... <code class="python">detections.split("+")</code> isole donc chaque détection, et <code class="python">len(data.split("+"))</code> vous donne donc le nombre d'objets détectés (peut-être 0...) pour retrouver s'il y a une/des mains : <code class="python">(d for d in detections.split("+") data.split("+") if d.startswith("0 ") )</code>| | Pour doter # | <code class="python">do_user_in(self, user)</code> | un état d'une nouvel utilisateur a été détecté par le robot en face de ces méthodes, on peut attacher lui. ... l'objet de type User a plusieurs champs: *user.id* *user.location* une méthode chaine (str), directement à un objet état ou à des états différents : utilisable avec *look3D()* <pre><code class="python"> *user.visible* vaudra True State("main").set_behaviour(State.do_reco,catch_default_msg) | State("waiting").set_behaviour(State.do_reco,catch_default_msg) # </code></pre> | <code class="python">do_user_out(self, user)</code> | un utilisateur précédemment détecté n'est plus visible. Plus classiquement, ... Les champs sont les mêmes que précédemment, à part *user.visible* qui vaudra False | on peut sous-classer State (ou ses sous-classes), State, comme ici: <pre><code class="python"> class StateParrot(State): def do_reco(self,key,msg): app.say(msg) StateParrot("repeat_as_parrot") app.run("repeat_as_parrot") </code></pre> Si on a besoin de plusieurs méthodes dans le même état, ou beaucoup d'états différents, il est plus probablement plus simple/lisible d'utiliser des sous-classes. Si attacher une méthode est utilisée méthode, sans sous-classer ou parce qu'elle sert dans plusieurs états, l'attacher aux instances est peut-être plus lisible, ou permet des modifications dynamiques. états : <pre><code class="python"> State("main").set_behaviour(State.do_reco,catch_default_msg) </code></pre> h1. Génération d'actions 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 : | <code class="python">app.switch("etat2"</code>) | 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. d'état.| | # | <code class="python">app.sayNB("texte à prononcer")</code> | fait prononcer au robot le texte voulu. La suite du traitement des évènements va reprendre dès que la phrase *commencera* commencera à être prononcée ( _NB = non blocking)_ | # | <code class="python">app.say("texte à prononcer")</code> | fait prononcer au robot le texte voulu. *Attention, l'appel est bloquant*, jusqu'à ce que la phrase soit prononcée en entier : plus la phrase est longue, plus bloquant* et des évènements en retard vont risquent de s'empiler dans la pile de traitement... | # | <code class="python">app.track(target)</code> | suit du regard traitement, surtout si la cible *target* Les valeurs possible sont *"All",* *"Nobody"* ou le *user-id* reçu lors d'un évènement USERIN phrase est longue... | # | <code class="python">app.glance(target)</code> | comme précédemment, mais seulement en jetant un coup d’œil | # | <code class="python">app.look("x y z",duration=Xms)</code> | 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. | h1. Méthodes auxiliaires | <code class="python">AnyKeyword(**strings).isin(message)</code> | pour tester la présence de l'un des mots clefs (synonymes) dans un message reçu par le robot. ... par exemple : if AnyKeyword('rouge','vert','bleu')isin(msg): | # | <code class="python">x,y = yolo_center(yolo_data)</code> | à partir d'une des lignes détectées par yolo, retourne la position detectée *(x,y)* Utile pour comparer des positions de cartes (droite, gauche, proches d'une autre ou de la main...), choisir | # | <code class="python">id = yolo_target(yolo_data,duration=Xms)</code> | à partir d'une des lignes détectées par yolo, oriente tête et regard du robot vers la carte (ou main) correspondante, soit définitivement, soit temporairement si *duration* est passé en paramètre (durée en millisecondes) *id* retourné permet d'avoir le label correspondant via *app.yolo_classes[id]* | définitive.|