Leap Motion

///////////////////////////////////////////////////////////////////////
——— LEAP MOTION————-
///////////////////////////////////////////////////////////////////////
Article écrit par Louis Eveillard
Designer / Chercheur à L’EnsadLab
Rédigé avec l’aide d’Edouard Mortec.

Source Code :
Sketches Processing

///////////////////////////////////////////////////////////////////////
2
///////////////////////////////////////////////////////////////////////

PRÉSENTATION.

Le Leap est un petit appareil qui se connecte en USB à un ordinateur. Il détecte et enregistre
les mains, les doigts, ou tout autre objet ressemblant à un doigt qui passe dans son champ de
vision. Contrairement au Kinect de Microsoft, il se contente donc d’analyser un espace très
proche mais avec une excellente précision et une réactivité exemplaire.

Posé à plat sur une surface directement en dessous d’un écran, le Leap détecte tous les mouvements
qui ont lieu au dessus de lui dans un espace en forme pyramide inversé d’une soixantaine de centimètre
de haut. Large de quelques centimètres en bas, elle s’étend pour accommoder les dix doigts de la main
à partir d’une trentaine de centimètres.

Le Leap est pour l’instant capable de communiquer des informations très simples : position de la main,
de chacun des doigts mais aussi de la direction exacte dans laquelle pointe chaque doigt. Cette information
est particulièrement précieuse, car elle permet de suivre les gestes qui sont effectués par l’utilisateur :
resserrer le poing, pincer deux doigts, glisser la main dans une direction, etc.

Peu d’informations sont données sur le fonctionnement exact du Leap. Les données fournies par l’API
(le programme qui fait le lien entre le logiciel du Leap et les autres logiciels comme Processing)
sont uniquement liés aux doigts et aux mains, et il est pour l’instant impossible d’accéder au flux
vidéo des caméras stéréoscopiques infra-rouge.

1

Le Leap sera commercialisé en Mai aux États-Unis, pour un prix d’environ 80 dollars. Il devrait arriver
rapidement après en France. En attendant, plusieurs milliers de kits pour développeurs ont été distribués
de par le monde pour permettre à des ingénieurs, des musiciens, des graphistes et des bidouilleurs
d’imaginer les usages qui en seront fait.

Pour faciliter la tâche des développeurs, le Leap est fournit
avec un SDK (software development kit, traduit kit de développement de logiciels) particulièrement réussi.
Celui-ci permet l’accès aux informations du Leap par de nombreux biais, notamment grâce à un server web
local qui permet de récupérer toutes les données grâce à quelques lignes de JavaScript. Cela signifie que, potentiellement, n’importe quel site web pourrait se servir des données du Leap de la manière dont il
l’entend, avec l’accord de l’utilisateur.

LIBRARIES.

Sur Processing, plusieurs librairies se chargent de rendre les données du Leap visibles et disponibles.
J’en ai recensé trois développées en parallèle et plus ou moins abouties.

Les deux premières sont principalement des wrappers, c’est à dire qu’elles récupèrent les informations du
SDK et les passe directement à Processing.

Par exemple, la première, développée par Michael Heuer, permet d’accéder aux informations des doigts de
cette manière, (ceci est un extrait de leap_position_example.pde, j’ai ajouté des commentaires en italique pour clarifier le code) :

 

// On créer une base de données qui stockera les doigts et leurs positions
fingerPositions = new ConcurrentHashMap<Integer, Vector>();

// On itère pour chaque doigt dans notre base de donnée
for (Map.Entry entry : fingerPositions.entrySet()) {

// On récupère son identifiant (un chiffre)
Integer fingerId = (Integer) entry.getKey();

// On créé un vecteur qui contient sa position
Vector position = (Vector) entry.getValue();

// On défini la couleur de remplissage en fonction de l'identifiant du doigt
fill(fingerColors.get(fingerId));
noStroke();

// on dessine une ellipse, après avoir transformé les valeurs fournis par le leap
//en des valeurs correspondant à un sketch processing.

ellipse(leapToScreenX(position.getX()), leapToScreenY(position.getY()), 24.0, 24.0);
}

La deuxième fonctionne à peu près de la même manière, et renvoie exactement les mêmes valeurs, avec la
position approximative de la paume de la main en plus.

La troisième librairie est la plus riche et la plus intéressante. Développée par Marcel Schwittlick, elle incorpore en plus des informations précédentes une
détection de gestes. Cette reconnaissance est basée sur le OneDollar Unistroke Recognizer de l’Université
de Washington, adapté sur Processing par Darius Morawiec. Le $1 Recognizer est particulièrement fiable
pour interpréter les déplacements d’un point (en l’occurrence, ici un ou plusieurs doigts) en un mouvement,
et chaque mouvement déclenche une fonction associée.

Voici une liste des gestes et des paramètres associés :

+ cercle : un mouvement circulaire avec la main
–> sens : sens des aiguilles d’une montre / sens opposé
–> rayon du cercle tracé
–> vecteur normalisé
–> nombre de tours
–> position du centre
–> temps pour le réaliser

+ swipe : un mouvement horizontal de balayage
–> position du milieu du swipe
–> direction
–> vitesse
–> temps pour le réaliser

+ screenTap : un mouvement court de pointage avec un doigt vers l’écran, comme en touchant un écran tactile
–> position
–> direction
–> temps pour le réaliser

+ keyTap : un mouvement vers le bas, comme en tapant sur un clavier
–> position
–> direction
–> temps pour le réaliser

Quand un mouvement est détecté, une fonction est appelée. Pour le cercle, c’est celle-ci (elles sont toutes répertoriées dans les exemples de cette librairie).

public void circleGestureRecognized(CircleGesture gesture, String clockwiseness) {}

À l’intérieur de cette fonction, il est possible de placer n’importe quelle commande. Imprimer un document,
poster un tweet, éteindre sa machine, etc.

PRODUCTION D’IMAGES AVEC LE LEAP

Les trois programmes qui suivent explorent la production d’animation contenant des formes générées en temps réel. Ils sont inspirés par le recode project et explorent les possibilités de recréation de mécanismes de dégradation d’image. Le premier et le dernier sont à ouvrir dans Processing 2.0b8, tandis que le deuxième est optimisé pour Processing 1.5.1. Cela s’explique par la manière dont se fait le traitement de l’image entre ces deux versions, qui justifient à eux seuls, dans certains cas,
de continuer à se servir de Processing 1.5.1.

Download Sketches Processing ici

lw_img_1983

lw_img_525
Ci-dessus des captures d’écran des sketchs Processing

Voici également une vidéo de ces trois programmes pour bien réaliser la précision des mouvements et la grande réactivité. Les ressources que sollicite le SDK pour transformer l’image du Leap en points représentant les doigts dans l’espace est considérable, et combinée avec celle d’un sketch Processing, l’un peux empêcher l’autre de s’exécuté aussi vite qu’il le voudrait.

PRODUCTION DE SONS AVEC LE LEAP.

Le Leap permet aussi, grâce à sa grande précision et à son utilisation des mains, de devenir un périphérique de contrôle pour du son. Edouard Mortec, musicien, artiste et participant aux sessions Processing Paris a réalisé cette vidéo pour montrer comment il était possible de moduler et maintenir une note par la position de sa main dans l’espace. Les gestes qui en résultent ne sont pas sans rappeler la machine de Thérémin.

EXEMPLES D’INTERFACE…

Voir d’autres exemples dans l’article ci-dessous.

///////////////////////////////////////////////////////////////////////
Plus d’infos

Un autre article portant plus sur les usages et la comparaison avec le Kinect
se trouve à cette adresse :
EnsadLab

Les sketchs présentés dans cet article sont sous license CC-BY 3.0.

Pour toute question, contacter le freeartbureau ou l’auteur de cet article à
louis.eveillard@gmail.com
///////////////////////////////////////////////////////////////////////