von autonomen Fahrzeugen und KI-Sprachmodellen, doch die wichtigste physische Schnittstelle, über die wir uns mit Maschinen verbinden, ist seit fünfzig Jahren unverändert geblieben. Erstaunlicherweise verwenden wir zum Klicken und Ziehen immer noch die Computermaus, ein Gerät, das Doug Engelbart Anfang der 1960er Jahre entwickelt hat. Vor ein paar Wochen habe ich beschlossen, diese Norm durch die Programmierung in Python in Frage zu stellen.
Für Datenwissenschaftler und ML-Ingenieure ist dieses Projekt mehr als nur ein Partytrick – es ist eine Meisterklasse in angewandter Laptop Imaginative and prescient. Wir werden eine Echtzeit-Pipeline aufbauen, die einen unstrukturierten Videostream (Pixel) aufnimmt, sequentiell ein ML-Modell anwendet, um Merkmale (Handmarkierungen) zu extrahieren und sie schließlich in greifbare Befehle umwandelt (Bewegen des Cursors). Im Grunde ist dies ein „Hallo Welt“-Beispiel für die nächste Era der Mensch-Laptop-Interaktion.
Das Ziel? Steuern Sie den Mauszeiger einfach durch eine Handbewegung. Sobald Sie das Programm starten, wird in einem Fenster Ihr Webcam-Feed mit einem in Echtzeit überlagerten Handskelett angezeigt. Der Cursor auf Ihrem Laptop folgt der Bewegung Ihres Zeigefingers. Es ist quick wie Telekinese – Sie steuern ein digitales Objekt, ohne ein physisches Gerät zu berühren.
Das Konzept: Python das „Sehen“ beibringen
Um die physische Welt (meine Hand) mit der digitalen Welt (dem Mauszeiger) zu verbinden, haben wir beschlossen, das Downside in zwei Teile zu unterteilen: die Augen und das Gehirn.
- The Eyes – Webcam (OpenCV): Movies von der Kamera in Echtzeit zu erhalten, das ist der erste Schritt. Wir werden dafür OpenCV verwenden. OpenCV ist eine umfangreiche Laptop-Imaginative and prescient-Bibliothek, die es Python ermöglicht, auf Frames einer Webcam zuzugreifen und diese zu verarbeiten. Unser Code öffnet die Standardkamera mit
cv2.VideoCapture(0)und liest dann die Frames nacheinander weiter. - Das Gehirn – Hand-Landmark-Erkennung (MediaPipe): Um jeden Body zu analysieren, die Hand zu finden und die Schlüsselpunkte auf der Hand zu erkennen, haben wir uns an die MediaPipe Palms-Lösung von Google gewandt. Hierbei handelt es sich um ein vorab trainiertes Modell für maschinelles Lernen, das in der Lage ist, ein Bild einer Hand aufzunehmen und die Positionen von 21 3D-Markierungen (Gelenke und Fingerspitzen) einer Hand vorherzusagen. Um es einfach auszudrücken: MediaPipe-Hände „erkennen hier nicht nur eine Hand“, sondern zeigen Ihnen sogar genau, wo sich jede Fingerspitze und jeder Knöchel im Bild befindet. Sobald Sie diese Orientierungspunkte gefunden haben, ist die größte Herausforderung im Grunde genommen vorbei: Wählen Sie einfach den gewünschten Orientierungspunkt aus und verwenden Sie seine Koordinaten.
Im Grunde bedeutet das, dass wir jedes Kamerabild an MediaPipe übergeben, das die (x,y,z)-Koordinaten von 21 Punkten auf der Hand ausgibt. Um einen Cursor zu steuern, folgen wir der Place des Orientierungspunkts Nr. 8 (der Spitze des Zeigefingers). (Wenn wir das Klicken später implementieren würden, könnten wir den Abstand zwischen Orientierungspunkt Nr. 8 und Nr. 4 (Daumenspitze) überprüfen, um eine Einklemmung zu identifizieren.) Im Second sind wir nur an der Bewegung interessiert: Wenn wir die Place der Zeigefingerspitze finden, können wir diese ziemlich genau mit der Place des Mauszeigers in Verbindung bringen, an die er sich bewegen soll.
Die Magie von MediaPipe
MediaPipe Palms kümmert sich um die anspruchsvollen Teile der Handerkennung und Orientierungspunktschätzung. Die Lösung nutzt maschinelles Lernen, um 21 Handmarkierungen aus nur einem Bildrahmen vorherzusagen.
Darüber hinaus ist es vorab trainiert (tatsächlich anhand von mehr als 30.000 Handbildern), was bedeutet, dass wir unser Modell nicht trainieren müssen. Wir holen uns einfach das Hand-Monitoring-„Gehirn“ von MediaPipe in Python:
mp_hands = mp.options.arms
arms = mp_hands.Palms(max_num_hands=1, min_detection_confidence=0.7)Additionally danach wird jedes Mal ein neuer Body gesendet arms.course of()gibt es eine Liste der erkannten Hände zusammen mit ihren 21 Orientierungspunkten zurück. Wir rendern sie auf dem Bild, damit wir visuell überprüfen können, ob es funktioniert. Das Entscheidende ist, dass wir für jede Hand erhalten können hand_landmarks.landmark(i) für i von 0 bis 20, jeweils mit normalisierten (x, y, z)-Koordinaten. Konkret ist die Spitze des Zeigefingers der Orientierungspunkt (8) und die Spitze des Daumens der Orientierungspunkt (4). Durch die Verwendung von MediaPipe sind wir bereits von der anspruchsvollen Aufgabe entlastet, die Geometrie der Handhaltung herauszufinden.
Das Setup
Dafür benötigen Sie keinen Supercomputer – ein typischer Laptop computer mit Webcam reicht aus. Installieren Sie einfach diese Python-Bibliotheken:
pip set up opencv-python mediapipe pyautogui numpy- opencv-python: Verwaltet den Webcam-Video-Feed. Mit OpenCV können wir Frames in Echtzeit erfassen und in einem Fenster anzeigen.
- Medienpipe: Stellt das Hand-Monitoring-Modell (MediaPipe Palms) bereit. Es erkennt die Hand und gibt 21 Orientierungspunkte zurück.
- pyautogui: Eine plattformübergreifende GUI-Automatisierungsbibliothek. Wir werden es verwenden, um den eigentlichen Mauszeiger auf unserem Bildschirm zu bewegen. Zum Beispiel,
pyautogui.moveTo(x, y)Bewegt den Cursor sofort an die Place(x, y). - Numpy: Wird für numerische Operationen verwendet, hauptsächlich zum Zuordnen von Kamerakoordinaten zu Bildschirmkoordinaten. Wir verwenden
numpy.interpum Werte von der Webcam-Rahmengröße auf die volle Bildschirmauflösung zu skalieren.
Jetzt ist unsere Umgebung bereit und wir können die vollständige Logik in eine einzige Datei schreiben (z. B. ai_mouse.py).
Der Kodex
Die Kernlogik ist bemerkenswert prägnant (weniger als 60 Zeilen). Hier ist das vollständige Python-Skript:
import cv2
import mediapipe as mp
import pyautogui
import numpy as np
# --- CONFIGURATION ---
SMOOTHING = 5 # Larger = smoother motion however extra lag.
plocX, plocY = 0, 0 # Earlier finger place
clocX, clocY = 0, 0 # Present finger place
# --- INITIALIZATION ---
cap = cv2.VideoCapture(0) # Open webcam (0 = default digital camera)
mp_hands = mp.options.arms
# Observe max 1 hand to keep away from confusion, confidence threshold 0.7
arms = mp_hands.Palms(max_num_hands=1, min_detection_confidence=0.7)
mp_draw = mp.options.drawing_utils
screen_width, screen_height = pyautogui.measurement() # Get precise display screen measurement
print("AI Mouse Lively. Press 'q' to stop.")
whereas True:
# STEP 1: SEE - Seize a body from the webcam
success, img = cap.learn()
if not success:
break
img = cv2.flip(img, 1) # Mirror picture so it feels pure
frame_height, frame_width, _ = img.form
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# STEP 2: THINK - Course of the body with MediaPipe
outcomes = arms.course of(img_rgb)
# If a hand is discovered:
if outcomes.multi_hand_landmarks:
for hand_landmarks in outcomes.multi_hand_landmarks:
# Draw the skeleton on the body so we are able to see it
mp_draw.draw_landmarks(img, hand_landmarks, mp_hands.HAND_CONNECTIONS)
# STEP 3: ACT - Transfer the mouse primarily 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 display screen coordinates
mouse_x = np.interp(x, (0, frame_width), (0, screen_width))
mouse_y = np.interp(y, (0, frame_height), (0, screen_height))
# Clean the values to cut back jitter (The "Skilled Really feel")
clocX = plocX + (mouse_x - plocX) / SMOOTHING
clocY = plocY + (mouse_y - plocY) / SMOOTHING
# Transfer the precise mouse cursor
pyautogui.moveTo(clocX, clocY)
plocX, plocY = clocX, clocY # Replace earlier location
# Present the webcam feed with overlay
cv2.imshow("AI Mouse Controller", img)
if cv2.waitKey(1) & 0xFF == ord('q'): # Give up on 'q' key
break
# Cleanup
cap.launch()
cv2.destroyAllWindows()Dieses Programm wiederholt kontinuierlich den gleichen dreistufigen Prozess in jedem Body: SEHEN, DENKEN, HANDELN. Zunächst wird ein Bild von der Webcam aufgenommen. Anschließend wird MediaPipe angewendet, um die Hand zu identifizieren und die Orientierungspunkte zu zeichnen. Schließlich greift der Code auf die Place der Zeigefingerspitze (Markierung Nr. 8) zu und wendet sie zum Bewegen des Cursors an.
Da der Webcam-Rahmen und Ihr Show unterschiedliche Koordinatensysteme haben, transformieren wir zunächst die Fingerspitzenposition mithilfe von auf die gesamte Bildschirmauflösung numpy.interp und anschließend aufrufen pyautogui.moveTo(x, y) um den Cursor zu verschieben. Um die Stabilität der Bewegung zu verbessern, führen wir zusätzlich eine kleine Glättung ein (unter Berücksichtigung des Durchschnitts der Positionen über die Zeit), um den Jitter zu verringern.
Das Ergebnis
Führen Sie das Skript durch python ai_mouse.py. Das Fenster „AI Mouse Controller“ öffnet sich und zeigt Ihre Kameraaktivität an. Halten Sie Ihre Hand vor die Kamera und Sie sehen ein darüber eingezeichnetes farbiges Skelett (Handgelenke und Verbindungen). Bewegen Sie dann Ihren Zeigefinger, und der Mauszeiger bewegt sich sanft über Ihren Bildschirm und folgt Ihrer Fingerbewegung in Echtzeit.
Zunächst kommt es seltsam vor – in gewisser Weise ganz wie Telekinese. Doch innerhalb von Sekunden wird es vertraut. Aufgrund der Interpolations- und Glättungseffekte, die Teil des Programms sind, bewegt sich der Cursor genau so, wie Sie es von Ihrem Finger erwarten würden. Wenn das System Ihre Hand vorübergehend nicht erkennen kann, kann es sein, dass der Cursor nonetheless bleibt, bis er wieder erkannt wird, aber im Großen und Ganzen ist es beeindruckend, wie intestine es funktioniert. (Wenn Sie gehen möchten, drücken Sie einfach die q-Style im OpenCV-Fenster.)
Fazit: Die Zukunft der Schnittstellen
Für dieses Projekt wurden nur etwa 60 Zeilen Python geschrieben, aber es konnte etwas recht Tiefgründiges demonstrieren.
Erste. Wir beschränkten uns auf Lochkarten, dann auf Tastaturen und schließlich auf Mäuse. Jetzt winken Sie einfach mit der Hand und Python versteht das als Befehl. Da sich die Branche auf räumliches Computing konzentriert, ist die gestenbasierte Steuerung keine Science-Fiction-Zukunft mehr – sie wird zur Realität, wie wir mit Maschinen interagieren werden.
Dieser Prototyp scheint natürlich (noch) nicht bereit zu sein, Ihre Maus für Wettkampfspiele zu ersetzen. Aber es hat uns einen Einblick gegeben, wie KI die Lücke dazwischen schließt Absicht Und Aktion verschwinden.
Ihre nächste Herausforderung: Der „Pinch“-Klick
Der logische nächste Schritt besteht darin, dies von einer Demo in ein Instrument umzuwandeln. Durch die Erkennung einer Pinch-Geste kann eine „Klick“-Funktion implementiert werden:
- Messen Sie den euklidischen Abstand zwischen Orientierungspunkt Nr. 8 (Indexspitze) und Orientierungspunkt Nr. 4 (Daumenspitze).
- Wenn der Abstand kleiner als ein bestimmter Schwellenwert (z. B. 30 Pixel) ist, wird ausgelöst
pyautogui.click on().
Probieren Sie es einfach aus. Machen Sie etwas, das wie Magie wirkt.
Lassen Sie uns verbinden
Wenn Sie es schaffen, das zu bauen, würde ich mich freuen, es zu sehen. Nehmen Sie gerne Kontakt mit mir auf LinkedIn und schick mir eine DM mit deinen Ergebnissen. Ich schreibe regelmäßig über Themen wie Python, KI und kreatives Coding.
Referenzen
- MediaPipe-Hände (Google): Modell und Dokumentation zur Erkennung von Handmarkierungen
- OpenCV-Python-Dokumentation: Instruments zur Webcam-Erfassung, Bildverarbeitung und Visualisierung
- PyAutoGUI-Dokumentation: Programmatische Cursorsteuerungs- und Automatisierungs-APIs (
moveTo,click onusw.) - NumPy-Dokumentation:
numpy.interp()zum Zuordnen von Webcam-Koordinaten zu Bildschirmkoordinaten - Doug Engelbart und die Computermaus (Historischer Kontext): Der Ursprung der Maus als moderne Schnittstellenbasis