Einführung

"Bewegungsvorlage" ist eine effiziente Methode zur Bewegungsextraktion, die vom MIT Media Lab (Link 1, [Link] entwickelt wurde. 2](http://alumni.media.mit.edu/~jdavis/Publications/motiontemplategradient.pdf)). Es eignet sich für Echtzeitberechnungen mit geringem Rechenaufwand. Es hat eine breite Palette von Anwendungen und kann Spielerbewegungen, Ball-, Schläger-, Schläger- und Schlägerbahnen durch Gestenerkennung und Sportübertragungen visuell anzeigen. Dieses Mal werde ich versuchen, Bewegungsvorlagen mit OpenCV 3 zu analysieren.

OpenCV OpenCV (Open Source Computer Vision Library) ist eine Sammlung von BSD-lizenzierten Video- / Bildverarbeitungsbibliotheken. Es gibt viele Algorithmen wie Bildfilterung, Vorlagenabgleich, Objekterkennung, Videoanalyse und maschinelles Lernen.

■ Beispiel für Bewegungsverfolgung mit OpenCV (OpenCV Google Summer of Code 2015) https://www.youtube.com/watch?v=OUbUFn71S4s

■ Klicken Sie hier für die Installation und einfache Verwendung Installieren Sie OpenCV 3 (Core + Contrib) in der Python 3-Umgebung und unterscheiden Sie zwischen OpenCV 2 und OpenCV 3 und überprüfen Sie die einfache Bedienung ★ Installieren Sie core + opencv_contrib, um die Bewegungsvorlage auszuführen.

■ Klicken Sie hier, um Standbilder zu filtern Versuchen Sie die Kantenerkennung mit OpenCV Führen Sie verschiedene Filter mit OpenCV durch (Gradient, Highpass, Laplacian, Gaussian) Extrahieren Sie Feature-Punkte mit OpenCV (AgastFeature, FAST, GFTT, MSER, AKAZE, BRISK, KAZE, ORB, SimpleBlob)

■ Klicken Sie hier, um Videodateien zu verarbeiten Versuchen Sie, Videos in Echtzeit mit OpenCV zu konvertieren Versuchen Sie, Webkamera- / Videokamera-Videos in Echtzeit mit OpenCV zu konvertieren Zeichnen Sie den optischen Fluss in Echtzeit mit OpenCV (Shi-Tomasi-Methode, Lucas-Kanade-Methode) Objektverfolgung mit OpenCV (Verfolgen von Funktionspunkten, die von der Maus mit der Lucas-Kanade-Methode festgelegt wurden

einfache Erklärung

"Motion Template" kann auch einfach mit OpenCV realisiert werden. Hier finden Sie eine kurze Zusammenfassung der diesmal verwendeten OpenCV-Methoden.

ID	Methode	Überblick
(a)	cv2.motempl.updateMotionHistory()	Film aktualisieren
(b)	cv2.motempl.calcMotionGradient()	Berechnen Sie die Richtung für jede Koordinate aus dem Film
(c)	cv2.motempl.calcGlobalOrientation()	Berechnen Sie die Gesamtausrichtung des Films

Dieses Mal erstellen wir ein Programm, das alle (a), (b) und (c) verwendet, aber es ist auch möglich, nur die erforderlichen auszuwählen. Wenn Sie beispielsweise nur bewegte Bilder möchten, benötigen Sie (b) (c) nicht.

Die Hauptfunktionen dieses Programms sind wie folgt. --Motion wird erkannt und in Graustufen angezeigt.

Betonen Sie neue Bewegungen und dimmen Sie alte Bewegungen allmählich ab.
Die Bewegungsrichtung an jeder Koordinate wird als grüne Linie angezeigt.
Die Bewegungsrichtung auf dem gesamten Bildschirm wird als gelbe Linie angezeigt.

Programm

Betriebsumgebung
- python: 3.5.1
- OpenCV(core + contrib): 3.1.0
Videodaten Das Programm verwendet das mit OpenCV gelieferte Beispielvideo. 　　OpenCV\opencv\sources\samples\data\768x576.avi

`motion.py`


import time
import math
import cv2
import numpy as np

#Videodaten
VIDEO_DATA = "768x576.avi"
#Esc-Taste
ESC_KEY = 0x1b
#Verbleibende Bewegungsdauer(sec)
DURATION = 1.0
#Die Länge der Linie, die die Gesamtrichtung anzeigt
LINE_LENGTH_ALL = 60
#Die Länge der Linie, die die Richtung für jede Koordinate anzeigt
LINE_LENGTH_GRID = 20
#Intervall zur Berechnung der Richtung für jede Koordinate
GRID_WIDTH = 40
#Der Radius des Kreises der Linie, der die Richtung angibt
CIRCLE_RADIUS = 2

#Initialisierung des Anzeigefensters
cv2.namedWindow("motion")
#Videodaten laden
video = cv2.VideoCapture(VIDEO_DATA)

#Laden des ersten Frames
end_flag, frame_next = video.read()
height, width, channels = frame_next.shape
motion_history = np.zeros((height, width), np.float32)
frame_pre = frame_next.copy()

while(end_flag):
    #Differenzberechnung zwischen Frames
    color_diff = cv2.absdiff(frame_next, frame_pre)

    #Graustufenumwandlung
    gray_diff = cv2.cvtColor(color_diff, cv2.COLOR_BGR2GRAY)

    #Binarisierung
    retval, black_diff = cv2.threshold(gray_diff, 30, 1, cv2.THRESH_BINARY)

    #Prozessorverarbeitungszeit(sec)Erhalten
    proc_time = time.clock()

    #Bewegungsverlauf aktualisieren
    cv2.motempl.updateMotionHistory(black_diff, motion_history, proc_time, DURATION)

    #Dimmen der Anzeige alter Bewegungen im Laufe der Zeit
    hist_color = np.array(np.clip((motion_history - (proc_time - DURATION)) / DURATION, 0, 1) * 255, np.uint8)

    #Graustufenumwandlung
    hist_gray = cv2.cvtColor(hist_color, cv2.COLOR_GRAY2BGR)

    #Berechnung der Änderungsrichtung des Bewegungsverlaufsbildes
    #* Die Ausrichtung speichert den Wert (Grad) in Änderungsrichtung für jede Koordinate.
    mask, orientation = cv2.motempl.calcMotionGradient(motion_history, 0.25, 0.05, apertureSize = 5)

    #Zeichnen Sie die Bewegung jeder Koordinate mit einer grünen Linie
    width_i = GRID_WIDTH
    while width_i < width:
        height_i = GRID_WIDTH
        while height_i < height:
            cv2.circle(hist_gray, \
                       (width_i, height_i), \
                       CIRCLE_RADIUS, \
                       (0, 255, 0), \
                       2, \
                       16, \
                       0)
            angle_deg = orientation[height_i - 1][width_i - 1]
            if angle_deg > 0:
                angle_rad = math.radians(angle_deg)
                cv2.line(hist_gray, \
                         (width_i, height_i), \
                         (int(width_i + math.cos(angle_rad) * LINE_LENGTH_GRID), int(height_i + math.sin(angle_rad) * LINE_LENGTH_GRID)), \
                         (0, 255, 0), \
                         2, \
                         16, \
                         0)
            
            height_i += GRID_WIDTH
        
        width_i += GRID_WIDTH


    #Berechnen Sie die Gesamtbewegungsrichtung
    angle_deg = cv2.motempl.calcGlobalOrientation(orientation, mask, motion_history, proc_time, DURATION)

    #Zeichnen Sie die gesamte Bewegung mit einer gelben Linie
    cv2.circle(hist_gray, \
               (int(width / 2), int(height / 2)), \
               CIRCLE_RADIUS, \
               (0, 215, 255), \
               2, \
               16, \
               0)
    angle_rad = math.radians(angle_deg)
    cv2.line(hist_gray, \
             (int(width / 2), int(height / 2)), \
             (int(width / 2 + math.cos(angle_rad) * LINE_LENGTH_ALL), int(height / 2 + math.sin(angle_rad) * LINE_LENGTH_ALL)), \
             (0, 215, 255), \
             2, \
             16, \
             0)

    #Bewegtbild anzeigen
    cv2.imshow("motion", hist_gray)

    #Drücken Sie die Esc-Taste, um den Vorgang abzuschließen
    if cv2.waitKey(20) == ESC_KEY:
        break

    #Laden Sie den nächsten Frame
    frame_pre = frame_next.copy()
    end_flag, frame_next = video.read()

#Verarbeitung beenden
cv2.destroyAllWindows()
video.release()

Ausführungsergebnis

Die gehende Figur wird in der Bewegungsvorlage angezeigt.
Die grüne Linie zeigt, in welche Richtung sich jedes Gitter bewegt. ――Die gelbe Linie zeigt an, in welche Richtung sich der Bildschirm bewegt.

Es ist etwas schwierig, die Gesamtrichtung zu verstehen, aber wenn es sich um einen festen Rahmen handelt, wird angezeigt, in welche Richtung sich die Objekte auf dem Bildschirm insgesamt bewegen. In Fällen, in denen sich der gesamte Rahmen bewegt, gibt er die Richtung an, in die sich der Rahmen bewegt.

Bewegungsanalyse unter Verwendung von Richtungsinformationen

Lassen Sie uns als Beispiel für die Analyse von Bewegungen mithilfe einer Bewegungsvorlage den Moment einer Aufnahme von Kei Nishikiori analysieren. Führen Sie die Analyse anhand der Richtungsinformationen durch, die aus den Bewegungsvorlageninformationen berechnet wurden. Lassen Sie uns das Bewegungsvorlagenprogramm für das Originalbild ausführen. Im Film sehen Sie die Flugbahn des Balls für jedes Bild (Film 1, Film 2). Wenn Sie die Anzahl der Kugeln zählen, ist das Motion 2-Bild 3 Frames vor dem Motion 1-Bild.

Wenn Sie die Richtung jedes Gitters für Film 1 und Film 2 analysieren, können Sie die folgenden Bewegungen lesen.

Die rechte Schulter, die im Motion 1-Bild angehalten wurde, bewegt sich im Motion 2-Bild nach rechts oben.
Das rechte Kalb, das im Motion 1-Bild gestoppt wurde, bewegt sich im Motion 2-Bild nach unten.
Das linke Knie, das im Motion 1-Bild angehalten wurde, bewegt sich im Motion 2-Bild nach oben.
Die Taille, die sich im Motion 1-Bild rückwärts bewegt hat, bewegt sich im Motion 2-Bild nach rechts oben.
Vom Schienbein des linken Fußes werden die Mitte des linken und rechten Schulterblatts und der Kopf in den Bildern von Bewegung 1 und Bewegung 2 gestoppt. ―― Insgesamt ist die linke Körperhälfte als Achse festgelegt, und die rechte Körperhälfte wird gedehnt, um den Ball zurückzuschlagen.

Wenn Sie es im Fernsehen sehen, sieht es so aus, als würden Sie mit Ihrem ganzen Körper springen und den Ball schlagen. Verwenden Sie jedoch in diesem Video die Feder der rechten Körperhälfte, nachdem Sie mit der linken Körperhälfte eine durchgezogene Achse erstellt haben Sie können sehen, dass Sie schlagen.

** Original Bild **

** Film 1 Bild **

** Film 2 Bild **

Für diejenigen, die Sport treiben, wäre es interessant, die Bewegungen von Profis und den Unterschied zwischen den Bewegungen zu analysieren, wenn sie erfolgreich sind und wenn sie versagen.

[PYTHON] Bewegungsvorlagenanalyse mit OpenCV (Erkennen von Objekten und deren Bewegungsrichtungen in Echtzeit)