Effiziente Schätzung der menschlichen Haltung

Einführung

Im Bereich des Computervisions ist die Schätzung der menschlichen Haltung als faszinierendes Feld mit Anwendungen, die sich von erhöhter Realität und Spielen bis hin zu mechanischer Autonomie und Gesundheitsversorgung erstrecken. Dieser Artikel beleuchtet die Komplexität der Schätzung der menschlichen Haltung, seine Bedeutung, ihre grundlegenden Fortschritte und auffällige Anwendungen.

Die Haltungsschätzung, ein faszinierendes Feld im Computer Vision, umfasst das Erkennen von Key -Fokus auf den Körper einer Person, um ihn zu erhalten und ihre Pose zu analysieren. Unser Ziel ist es, diese Innovation in den Domäne des Yoga zu bringen und es uns ermöglicht, Yoga -Haltungen aus Bildern zu erkennen und zu klassifizieren.

Lernziel

• Erhalten Sie ein tiefes Verständnis der Prinzipien der menschlichen Pose -Schätzung und deren Bedeutung im Computer Vision.
• Verschaffen Sie, wie die Technologie der menschlichen Pose-Schätzung die Yoga-Praxis durch personalisierte Anleitung und Echtzeit-Feedback verbessert.
• Entwickeln Sie praktische Fähigkeiten bei der Implementierung von Algorithmen für menschliche Pose -Schätzungen für Yoga -Anwendungen mithilfe von Python und relevanten Bibliotheken.

Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.

Inhaltsverzeichnis

• Schätzung der menschlichen Pose verstehen
• Bottom-up vs. Top-Down-Methoden der Posenschätzung
• Beliebte Bibliotheken und Tools
• Verbesserte Schätzung der menschlichen Pose: Ein einfacher und effizienter Ansatz
• Anwendungen der menschlichen Poseschätzung
• Häufig gestellte Fragen

Schätzung der menschlichen Pose verstehen

Die Schätzung der menschlichen Pose ist eine Computer -Vision -Aufgabe, die die Ausrichtung einer Person grafisch darstellt. Diese Technik, die modellbasierte Ansätze nutzt, identifiziert und klassifiziert Posen von menschlichen Körperteilen und Gelenken in Bildern oder Videos. Der Schlüssel liegt darin, eine Reihe von Koordinaten zu erfassen, die Gelenke wie Handgelenke, Schultern und Knie definieren, die gemeinsam die Pose einer Person beschreiben.

Bedeutung der menschlichen Poseschätzung

Die Erkennung von Menschen hat sich mit Algorithmen für maschinelles Lernen entwickelt und es Computern ermöglicht, die menschliche Körpersprache durch Erkennung und Verfolgung von Posen zu verstehen. Diese Technologie ist kommerziell tragfähig geworden und wirkt sich auf verschiedene Branchen wie Sicherheit, Business Intelligence, Gesundheit und Sicherheit und Unterhaltung aus. Insbesondere in der Zeit der Coronavirus-Pandemie hilft die Erkennung von Echtzeit-Posen bei der Umsetzung sozialer Distanzierungsmaßnahmen.

Kontrast zwischen 2D- und 3D -Schätzung der menschlichen Haltung

Zwei Hauptmethoden sind 2D -Haltungsschätzungen und 3D -Haltungsschätzung. Die vorherigen Messgeräte der Körperverbindungen im 2D-Raum, während das letzte erwähnte ein 2D-Bild in einen 3D-Protest verwandelt, indem er eine zusätzliche Z-Dimension erwartet. Die 3D -Pose -Schätzung ermöglicht zwar herausfordernd eine genaue räumliche Positionierung in Darstellungen.

Arten von menschlichen Posenschätzungsmodellen

Die Modelle der Human -Pose -Schätzung fallen in drei Haupttypen:

• Skelettbasiertes Modell: Repräsentiert die Skelettstruktur, die sowohl für die 3D- als auch für die 2D-Posenschätzung verwendet wird.
• Konturbasiertes Modell: Konzentriert sich auf die Schätzung von 2D-Posen und betont das Erscheinungsbild und die Form des Körpers.
• Volumenbasierter Modell: Verwendet für die 3D-Pose-Schätzung 3D-menschliche Körpermodelle und -posen.

Bottom-up vs. Top-Down-Methoden der Posenschätzung

Methoden zur Schätzung der menschlichen Pose werden weitgehend in zwei Ansätze eingeteilt: Bottom-up und Top-Down. Bottom-up bewertet jedes Körpergelenk einzeln, während Top-Down zuerst einen Körperdetektor verwendet und die Gelenke in entdeckten Begrenzungsboxen bestimmt.

Das Verständnis der Funktionsweise der menschlichen Posenschätzung beinhaltet das Eintauchen in die Grundstruktur, die Modellarchitekturübersicht und verschiedene Ansätze zur Pose -Schätzung. Der Prozess umfasst die absolute Posenschätzung, die relative Pose -Schätzung und deren Kombination.

Beliebte Bibliotheken und Tools

Mehrere Open-Source-Bibliotheken ermöglichen die Schätzung der menschlichen Pose:

• Eröffnung: Ein mehrköpfiges System, das die Schätzung der 2D- und 3D-Pose unterstützt.
• Poededetektion: Auf TensorFlow.js aufgebaut und bietet Echtzeit-Pose-Schätzmodelle.
• Dichtung: Karten menschliche Pixel von 2D-RGB-Bildern zu einem 3D-oberflächenbasierten Modell.
• Alphapose: Eine Echtzeit-Bibliothek für Multi-Personen-Posenschätzungsbibliothek mit einem Top-Down-Ansatz.
• HRNET (hochauflösendes Netz): Geeignet für die Vorhersage der Hitzemap-Hitzezeit mit hoher Genauigkeit.

Verbesserte Schätzung der menschlichen Pose: Ein einfacher und effizienter Ansatz

Beginnen wir nun mit dem einfachen menschlichen Pose -Schätzcode, indem wir bestimmte Schritte befolgen.

Schritt 1: Festlegen der Bühne

Um unsere Reise zu beginnen, müssen wir unsere Umgebung einrichten, indem wir die erforderlichen Bibliotheken installieren. OpenCV, Numpy und MediaPipe sind für unser Projekt unerlässlich. Führen Sie den folgenden Befehl aus, um sie zu installieren:

 ! PIP Installation OpenCV-Python MediaPipe

Wir haben MediaPipe in diesem Artikel vorgestellt, ein von Google entwickeltes Open-Source-Framework für die Erstellung von Pipelines für maschinelles Lernen, die sich auf Computer Vision-Aufgaben konzentrieren. MediaPipe vereinfacht die Implementierung komplexer visueller Anwendungen und bietet vorgebreitete Modelle für die Schätzung des menschlichen Posens, die mit minimalem Aufwand integriert werden können. Die plattformübergreifende Fähigkeit sorgt für eine konsistente Leistung auf mobilen Geräten, Webanwendungen und Desktops, während sein Design für die Echtzeitverarbeitung eine schnelle Videoeingabebuchanalyse ermöglicht.

Schritt 2: Importierende Bibliothek importieren

 Mathematik importieren
CV2 importieren
Numph als NP importieren
zum Zeitpunkt der Zeit
MediaPipe als MP importieren
matplotlib.pyplot als pLT importieren
von ipython.display import HTML

• `math`: Bietet mathematische Funktionen für Berechnungen.
• `CV2`: OpenCV -Bibliothek für Computer -Vision -Aufgaben wie Bildmanipulation und Verarbeitung.
• `numpy as NP`: Numpy Library für numerisches Computing mit Unterstützung für Arrays und Matrizen.
• `time`: Modul für die Arbeit mit der Zeit, die hier zur Messung der Ausführungszeit verwendet wird.
• `MediaPipe as MP`: Mediapipe Framework zum Erstellen von Wahrnehmungspipelines für verschiedene Medientypen.
• `Matplotlib.pyplot als PLT`: Matplotlib -Bibliothek zum Erstellen von Diagrammen und Visualisierungen.
• `Ipython.display import html`: ipython -Modul zum Anzeigen von HTML -Inhalten im Notebook.

Schritt 3: Initialze MediaPipe -Paket

Richten Sie die Pose- und Zeichnen von Versorgungsunternehmen von MediaPipe zur Erkennung und Visualisierung von Pose ein.

 # Initialisieren von MediaPipe Pose Class.
mp_pin = mp.Solutions.ple

# Einrichten der Pose -Funktion.
pose = mp_pose.ple (static_image_mode = true, min_detion_confidence = 0,3, model_complexity = 2)

# Initialisieren von MediaPipe -Zeichenklassen, nützlich für Annotation.
mp_drawing = mp.Solutions.drawing_utils

• Diese Zeilen initialisieren die erforderlichen Komponenten aus dem Mediapipe -Framework, um Pose -Schätzaufgaben auszuführen.
• mp_pin = mp.Solutions.pose initialisiert die MediaPipe Pose -Klasse und ermöglicht die Funktionalität der Pose -Schätzung.
• pose = mp_pose.ple (static_image_mode = true, min_detion_confidence = 0.3, model_complexity = 2) setzt die Pose -Funktion mit spezifischen Parametern wie dem statischen Bildmodus, dem minimalen Erkennungsvertrauen und der Modellkomplexität ein.
• mp_drawing = mp.Solutions.drawing_utils initialisiert die Klasse von MediaPipe Drawing Utilities, die Funktionen zum Anmerkungsbildern mit Sehenswürdigkeiten und Verbindungen bietet, wodurch die Visualisierung der Posenschätzergebnisse erleichtert werden.

Schritt 4: Bild laden und anzeigen

Verwenden Sie OpenCV, um ein Bild und ein Matplotlib zu laden, um es anzuzeigen.

 Sample_img = cv2.imread ('/content/iStockphoto-664637378-612x612.jpg'))
PLT.Figure (AbbSize = [10,10])
Plt.title ("sample_image")
PLT.AXIS ('OFF')
Plt.imshow (Sample_img [::, ::-1]); PLT.Show ()

• Dieses Codesegment lädt ein Beispielbild aus einem angegebenen Dateipfad unter Verwendung der OpenCV -Bibliothek (cv2.imread ()).
• Anschließend wird Matplotlib verwendet, um das geladene Bild in einer Figur mit einer angegebenen Größe (Plt.Abg. (AbbSize = [10, 10]), Titel (PLT.TITLE („Probenbild“)) und ohne Achsenzicks (PLT.AXIS ('Off') anzuzeigen.
• Das Bild wird schließlich mit der Funktion plt.imshow () gezeigt, die das Bild in der angegebenen Abbildung anzeigt. Die [:,:, ::-1] Indexierung wird verwendet, um das Bild von BGR in das RGB-Format zu konvertieren, wie Matplotlib RGB-Bilder für die Anzeige erwartet.

Schritt 5: Erkennende und drucken Sehenswürdigkeiten

Konvertieren Sie das Bild in RGB und verwenden Sie MediaPipe, um Pose -Sehenswürdigkeiten zu erkennen. Drucken Sie die ersten beiden erkannten Sehenswürdigkeiten (z. B. Nase, links_eye_inner).

Tastoint_identification

keypoint_landmark

 # Führen Sie die Pose -Erkennung durch, nachdem Sie das Bild in das RGB -Format konvertiert haben.
Ergebnisse = Pose.Process (cv2.cvtcolor (Sample_img, cv2.color_bgr2rgb))

# Überprüfen Sie, ob Orientierungspunkte gefunden werden.
Wenn results.ple_landmarks:
    
    # Iterieren Sie zweimal, da wir nur die ersten beiden Sehenswürdigkeiten anzeigen möchten.
    für i im Bereich (2):
        
        # Zeigen Sie die gefundenen normalisierten Sehenswürdigkeiten an.
        print (f

• Dieses Codesegment führt eine Pose -Erkennung auf dem Beispielbild durch, nachdem es mithilfe von OpenCVs CV2.CVTColor () -Funktion in das RGB -Format konvertiert wurde.
• Es prüft dann, ob im Bild das Attribut von Ergebnissen.
• Wenn Sehenswürdigkeiten gefunden werden, iteriert sie die ersten beiden Sehenswürdigkeiten und druckt ihre Namen und Koordinaten.
• Der wegweisende Name wird mit MP_POSE.Poselandmark (i) .Name erhalten, und auf die Koordinaten werden unter Verwendung von results.pin_landmarks.landmark [MP_POSE.POSELANDMARK (I) .VALUE] zugegriffen.

Ausgabe:

 NASE:
X: 0,7144814729690552
Y: 0,3049055337905884
Z: -0.1483774036169052
Sichtbarkeit: 0,9999918937683105
Links_eye_innerer:
X: 0,7115224599838257
Y: 0,2835153341293335
Z: -0.13594578206539154
Sichtbarkeit: 0,9999727010726929

Schritt6: Zeichnen Sie Orientierungspunkte auf Bild

Erstellen Sie eine Kopie des Bildes, zeichnen Sie erkannte Orientierungspunkte mit MediaPipe -Dienstprogrammen und zeigen Sie es an.

 # Erstellen Sie eine Kopie des Beispielbildes, um Sehensmarke zu zeichnen.
img_copy = sample_img.copy ()

# Überprüfen Sie, ob Orientierungspunkte gefunden werden.
Wenn results.ple_landmarks:
    
    # Zeichnen Sie Pose -Sehenswürdigkeiten auf das Beispielbild.
    mp_drawing.draw_landmarks (Image = img_copy, Landmark_List = results.ple_landmarks, Connections = MP_POPS.PLE.CONNEctions)
       
    # Geben Sie eine Größe der Abbildung an.
    Abb = PLT.Figure (AbbSize = [10, 10])

    # Zeigen Sie das Ausgabebild mit den gezogenen Landmarken an und wandeln Sie auch BGB in RGB um. 
    PLT.TITLE ("Ausgabe")
    PLT.AXIS ('OFF')
    plt.imshow (img_copy [:,:, ::-1])
    Plt.Show ()

• In diesem Codesegment wird eine Kopie des Beispielbildes erstellt, um das Originalbild zu erhalten, während die Wahrzeichen auf einem separaten Bild zeichnet.
• Es prüft, ob in den Ergebnissen Pose -Orientierungspunkte gefunden werden.
• Wenn Orientierungspunkte gefunden werden, zeichnet es die Wahrzeichen des kopierten Bildes mit MP_DRAWING.DRAW_LANDMARKS ().
• Die Größe der Abbildung zur Anzeige des Ausgabebildes wird unter Verwendung von PLT.Figure angegeben (Abbisze = [10, 10]).
• Schließlich wird das Ausgabebild mit den mit PLT.IMSHOW () gezeichneten Wahrzeichen angezeigt. Die [:,:, ::-1] Indexierung wird verwendet, um das Bild von BGR in das RGB-Format für eine ordnungsgemäße Anzeige mit Matplotlib zu konvertieren.

Schritt 7: 3D -Pose -Visualisierung

Verwenden Sie die Plot_landmarks () von MediaPipe, um die erkannten Sehenswürdigkeiten in 3D zu visualisieren.

 # Grundstück posieren Sehenswürdigkeiten in 3D.
MP_DRAWING.PLOT_LANDMARKS (results.pin_world_landmarks, MP_POPS.POLE_CONNEctions)

• Dieses Codesegment zeigt die Pose -Orientierungspunkte im 3D -Raum mit der Funktion von MediaPipe von Plot_landmarks ().
• Es dauert als Eingabe, was die Pose -Wahrzeichen in Weltkoordinaten darstellt.
• MP_POPS.POLE_CONNEctions gibt die Verbindungen zwischen verschiedenen Sehenswürdigkeiten an und beiträgt dazu, die Skelettstruktur zu visualisieren.

Schritt 8: Benutzerdefinierte Erkennungsfunktion

Für die kundenspezifische Pose -Erkennung verwenden wir DetectPose (). Diese Funktion führt die Erkennung von Posen durch, zeigt Ergebnisse an und gibt optional Sehenswürdigkeiten zurück.

 Def Detectpose (Bild, Pose, Display = True):
    '' ''
    Diese Funktion führt eine Pose -Erkennung auf einem Bild durch.
    Args:
        Bild: Das Eingabebild mit einer prominenten Person, deren Pose -Orientierungspunkte erkannt werden müssen.
        Pose: Die Pose -Setup -Funktion, die zur Durchführung der Pose -Erkennung erforderlich ist.
        Anzeige: Ein boolescher Wert, der auf true festgelegt ist, zeigt das ursprüngliche Eingabebild, das resultierende Bild, 
                 und die Pose -Sehenswürdigkeiten im 3D -Grundstück und gibt nichts zurück.
    Rückgaben:
        output_image: Das Eingabebild mit den erkannten Pose -Sehenswürdigkeiten gezeichnet.
        Sehenswürdigkeiten: Eine Liste der erkannten Sehenswürdigkeiten, die in ihre ursprüngliche Skala umgewandelt wurden.
    '' ''
    
    # Erstellen Sie eine Kopie des Eingabebildes.
    output_image = image.copy ()
    
    # Konvertieren Sie das Bild von BGR in das RGB -Format.
    ImageGb = cv2.cvtcolor (Bild, cv2.color_bgr2rgb)
    
    # Führen Sie die Pose -Erkennung durch.
    Ergebnisse = Pose.Process (Impergb)
    
    # Rufen Sie die Höhe und Breite des Eingabebildes ab.
    Höhe, Breite, _ = Bild.Shape
    
    # Initialisieren Sie eine Liste, um die erkannten Wahrzeichen zu speichern.
    Sehenswürdigkeiten = []
    
    # Überprüfen Sie, ob Orientierungspunkte festgestellt werden.
    Wenn results.ple_landmarks:
    
        # Zeichnen Sie Pose -Sehenswürdigkeiten auf dem Ausgangsbild.
        MP_DRAWING.DRAW_LANDMARKS (Image = output_image, Landmark_List = results.pin_landmarks,
                                  connections = mp_pose.ple_connections)
        
        # Über die erkannten Sehenswürdigkeiten wiederholen.
        Für das Landmark in Ergebnissen.PILE_LANDMARKS.LANDMARK:
            
            # Das Wahrzeichen in die Liste anhängen.
            Landmarks.Append ((int (Landmark.x * Breite), int (Landmark.y * Höhe),
                                  (Landmark.z * Breite))))
    
    # Überprüfen Sie, ob das ursprüngliche Eingabebild und das resultierende Bild angegeben sind, um angezeigt zu werden.
    Wenn Anzeige:
    
        # Zeigen Sie das ursprüngliche Eingabebild und das resultierende Bild an.
        PLT.Figure (AbbSize = [22,22])
        Plt.Subplot (121); Plt.imshow (Bild [::, ::-1]); Plt.title ("Originalbild"); PLT.AXIS ('OFF');
        plt.subplot (122); plt.imshow (output_image [:,: ::-1]); plt.title ("Ausgabebild"); PLT.AXIS ('OFF');
        
        # Zeichnen Sie auch die Pose -Sehenswürdigkeiten in 3D.
        MP_DRAWING.PLOT_LANDMARKS (results.pin_world_landmarks, MP_POPS.POLE_CONNEctions)
        
    # Ansonsten
    anders:
        
        # Geben Sie das Ausgangsbild und die gefundenen Orientierungspunkte zurück.
        Return Output_image, Wahrzeichen

• Diese Funktion detekte () führt eine Pose -Erkennung auf einem Eingabebild mithilfe des Pose -Modells von MediaPipe durch.
• Es dauert drei Parameter: Bild (das Eingabebild), Pose (die Pose -Setup -Funktion) und Anzeige (ein Boolescher Angabe, ob die Ergebnisse angezeigt werden).
• Es kopiert das Eingabebild, um das Original zu erhalten, und konvertiert das Bild von BGR in das RGB -Format, wie von MediaPipe erforderlich.
• Es erkennt Posen auf dem konvertierten Bild und zeichnet die erkannten Orientierungspunkte auf dem Ausgangsbild mit MP_DRAWING.DRAW_LANDMARKS ().
• Die Funktion holt auch die Höhe und Breite des Eingabebildes und initialisiert eine leere Liste, um die erkannten Sehenswürdigkeiten zu speichern.
• Wenn der Anzeigeparameter auf TRUE eingestellt ist, wird das ursprüngliche Eingangsbild, das Ausgabebild mit gezogenen Landmarken angezeigt und die Wahrzeichen im 3D -Raum unter Verwendung von MP_DRAWING.PLOT_LANDMARKS () plant.
• Wenn die Anzeige falsch ist, gibt es das Ausgabebild mit gezeichneten Orientierungspunkten und der erkannten Wahrzeichenliste zurück.

Schritt 9: Beispielausführung

Laufen Sie die Pose -Erkennung auf einem neuen Probenbild mit der Funktion DetectPose ().

 # Lesen Sie ein anderes Beispielbild und führen Sie die Pose -Erkennung durch.
Image = cv2.imread ('/content/hd-wallpaper-yoga-training-gy-poses-woman-yoga-exercises.jpg'))
Nachweis (Bild, Pose, Anzeige = True)

• In diesem Codesegment wird ein weiteres Beispielbild aus dem angegebenen Dateipfad gelesen.
• Anschließend ruft die Funktion "DetectPose () auf, um die Pose -Erkennung auf dem Bild mit dem zuvor initialisierten Pose -Setup durchzuführen.
• Das Einstellen des Anzeigeparameters in true lenkt die Funktion, um das ursprüngliche Eingabebild, das resultierende Bild mit gezogenen Wahrzeichen und das 3D -Diagramm von Sehenswürdigkeiten anzuzeigen.

Schritt 10: Pose -Klassifizierung (optional)

Der nächste Schritt besteht darin, eine Funktion zur Klassifizierung von Posen wie Krieger, Baum usw. zu definieren, basierend auf gemeinsamen Winkeln.

Kriegerpose, T-Pose, Baumpose, unbekannt

 DEF Classifypose (Sehenswürdigkeiten, output_image, display = false):
    '' ''
    Diese Funktion klassifiziert Yoga -Posen in Abhängigkeit von den Winkeln verschiedener Körperverbindungen.
    Args:
        Sehenswürdigkeiten: Eine Liste der erkannten Sehenswürdigkeiten der Person, deren Pose klassifiziert werden muss.
        output_image: Ein Bild der Person mit den erkannten Pose -Sehenswürdigkeiten gezeichnet.
        Anzeige: Ein boolescher Wert, der auf true festgelegt ist, zeigt das resultierende Bild mit der Pose -Etikett an 
        geschrieben und gibt nichts zurück.
    Rückgaben:
        Output_image: Das Bild mit den erkannten Pose -Sehenswürdigkeiten, die geschrieben wurden.
        Etikett: Die klassifizierte Pose -Etikett der Person in der output_image.

    '' ''
    
    # Initialisieren Sie das Etikett der Pose. Es ist zu diesem Zeitpunkt nicht bekannt.
    Label = 'Unbekannte Pose'

    # Geben Sie die Farbe (rot) an, mit der das Etikett auf das Bild geschrieben wird.
    Farbe = (0, 0, 255)
    
    # Berechnen Sie die erforderlichen Winkel.
    #----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    
    # Holen Sie sich den Winkel zwischen der linken Schulter-, Ellbogen- und Handgelenkpunkte. 
    links_elbow_angle = calculateangle (Landmarken [MP_POSE.POSELANDMARK.LEFT_SHOLDER.VALUE],
                                      Sehenswürdigkeiten [mp_pose.poselandmark.left_elbow.value],
                                      Sehenswürdigkeiten [mp_pose.poselandmark.left_wrist.value])
    
    # Holen Sie sich den Winkel zwischen der rechten Schulter-, Ellbogen- und Handgelenkpunkte. 
    right_elbow_angle = calculateangle (Landmarks [MP_POSE.Poselandmark.right_Shoulder.Value],
                                       Sehenswürdigkeiten [MP_POSE.POSELANDMARK.RIGHT_ELBOW.VALUE],
                                       Sehenswürdigkeiten [MP_POLE.POSELANDMARK.RIGHT_WRIST.VALUE])   
    
    # Holen Sie sich den Winkel zwischen dem linken Ellbogen, Schulter und Hüftpunkten. 
    links_shoulder_angle = calculateangle (Landmarks [MP_POSE.Poselandmark.left_elbow.value],
                                         Sehenswürdigkeiten [MP_POSE.POSELANDMARK.LEFT_SHOLDER.VALUE],
                                         Sehenswürdigkeiten [MP_POLE.POSELANDMARK.LEFT_HIP.VALUE])

    # Holen Sie sich den Winkel zwischen der rechten Hüft-, Schulter- und Ellbogenpunkte. 
    right_shoulder_angle = calculateangle (Landmarks [MP_POSE.Poselandmark.right_hip.value],
                                          Sehenswürdigkeiten [mp_pose.poselandmark.right_Shoulder.Value],
                                          Sehenswürdigkeiten [MP_POLE.POSELANDMARK.RIGHT_ELBOW.VALUE])

    # Holen Sie sich den Winkel zwischen der linken Hüft-, Knie- und Knöchelpunkte. 
    links_knee_angle = calculateangle (Landmarken [MP_POSE.POSELANDMARK.LEFT_HIP.VALUE],
                                     Sehenswürdigkeiten [mp_pose.poselandmark.left_knee.value],
                                     Sehenswürdigkeiten [mp_pose.poselandmark.left_ankle.value])

    # Holen Sie sich den Winkel zwischen den rechten Hüft-, Knie- und Knöchelpunkten 
    right_knee_angle = calculateangle (Landmarks [MP_POSE.Poselandmark.right_hip.value],
                                      Sehenswürdigkeiten [MP_POLE.POSELANDMARK.RIGHT_KNEE.VALUE],
                                      Sehenswürdigkeiten [mp_pose.poselandmark.right_ankle.Value])
    
    #----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    
    # Überprüfen Sie, ob es sich um die Warrior II -Pose oder die T -Pose handelt.
    # Bei beiden sollten beide Arme gerade sein und die Schultern sollten sich im spezifischen Winkel befinden.
    #----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    
    # Überprüfen Sie, ob beide Arme gerade sind.
    If links_elbow_angle> 165 und links_elbow_angle  165 und right_elbow_angle  80 und links_shoulder_angle  80 und right_shoulder_angle  165 und links_knee_angle  165 und right_knee_angle  90 und links_knee_angle  90 und right_knee_angle  160 und links_knee_angle  160 und right_knee_angle  165 und links_knee_angle  165 und right_knee_angle  315 und links_knee_angle  25 und right_knee_angle <p><img  src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/174433982947729.jpg" class="lazy" alt="Effiziente Schätzung der menschlichen Haltung" ></p><p><img  src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/174433983294618.jpg" class="lazy" alt="Effiziente Schätzung der menschlichen Haltung" ></p><p><img  src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/174433983446597.jpg" class="lazy" alt="Effiziente Schätzung der menschlichen Haltung" ></p><pre class="brush:php;toolbar:false"> # Lesen Sie ein Beispielbild und führen Sie eine Pose -Klassifizierung durch.
Bild = cv2.imread ('/content/amp-1575527028- Dreieck Pose.jpg')
output_image, Landmarken = Nachweis (Bild, Pose, Anzeige = Falsch)
Wenn Sehenswürdigkeiten:
    klassifypose (Landmarken, output_image, display = true)

• Dieses Codesegment liest ein Beispielbild aus dem angegebenen Dateipfad.
• Anschließend ruft die Funktion "DetectPose () auf, um die Pose -Erkennung auf dem Bild mit dem zuvor initialisierten Pose -Setup durchzuführen.
• Wenn der Anzeigeparameter falsch ist, überspringt die Funktion die Ergebnisse.
• Wenn das Bild erkannte Wahrzeichen enthält, ruft die Funktion Classifypose () auf, um die Pose basierend auf diesen Sehenswürdigkeiten zu klassifizieren und das Ergebnis anzuzeigen.

# Lesen Sie ein Beispielbild und führen Sie eine Pose -Klassifizierung durch.
Image = cv2.imread ('/content/Warrior2.jpg')
output_image, Landmarken = Nachweis (Bild, Pose, Anzeige = Falsch)
Wenn Sehenswürdigkeiten:
    klassifypose (Landmarken, output_image, display = true)

• Dieses Codesegment liest ein Beispielbild aus dem angegebenen Dateipfad.
• Anschließend ruft die Funktion "DetectPose () auf, um die Pose -Erkennung auf dem Bild mit dem zuvor initialisierten Pose -Setup durchzuführen.
• Der Anzeigeparameter ist auf False eingestellt, was angibt, dass die Funktion die Ergebnisse nicht anzeigen sollte.
• Wenn im Bild Orientierungspunkte festgestellt werden, ruft sie die Funktion Classifypose () auf, um die Pose basierend auf den erkannten Sehenswürdigkeiten zu klassifizieren und das Ergebnis anzuzeigen.

Anwendungen der menschlichen Poseschätzung

Die Schätzung der menschlichen Pose findet Anwendungen in verschiedenen Bereichen:

Fitness- und Wellnessbranche

• Personalisierte Anleitung: Pose-Erkennungsanwendungen führen Benutzer durch Yoga-Sitzungen und bieten Echtzeit-Feedback zu ihrer Pose-Ausrichtung.
• Fortschrittsverfolgung: Die Systeme überwachen die Fortschritte der Benutzer und schlugen Änderungen oder Fortschritte vor, die auf individuelle Fähigkeiten zugeschnitten sind.

Anwendungen auf Branchenebene

• Corporate Wellness -Programme: Unternehmen können die Erkennung von Yoga -Posen integrieren und die Gesundheit der Mitarbeiter durch Wellnessprogramme und Stressreduzierung verbessern.

Gesundheitspflege

• Haltungskorrektur: Pose -Erkennung hilft bei der Korrektur der Haltung während der Rehabilitationsübungen und sorgt für die korrekte Bewegungsausführung.
• Fernüberwachung: Angehörige der medizinischen Fachkräfte überwachen die Yoga -Sitzungen der Patienten aus der Ferne, bieten virtuelle Unterstützung und Anpassung von Routinen nach Bedarf.

Sporttraining

• Flexibilität und Krafttraining: Die Erkennung von Sporttrainingsprogrammen zugute kommt den Athleten, die Flexibilität und Stärke erfordern und die Gesamtleistung steigern.

Ausbildung

• Interaktives Lernen: Die Erkennung von Pose verbessert das interaktive und zugängliche Lernen von Yoga für Schüler in Bildungseinrichtungen.
• Fertigkeitsbewertung: Die Lehrer bewerten die Yoga -Fähigkeiten der Schüler mithilfe von Technologie und bieten gezielte Anleitungen zur Verbesserung an.

Unterhaltung und Spiele

• Eintauchende Erfahrungen: VR- oder AR -Anwendungen erzeugen immersive Yoga -Erlebnisse mit virtuellen Ausbildern, die Benutzer durch Posen führen.
• Interaktives Spielen: Pose -Erkennung in Fitnessspielen macht Bewegung für die Benutzer angenehm und motiviert.

Ergonomie in der Industrie

• Desk -Yoga -Sitzungen: Die Integration der Pose -Erkennung in Wellness -Programme am Arbeitsplatz bietet kurze Yoga -Sitzungen, Verbesserung der Körperhaltung und Reduzierung von Stress für Mitarbeiter.
• Ergonomische Bewertungen: Arbeitgeber verwenden die Erkennung von Posen, um ergonomische Aspekte von Arbeitsstationen zu bewerten und die Gesundheit der Mitarbeiter zu fördern.

Benutzervorteile

• Richtiges Formular: Sofortiges Feedback zum Formular verringert das Risiko von Verletzungen und sorgt dafür, dass Benutzer maximale Vorteile von Yoga -Praktiken erzielen.
• Bequemlichkeit: Benutzer können Yoga in der Bequemlichkeit praktizieren, die von virtuellen Ausbildern oder Anwendungen geleitet werden, wodurch die Notwendigkeit physischer Klassen beseitigt wird.
• Motivation: Echtzeit-Fortschrittsverfolgung und Feedback motivieren für Benutzer, mit ihren Yoga-Routinen übereinzustimmen.

Abschluss

Die Integration des Erkennung von menschlichen Posen in Yoga -Posen transzendiert über verschiedene Sektoren und revolutioniert Wellness und Fitness. Von der personalisierten Anleitung und der Fortschrittsverfolgung in der Fitnessbranche bis hin zur Verbesserung der Rehabilitation und Physiotherapie im Gesundheitswesen bietet diese Technologie eine vielseitige Auswahl an Anwendungen. Im Sporttraining trägt es zur Flexibilität und Stärke der Athleten bei, während es in der Bildung interaktive und bewertbare Yoga -Lernerfahrungen bringt.

Der Arbeitsplatz profitiert von Desk-Yoga-Sitzungen und ergonomischen Bewertungen, wodurch das Wohlbefinden der Mitarbeiter fördert. Benutzer, die von virtuellen Ausbildern geführt werden, genießen das korrekte Feedback, die Bequemlichkeit und die Motivation und fördern einen gesünderen und effizienteren Ansatz für Yoga -Praktiken. Diese transformative Kombination von veralteten Praktiken mit modernster Innovation legt den Weg für einen umfassenden Wohlbefinden auf dem Weg zu.

Key Takeaways

• Die menschliche Haltungsschätzung, ein Feld im Computer Vision, umfasst das Erkennen von Key -Fokus auf den Körper einer Person, um ihn zu erhalten und ihre Pose zu analysieren.
• Die Schätzung der menschlichen Haltung hat verschiedene Anwendungen, die sich von Wellness und Wohlbefinden bis hin zur Gesundheitsversorgung, Sportvorbereitung, Unterricht, Belustigung und Ergonomie des Arbeitsumfelds erstrecken.
• Die Konsolidierung der Innovation für Haltung Discovery in Yoga Hone bietet Kunden eine personalisierte Richtung, Echtzeiteingabe, fortschrittliche Anhängerschaft, Komfort und Inspiration, um sie mit Wohlbefinden und kompetenteren Workouts voranzutreiben.
• Die Integration des Erkennung von menschlichen Posen in die Yoga-Praxis stellt einen erheblichen Fortschritt in der Wellness-Technologie dar und ebnet den Weg für eine umfassende Wohlbefindensrevolution.

Häufig gestellte Fragen

Q1. Was ist die Schätzung der menschlichen Haltung und wie funktioniert es?

A. Die Schätzung der menschlichen Haltung kann eine Computer -Vision -Strategie sein, die das Erkennen von Key -Fokus auf den Körper einer Person umfasst, um sie zu erhalten und ihre Pose zu analysieren. Es wird durch Nutzung von Berechnungen geeignet, um diese Schlüsselfokus zu unterscheiden und zu klassifizieren, wodurch die Echtzeit-Anhänger und die Untersuchung der menschlichen Entwicklung ermöglicht werden.

Q2. Was sind die Hauptanwendungen der menschlichen Pose -Schätzung in der Yoga -Praxis?

A. Die Technologie zur Schätzung der menschlichen Haltung kann in Yoga Hone angeschlossen werden, um Kunden personalisierte Richtung, Echtzeiteingaben zur Pose-Anordnung, fortgeschrittene Anhängerschaft und virtuelle Yoga-Anweisung zu liefern. Es kann auch in Yoga -Anweisungen, Genesung und Sportvorbereitung verwendet werden.

Q3. Was sind einige beliebte Bibliotheken und Werkzeuge für die Schätzung des menschlichen Pose?

A. Einige beliebte Open-Source-Bibliotheken und -instrumente für die Schätzung der menschlichen Pose sind offener Einsatz, Poedetektion, Dichtung, Alphapose und HRNet (hochauflösendes Netz). Diese Bibliotheken liefern vorgebrachte Modelle und APIs zur Durchführung von Aufgaben zur Pose-Schätzung.

Q4. Kann menschliche Pose -Schätzungstechnologie zur Haltungskorrektur im Yoga eingesetzt werden?

A. Ja, die Innovation der menschlichen Haltung schätzt, dass sie im Yoga zur Pose-Wiedergutmachung in Echtzeit kritisiert werden können, und Änderungen oder Änderungen vorzuschlagen, um Kunden bei der Erfüllung legitimer Form und Arrangements zu unterstützen.

Q5. Ist die menschliche Pose -Schätzungstechnologie für Anfänger im Yoga geeignet?

A. Ja, die Innovation der menschlichen Haltung schätzt, dass Innovation für Tenderfoots im Yoga nützlich sein kann, indem sie ihnen mit Anweisungen, Feedback und visuellen Signalen helfen, die Lern- und Hone -Yoga -Haltungen genau und sicher zu unterstützen.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonEffiziente Schätzung der menschlichen Haltung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!