J’ai abandonné ma souris : comment contrôler mon ordinateur avec des gestes de la main (en 60 lignes de Python)

des véhicules autonomes et des modèles de langage d’IA, mais la principale interface physique par laquelle nous nous connectons aux machines est restée inchangée depuis cinquante ans. Étonnamment, nous utilisons encore la souris d’ordinateur, un appareil créé par Doug Engelbart au début des années 1960, pour cliquer et faire glisser. Il y a quelques semaines, j’ai décidé de remettre en question cette norme en codant en Python.

Pour les Data Scientists et les ingénieurs ML, ce projet est plus qu’un simple tour de passe-passe : c’est une masterclass en vision par ordinateur appliquée. Nous allons construire un pipeline en temps réel qui capte un flux vidéo non structuré (pixels), applique séquentiellement un modèle ML pour extraire des fonctionnalités (repères manuels) et enfin les convertit en commandes tangibles (déplacement du curseur). Fondamentalement, il s’agit d’un exemple « Hello World » de la prochaine génération d’interaction homme-machine.

L’objectif? Contrôlez le curseur de la souris simplement en agitant votre main. Une fois que vous démarrez le programme, une fenêtre affichera le flux de votre webcam avec un squelette de main superposé en temps réel. Le curseur de votre ordinateur suivra votre index à mesure qu’il se déplace. C’est presque comme la télékinésie : vous contrôlez un objet numérique sans toucher aucun appareil physique.

Le concept : apprendre à Python à « voir »

Afin de connecter le monde physique (ma main) au monde numérique (le curseur de la souris), nous avons décidé de diviser le problème en deux parties : les yeux et le cerveau.

• The Eyes – Webcam (OpenCV) : Pour obtenir la vidéo de la caméra en temps réel, c’est la première étape. Nous utiliserons OpenCV pour cela. OpenCV est une vaste bibliothèque de vision par ordinateur qui permet à Python d’accéder et de traiter les images d’une webcam. Notre code ouvre la caméra par défaut avec cv2.VideoCapture(0) puis continue de lire les cadres un par un.
• The Brain – Hand Landmark Detection (MediaPipe) : Afin d’analyser chaque image, trouver la main et reconnaître les points clés de la main, nous nous sommes tournés vers la solution MediaPipe Hands de Google. Il s’agit d’un modèle d’apprentissage automatique pré-entraîné capable de prendre la photo d’une main et de prédire l’emplacement de 21 points de repère 3D (les articulations et le bout des doigts) sur une main. Pour faire simple, les mains MediaPipe non seulement « détectent une main ici », mais vous montrent même exactement où se trouvent le bout de chaque doigt et chaque articulation dans l’image. Une fois que vous avez obtenu ces points de repère, le défi principal est pratiquement terminé : choisissez simplement le point de repère que vous voulez et utilisez ses coordonnées.

Fondamentalement, cela signifie que nous transmettons chaque image de caméra à MediaPipe, qui génère les coordonnées (x, y, z) de 21 points sur la main. Pour contrôler un curseur, nous suivrons l’emplacement du repère n°8 (le bout de l’index). (Si nous devions implémenter le clic plus tard, nous pourrions vérifier la distance entre les points de repère n°8 et n°4 (pointe du pouce) pour identifier un pincement.) Pour le moment, nous ne nous intéressons qu’au mouvement : si nous trouvons la position du bout de l’index, nous pouvons à peu près la corréler à l’endroit où le pointeur de la souris devrait se déplacer.

La magie de MediaPipe

MediaPipe​‍​‌‍​‍‌ Hands s’occupe des parties difficiles de la détection des mains et de l’estimation des points de repère. La solution utilise l’apprentissage automatique pour prédire 21 repères manuels à partir d’une seule image.

De plus, il est pré-entraîné (sur plus de 30 000 images de mains en fait), ce qui signifie que nous n’avons pas besoin d’entraîner notre modèle. Nous obtenons et utilisons simplement le « cerveau » de suivi manuel de MediaPipe dans ​‍​‌‍​‍‌Python :

mp_hands = mp.solutions.hands
hands = mp_hands.Hands(max_num_hands=1, min_detection_confidence=0.7)

Ainsi,​‍​‌‍​‍‌ par la suite, chaque fois qu’une nouvelle trame est envoyée via hands.process()il renvoie une liste des mains détectées ainsi que leurs 21 repères. Nous les rendons sur l’image afin de pouvoir vérifier visuellement que cela fonctionne. L’essentiel est que pour chaque main, on puisse obtenir hand_landmarks.landmark[i] pour i allant de 0 à 20, chacun ayant des coordonnées normalisées (x, y, z). Plus précisément, le bout de l’index est un point de repère[8] et le bout du pouce est un point de repère[4]. En utilisant MediaPipe, nous sommes déjà soulagés de la tâche difficile de déterminer la géométrie de la pose de la main.

La configuration

Vous n’avez pas besoin d’un superordinateur pour cela : un ordinateur portable classique équipé d’une webcam suffit. Installez simplement ces bibliothèques Python :

pip install opencv-python mediapipe pyautogui numpy

• opencv-python : Gère le flux vidéo de la webcam. OpenCV nous permet de capturer des images en temps réel et de les afficher dans une fenêtre.
• tuyau multimédia : Fournit le modèle de suivi manuel (MediaPipe Hands). Il détecte la main et renvoie 21 points de repère.
• pyautogui : Une bibliothèque d’automatisation GUI multiplateforme. Nous l’utiliserons pour déplacer le curseur de la souris sur notre écran. Par exemple, pyautogui.moveTo(x, y) déplace instantanément le curseur vers la position (x, y).
• numpy : Utilisé pour les opérations numériques, principalement pour mapper les coordonnées de la caméra aux coordonnées de l’écran. Nous utilisons numpy.interp pour mettre à l’échelle les valeurs de la taille de l’image de la webcam à la résolution d’affichage complète.

Notre environnement est désormais prêt et nous pouvons écrire la logique complète dans un seul fichier (par exemple, ai_mouse.py).

Le code

La logique de base est remarquablement concise (moins de 60 lignes). Voici le script Python complet :

import cv2
import mediapipe as mp
import pyautogui
import numpy as np

# --- CONFIGURATION ---
SMOOTHING = 5  # Higher = smoother movement but more lag.
plocX, plocY = 0, 0  # Previous finger position
clocX, clocY = 0, 0  # Current finger position

# --- INITIALIZATION ---
cap = cv2.VideoCapture(0)  # Open webcam (0 = default camera)

mp_hands = mp.solutions.hands
# Track max 1 hand to avoid confusion, confidence threshold 0.7
hands = mp_hands.Hands(max_num_hands=1, min_detection_confidence=0.7)
mp_draw = mp.solutions.drawing_utils

screen_width, screen_height = pyautogui.size()  # Get actual screen size

print("AI Mouse Active. Press 'q' to quit.")

while True:
    # STEP 1: SEE - Capture a frame from the webcam
    success, img = cap.read()
    if not success:
        break

    img = cv2.flip(img, 1)  # Mirror image so it feels natural
    frame_height, frame_width, _ = img.shape
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

    # STEP 2: THINK - Process the frame with MediaPipe
    results = hands.process(img_rgb)

    # If a hand is found:
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            # Draw the skeleton on the frame so we can see it
            mp_draw.draw_landmarks(img, hand_landmarks, mp_hands.HAND_CONNECTIONS)

            # STEP 3: ACT - Move the mouse based on the index finger tip.
            index_finger = hand_landmarks.landmark[8]  # landmark #8 = index fingertip
            
            x = int(index_finger.x * frame_width)
            y = int(index_finger.y * frame_height)

            # Map webcam coordinates to screen coordinates
            mouse_x = np.interp(x, (0, frame_width), (0, screen_width))
            mouse_y = np.interp(y, (0, frame_height), (0, screen_height))

            # Smooth the values to reduce jitter (The "Professional Feel")
            clocX = plocX + (mouse_x - plocX) / SMOOTHING
            clocY = plocY + (mouse_y - plocY) / SMOOTHING

            # Move the actual mouse cursor
            pyautogui.moveTo(clocX, clocY)

            plocX, plocY = clocX, clocY  # Update previous location

    # Show the webcam feed with overlay
    cv2.imshow("AI Mouse Controller", img)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):  # Quit on 'q' key
        break

# Cleanup
cap.release()
cv2.destroyAllWindows()

Ce programme​‍​‌‍​‍‌ répète continuellement le même processus en trois étapes à chaque image : VOIR, PENSER, AGIR. Dans un premier temps, il récupère une image de la webcam. Ensuite, il applique MediaPipe pour identifier la main et dessiner les repères. Enfin, le code accède à la position du bout de l’index (repère n°8) et l’applique pour déplacer le curseur ​‍​‌‍​‍‌.

Comme​‍​‌‍​‍‌ le cadre de la webcam et votre écran ont des systèmes de coordonnées distincts, nous transformons d’abord la position du bout du doigt en résolution totale de l’écran à l’aide de numpy.interp et invoque ensuite pyautogui.moveTo(x, y) pour déplacer le curseur. Pour améliorer la stabilité du mouvement, nous introduisons en outre une petite quantité de lissage (en prenant la moyenne des positions au fil du temps) pour réduire la gigue.

Le résultat

Exécutez​‍​‌‍​‍‌ le script via python ai_mouse.py. La fenêtre « AI Mouse Controller » apparaîtra et affichera l’activité de votre caméra. Mettez votre main devant la caméra et vous verrez un squelette coloré (articulations et connexions de la main) dessiné dessus. Ensuite, déplacez votre index et le curseur de la souris se déplacera en douceur sur votre écran en suivant le mouvement de votre doigt en temps réel.

Au début,​‍​‌‍​‍‌ cela semble étrange, un peu comme la télékinésie en quelque sorte. Cependant, en quelques secondes, cela devient familier. Le curseur se déplace exactement comme vous l’attendriez avec votre doigt en raison des effets d’interpolation et de lissage qui font partie du programme. Par conséquent, si le système est momentanément incapable de détecter votre main, le curseur peut rester immobile jusqu’à ce que la détection soit rétablie, mais en général, il est impressionnant de voir à quel point il fonctionne bien. (Si vous souhaitez quitter, appuyez simplement sur la touche q dans la fenêtre OpenCV ​‍​‌‍​‍‌.)

Conclusion : l’avenir des interfaces

Seulement environ 60 lignes de Python ont été écrites pour ce projet, mais il a pu démontrer quelque chose d’assez profond.

D’abord. nous étions limités aux cartes perforées, puis aux claviers et après cela aux souris. Maintenant, vous agitez simplement votre main et Python comprend cela comme une commande. Alors que l’industrie se concentre sur l’informatique spatiale, le contrôle gestuel n’est plus un avenir de science-fiction : il devient la réalité de la façon dont nous allons interagir avec les machines.

Ce prototype, bien sûr, ne semble pas (encore) prêt à remplacer votre souris pour le jeu compétitif. Mais cela nous a donné un aperçu de la façon dont l’IA comble le fossé entre intention et action disparaître.

Votre prochain défi : le clic « Pinch »

La prochaine étape logique consiste à passer d’une démo à un outil. Une fonction « clic » peut être mise en œuvre en détectant un geste de pincement :

• Mesurez la distance euclidienne entre le repère n°8 (pointe de l’index) et le repère n°4 (pointe du pouce).
• Lorsque la distance est inférieure à un seuil donné (par exemple 30 pixels), alors déclenchez pyautogui.click().

Allez-y, essayez-le. Créez quelque chose qui semble magique.

Connectons-nous

Si vous parvenez à construire cela, je serais ravi de le voir. N’hésitez pas à me contacter sur LinkedIn et envoie-moi un DM avec tes résultats. J’écris régulièrement sur des sujets qui couvrent Python, l’IA et le codage créatif ​‍​‌‍​‍‌Coding.

Références

• Mains MediaPipe (Google) : Modèle de détection de repères manuels et documentation
• Documentation OpenCV-Python : Outils de capture par webcam, de traitement d’image et de visualisation
• Documentation PyAutoGUI : API de contrôle programmatique du curseur et d’automatisation (moveTo, clicketc.)
• Documentation NumPy : numpy.interp() pour mapper les coordonnées de la webcam sur les coordonnées de l’écran
• Doug Engelbart et la souris d’ordinateur (contexte historique) : L’origine de la souris comme base d’interface moderne