Vous pouvez voir des informations sur les différentes API fournies par NAOqi Framework en ouvrant [Aide] - [API de référence] de Choregraphe. Dans cet article, je vais expliquer comment utiliser l'API en utilisant ** ALPeoplePerception API ** et ** ALFaceCharacteristics API ** comme exemples.

De plus, ** l'API ALPeoplePerception et l'API ALFaceCharacteristics n'ont pas de moyen de vérifier le fonctionnement avec un robot virtuel, et une machine Pepper réelle est requise. ** Je voudrais que vous expérimentiez la machine à poivre à Aldebaran Atelier Akihabara. (URL de réservation: http://pepper.doorkeeper.jp/events)

API introduite dans cet article

ALPeoplePerception API

L'API ** People Perception ** est également disponible dans Tutoriel Pepper (6): Capteur tactile, reconnaissance humaine Comme vous pouvez le voir, c'est une API qui offre la possibilité de détecter et d'identifier les personnes autour de Pepper.

Lorsqu'une personne est détectée par le capteur de Pepper, un ID d'identification temporaire est défini et cette information est stockée dans une zone appelée «ALMemory». L'application peut obtenir l'événement par ʻALPeoplePerception via ʻALMemory et faire quelque chose, ou peut utiliser les informations stockées par ʻALPeoplePerception dans ʻALMemory.

Cette API fournit des informations relatives à la reconnaissance humaine, telles que:

Liste des informations d'identification des personnes reconnues par Pepper
Événements de changement tels que la reconnaissance de nouvelles personnes et la perte de personnes
Informations d'attribut pour chaque personne qui reconnaît
Informations telles que la distance relative à Pepper et la position
S'il est en vue et s'il détecte un visage
Couleur de la chemise

ALFaceCharacteristics API

** Caractéristiques du visage ** L'API est une API qui analyse les informations faciales de chaque personne reconnue par ʻALPeoplePerception` et obtient des informations supplémentaires telles que l'âge, le sexe et le rire.

ʻALFaceCharacteristics` fournit les informations suivantes déduites des traits du visage:

Âge ... Âge estimé (0-75 ans)
Sexe ... Sexe estimé (Homme / Femme)
Degré de sourire ... Degré d'être considéré comme un sourire (0,0-1,0)

Chacune de ces valeurs est également fournie avec une valeur comprise entre 0 et 1 pour indiquer le degré de certitude. De plus, les valeurs suivantes sont fournies.

Expression faciale ... Valeur d'évaluation de laquelle des expressions faciales sans expression, heureuse, surprise, en colère et triste

Comment utiliser l'API

Tout d'abord, lors de l'utilisation de ces API, nous organiserons comment accéder aux API. Il existe deux manières principales d'utiliser les différentes fonctions fournies par l'API.

Appel d'une méthode de module via ʻALProxy`
Obtenez l'événement et la valeur via ʻALMemory`

Ici, nous allons donner un aperçu de chaque méthode.

Appel de méthode de module via ALProxy

De nombreuses API telles que ʻALPeoplePerception et ʻALFaceCharacteristics sont fournies sous la forme de ** modules **.

Les modules sont fournis par les classes Python et les méthodes fournies par l'API sont accessibles via la classe ʻALProxy. Par exemple, pour appeler la méthode ʻanalyzeFaceCharacteristics fournie par ʻALFaceCharacteristics`, écrivez le script Python suivant.

faceChar = ALProxy("ALFaceCharacteristics")
faceChar.analyzeFaceCharacteristics(peopleId)

Lors de l'exécution d'un script Python dans Pepper comme Python Box, spécifiez la chaîne de caractères indiquant le nom du module dans ʻALProxy comme argument. Cela vous donnera une instance ʻALProxy pour accéder au module. Cela permet à l'application d'appeler les méthodes fournies par l'API.

Obtenez des événements et des valeurs via ALMemory

Lorsque nous avons introduit Memory Events, nous avons introduit la gestion des événements par clé, mais les informations collectées par différentes API de Pepper sont Il est une fois agrégé dans un mécanisme appelé «Mémoire AL». L'application peut effectuer les opérations suivantes sur ʻALMemory`.

Définir et obtenir des valeurs
Emission et suivi d'événements

Il existe les manières suivantes d'utiliser ʻALMemory`.

Surveillance des événements par diagramme de flux

À l'extrême gauche du diagramme, vous pouvez créer une entrée qui répond aux événements de mémoire.

Pour plus de détails sur le fonctionnement, reportez-vous à Approaching people.

Acquisition de valeur par bibliothèque de boîtes, surveillance d'événements

En utilisant la boîte en mémoire de la bibliothèque de boîtes avancées, il est possible d'acquérir et de définir des valeurs, de surveiller les événements de mémoire, etc. en combinant des boîtes.

Cet article vous montrera comment utiliser la boîte, en utilisant ** Obtenir une liste de personnes ** comme exemple.

Acquisition de valeur et surveillance des événements par script Python

Puisque ʻALMemory est également implémenté comme module décrit ci-dessus, il est accessible via ʻALProxy comme suit.

memory = ALProxy("ALMemory")
ageData = memory.getData("PeoplePerception/Person/%d/AgeProperties" % peopleId)

Dans cet article, nous utiliserons ** Age Estimate ** comme exemple pour obtenir la valeur.

Essayez d'utiliser

Exemple d'emplacement de projet

Les projets présentés ici sont disponibles sur https://github.com/Atelier-Akihabara/pepper-face-characteristics-example.

Vous pouvez utiliser l'exemple de projet en récupérant le fichier depuis GitHub https://github.com/Atelier-Akihabara/pepper-face-characteristics-example. Il existe plusieurs façons de l'obtenir, mais l'une des méthodes les plus simples est d'obtenir l'archive à partir du lien [Télécharger le fichier ZIP].

Le fichier résultant contient des dossiers affichant deux projets, ** visible-people-list ** et ** get-age **. Ce dossier contient un fichier avec l'extension .pml, vous pouvez donc l'ouvrir en double-cliquant dessus pour démarrer Choregraphe et utiliser le projet.

J'expliquerai les points pour chaque exemple de projet.

ALPeoplePerception: obtenir une liste de personnes

Tout d'abord, vérifions le comportement lorsque Pepper reconnaît une personne en utilisant l'événement PeoplePerception / VisiblePeopleList pour ** obtenir une liste des personnes actuellement visibles par Pepper **. Je vais.

L'exemple de projet est ** visible-people-list **. Vous pouvez ouvrir les fichiers obtenus à partir de GitHub en double-cliquant sur visible-people-list.pml dans le dossier visible-people-list. Il est créé par la procédure suivante.

Cliquez sur le bouton ** Ajouter un événement de mémoire [+] sur le côté gauche du diagramme de flux **, entrez ** PeoplePerception [A] ** dans le filtre et cochez ** PeoplePerception / VisiblePeopleList [B] **.
Placez les cases suivantes sur le diagramme de flux

bibliothèque de boîtes standard
Système> Journal (2)
bibliothèque de boîtes avancées * Memory > Get Data

Définissez les connexions et les paramètres de chaque boîtier comme suit:

Exécutez ce projet et cliquez sur Log Viewer (http://qiita.com/Atelier-Akihabara/items/7a898f5e4d878b1ad889#-%E5%8F%82%E8%80%83%E3%82%A8%E3%83 % A9% E3% 83% BC% E3% 81% AE% E8% A1% A8% E7% A4% BA% E3% 81% A8% E3% 83% AD% E3% 82% B0% E3% 83% 93 Veuillez vérifier le message apparaissant dans% E3% 83% A5% E3% 83% BC% E3% 82% A2). Lorsqu'une personne se déplace autour de Pepper, le journal suivant doit être généré.

[INFO ] behavior.box :onInput_message:27 _Behavior__lastUploadedChoregrapheBehaviorbehavior_1790002616__root__AgeDetection_5__Log_1: Get: []
[INFO ] behavior.box :onInput_message:27 _Behavior__lastUploadedChoregrapheBehaviorbehavior_1790002616__root__AgeDetection_5__Log_2: Raised: [179318]

Vous pouvez voir que l'événement PeoplePerception / VisiblePeopleList fournit une liste des identifiants des personnes visibles par Pepper, sous la forme de 179318.

Ensuite, utilisons ʻALFaceCharacteristics` pour obtenir les informations sur le visage de la personne indiquée par ces identifiants.

ALFaceCaractéristiques: Estimation de l'âge

Ensuite, obtenons la valeur PeoplePerception / Person / <ID> / AgeProperties définie par le processus d'analyse de ʻALFaceCharacteristics`. Ici, à titre d'exemple, ** Pepper estime l'âge de la personne qu'il trouve et dit «Êtes-vous environ?» **.

Dans l'exemple précédent, nous avons obtenu les identifiants de toutes les personnes que Pepper a trouvées, mais ici, Basic Awareness J'utiliserai la fonction de. Nous utiliserons la boîte Trackers> Basic Awarenss dans la bibliothèque de boîtes standard pour suivre les personnes et obtenir l'ID de la personne suivie à partir de la sortie HumanTracked.

L'exemple de projet est ** get-age **. Parmi les fichiers obtenus à partir de GitHub, vous pouvez l'ouvrir en double-cliquant sur «get-age.pml» dans le dossier «get-age». Il est créé par la procédure suivante.

Créez une boîte Get Age en tant que boîte Python vide Cette fois, la configuration d'entrée / sortie est la suivante. Veuillez vous référer au Python Box Concept pour savoir comment le créer.

Double-cliquez sur la case Get Age pour ouvrir l'éditeur de script et écrire un script Python comme celui ci-dessous.

class MyClass(GeneratedClass):
    def __init__(self):
        GeneratedClass.__init__(self)

    def onLoad(self):
        self.memory = ALProxy("ALMemory")
        self.faceChar = ALProxy("ALFaceCharacteristics")

    def onUnload(self):
        pass

    def onInput_onPeopleDetected(self, peopleId):
        if peopleId < 0:
            return
        r = self.faceChar.analyzeFaceCharacteristics(peopleId)
        if not r:
            self.onUnknown()
            return
        ageData = self.memory.getData("PeoplePerception/Person/%d/AgeProperties" % peopleId)
        self.logger.info("Age Properties: %d => %s" % (peopleId, ageData))
        if ageData and len(ageData) == 2:
            self.onAge(ageData[0])
        else:
            self.onUnknown()

Ce code appelle la méthode ʻanalyzeFaceCharacteristics de ʻALFaceCharacteristics pour l'ID de la personne donné à partir de l'entrée ʻonPeopleDetected, et si cet appel réussit, à partir de ʻALMemory`` PeoplePerception / Person / <ID> / AgeProperties. Il obtient la valeur de ʻet appelle la sortie de ʻonAge avec la valeur indiquant l'âge de cette valeur comme argument.

Placez les boîtes suivantes

bibliothèque de boîtes standard * Trackers > Basic Awareness * Audio > Voice > Say
bibliothèque de boîtes avancées * Audio > Voice > Say Text

Remplacez la zone Type de texte par Nombre et personnalisez la zone Dire texte (http://qiita.com/Atelier-Akihabara/items/8df3e81d286e2e15d9b6#%E8%A3%9C%E8%B6%] B3say-text% E3% 83% 9C% E3% 83% 83% E3% 82% AF% E3% 82% B9% E3% 81% AE% E3% 82% AB% E3% 82% B9% E3% 82% BF% E3% 83% 9E% E3% 82% A4% E3% 82% BA) pour changer ce que vous dites
```
sentence += "vous êtes%Environ d ans" % int(p)
```
Connectez les boîtes placées en 1. et 3. comme indiqué ci-dessous.
Changez le contenu de la boîte Say connectée à la sortie ʻonUnknown` en quelque chose comme "Je ne sais pas".

Lorsque vous exécutez cette application, Basic Awareness sera lancé et Pepper transformera votre visage en réponse à votre environnement. Lorsque vous trouvez une personne, l'ID de la personne est entrée dans la case Obtenir l'âge et vous dites: «Êtes-vous sur le point?» Même si vous trouvez une personne, si le visage est difficile à reconnaître, le processus de reconnaissance échouera et vous direz «je ne sais pas».

De cette manière, il est possible de réaliser une application qui estime l'âge d'une personne reconnue par PeoplePerception en utilisant les informations obtenues à partir de ** ALPeoplePerception API **, ** ALFaceCharacteristics API **. est. Même si la fonction n'est pas fournie dans la bibliothèque de boîtes, de nombreuses fonctions peuvent être réalisées en accédant à l'API en utilisant ʻALProxy, ʻALMemory.

[PYTHON] Reconnaissance de l'âge à l'aide de l'API de Pepper