[PYTHON] Erkennen Sie Videoobjekte mit der Video Intelligence-API

Dinge die zu tun sind

Identifizieren Sie, was sich an welcher Position in welchem Frame des Videos befindet. Verwenden Sie die [Video Intelligence API] von Google (https://cloud.google.com/video-intelligence?hl=ja), um Objekte aus Videos zu erkennen. Der in diesem Artikel vorgestellte Code basiert auf dem Official Getting Started Guide.

Vorbereitung

Video Intelligence API [Authentifizierung für API] im offiziellen Handbuch (https://cloud.google.com/video-intelligence/docs/how-to?hl=ja#api-%E3%81%AB%E5%AF%BE%E3% 81% 99% E3% 82% 8B% E8% AA% 8D% E8% A8% BC) und erhalten Sie die Schlüsseldatei des Dienstkontos.

google colaboratory Verwenden Sie Google Colaboratory, um Ergebnisse zu implementieren und zu überprüfen.

[Dieser Artikel](https://qiita.com/sosuke/items/533909d31244f986ad47#%E3%82%B5%E3%83%BC%E3%83%93%E3%82%B9%E3%82%A2 % E3% 82% AB% E3% 82% A6% E3% 83% B3% E3% 83% 88% E3% 81% AE% E8% AA% 8D% E8% A8% BC% E6% 83% 85% E5 % A0% B1% E3% 82% 92% E3% 82% A2% E3% 83% 83% E3% 83% 97% E3% 83% AD% E3% 83% BC% E3% 83% 89% E3% 81 Laden Sie die Dienstkonto-Schlüsseldatei in das Labor hoch (siehe% 99% E3% 82% 8B). Wenn Sie dies nicht jedes Mal tun möchten, können Sie es in das von Ihnen gemountete Google-Laufwerk einfügen. Achten Sie jedoch darauf, dass Sie es nicht versehentlich freigeben.

Zu analysierendes Bild

Mit der Video Intelligence API

• Im GCP-Speicher gespeicherte Videodateien --Videodateien lokal gespeichert

Kann analysiert werden. Wenn Sie eine in GCP Storage gespeicherte Videodatei verwenden möchten, wird Ihnen zusätzlich zur API-Gebühr eine Nutzungsgebühr für Storage berechnet. Wenn Sie sie also nur ausprobieren möchten, wird local empfohlen.

Dieses Mal verwenden wir die Methode zum Analysieren von "lokal gespeicherten Videodateien". Speichern Sie also das Video, das Sie analysieren möchten, in Google Drive und mounten Sie das Laufwerk in einem Labor. Laufwerke können im linken Bereich des Labors montiert werden.

Berücksichtigen Sie bei der Vorbereitung eines Videos die Nutzungsgebühr der Video Intelligence-API.

[Ergänzung] Nutzungsgebühr für die Video Intelligence API (Stand März 2020)

Die Video Intelligence-API wird entsprechend der Länge des zu analysierenden Videos bezahlt. Die Länge wird in Minuten berechnet und weniger als 1 Minute wird aufgerundet. Wenn Sie also mit den folgenden drei Mustern Anmerkungen machen, ist die Nutzungsgebühr gleich.

1. Ein Video von 2 Minuten und 30 Sekunden
2. Ein 1-Minuten-30-Sekunden-Video und ein 30-Sekunden-Video
3. Drei 30-Sekunden-Videos

Der Preis für jede Anmerkung ist wie folgt

Implementierung

Bereit zur Verwendung von Video Intelligence

Installieren Sie den Videointelligence-Client

!pip install -U google-cloud-videointelligence

Erstellen Sie einen Videointelligence-Client

Zunächst [Authentifizierung für API](https://cloud.google.com/video-intelligence/docs/how-to?hl=ja#api-%E3%81%AB%E5%AF%BE%E3%81 Authentifizieren Sie sich mit der Schlüsseldatei des Dienstkontos, die in% 99% E3% 82% 8B% E8% AA% 8D% E8% A8% BC erhalten wurde. service_account_key_name ist der Pfad zur Dienstkonto-Schlüsseldatei, die in colaboratory hochgeladen wurde.

import json
from google.cloud import videointelligence
from google.oauth2 import service_account

#API-Authentifizierung
service_account_key_name = "{YOUR KEY.json}"
info = json.load(open(service_account_key_name))
creds = service_account.Credentials.from_service_account_info(info)

#Client erstellen
video_client = videointelligence.VideoIntelligenceServiceClient(credentials=creds)

Führen Sie die API aus

Laden Sie zuerst das Video vom Laufwerk.

#Geben Sie das zu verarbeitende Video an und laden Sie es
import io

path = '{YOUR FILE PATH}'
with io.open(path, 'rb') as file:
    input_content = file.read()

Führen Sie dann die API aus und erhalten Sie das Ergebnis

features = [videointelligence.enums.Feature.OBJECT_TRACKING]
timeout = 300
operation = video_client.annotate_video(input_content=input_content, features=features, location_id='us-east1')

print('\nProcessing video for object annotations.')
result = operation.result(timeout=timeout)
print('\nFinished processing.\n')

Überprüfen Sie das Ergebnis

Zeigen Sie eine Liste der erkannten Objekte an

Das Jupyter-Notizbuch zeichnet die Pandas DataFrame gut, also [Antwort](https://cloud.google.com/video-intelligence/docs/object-tracking?hl=ja#vision-object- Extrahieren Sie nur die erforderlichen Informationen aus dem Tracking-GCS-Protokoll und generieren Sie einen DataFrame.

Dieses Mal erhalten Sie Folgendes aus der Antwort "object_annotations".

#Listen Sie die erkannten Objekte auf
import pandas as pd

columns=['Description', 'Confidence', 'SegmentStartTime', 'SegmentEndTime', 'FrameTime', 'BoxLeft', 'BoxTop', 'BoxRight', 'BoxBottom', 'Box', 'Id']
object_annotations = result.annotation_results[0].object_annotations
result_table = []
for object_annotation in object_annotations:
    for frame in object_annotation.frames:
        box = frame.normalized_bounding_box
        result_table.append([
                object_annotation.entity.description,
                object_annotation.confidence,
                object_annotation.segment.start_time_offset.seconds + object_annotation.segment.start_time_offset.nanos / 1e9,
                object_annotation.segment.end_time_offset.seconds + object_annotation.segment.end_time_offset.nanos / 1e9,
                frame.time_offset.seconds + frame.time_offset.nanos / 1e9,
                box.left,
                box.top,
                box.right,
                box.bottom,
                [box.left, box.top, box.right, box.bottom],
                object_annotation.entity.entity_id
        ])
        #Da es riesig sein wird, ist vorerst nur der erste Frame jedes Segments
        break

df=pd.DataFrame(result_table, columns=columns)
pd.set_option('display.max_rows', len(result_table))
#Nach Vertrauen sortieren und anzeigen
df.sort_values('Confidence', ascending=False)

Bei der Ausführung werden die folgenden Ergebnisse erhalten.

Listen Sie die Frames auf, in denen das Objekt als Standbild erkannt wurde

Zunächst wird der Frame basierend auf den oben erwähnten "time_offset" -Informationen aus dem Video extrahiert. Verwenden Sie "openCV", um ein Standbild aus einem Video zu erhalten. Da das Standbild angegeben werden muss, das in Frames ausgeschnitten werden soll, wird die ungefähre Anzahl der Frames aus den FPS des Videos und "time_offset" (Sekunden) berechnet.

import cv2

images = []
cap = cv2.VideoCapture(path)

if cap.isOpened():
    fps = cap.get(cv2.CAP_PROP_FPS)
    for sec in df['FrameTime']:
        #Berechnen Sie die Anzahl der Frames aus fps und Sekunden
        cap.set(cv2.CAP_PROP_POS_FRAMES, round(fps * sec))
        ret, frame = cap.read()
        if ret:
            images.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))

Fügen Sie als Nächstes dem in jedem Standbild gezeigten Objekt, das durch ein "Rechteck" von "openCV" ausgeschnitten ist, einen Rahmen hinzu. Da "Rechteck" den oberen linken und unteren rechten Scheitelpunkt des zu zeichnenden Rechtecks angeben muss, müssen diese beiden Punkte erhalten werden. Die von der API zurückgegebene "normalized_bounding_box" enthält Informationen auf vier Seiten ("left", "top", "right", "bottom"). In dem im Bild unten gezeigten Feld wird beispielsweise die Position von "person" angezeigt. Der Wert von "left" ist "l (Breite vom linken Rand des Bildes bis zum linken Rand des Feldes) / width (Breite des gesamten Bildes)", also bei der Berechnung der x-Koordinate von Scheitelpunkt 1 ("pt1") aus dem Wert von "left" Sie können mit width * left zurückrechnen. Bereiten Sie eine geeignete Methode vor.

#Finden Sie die Koordinaten auf dem Bild
def ratio_to_pics(size_pics, ratio):
    return math.ceil(size_pics * ratio)

#Holen Sie sich die oberen linken und unteren rechten Eckpunkte aus der Box
def rect_vertex(image, box):
    height, width  = image.shape[:2]
    return[
        (
            ratio_to_pics(width, box[0]), ratio_to_pics(height, box[1])
        ),
        (
            ratio_to_pics(width, box[2]), ratio_to_pics(height, box[3])
        )
    ]

Schreiben Sie den Rahmen tatsächlich in das Bild, während Sie die Position des Scheitelpunkts des Rahmens mit der obigen Methode berechnen.

boxed_images = []
color = (0, 255, 255)
thickness = 5
for index, row in df.iterrows():
    image = images[index]
    boxed_images.append(cv2.rectangle(image,  *rect_vertex(image, row.Box), color,  thickness = thickness))

Schließlich wird jedes Bild mit Beschreibung und Vertrauen angezeigt. Abhängig von der Länge des Videos und der Anzahl der erkannten Objekte kann es einige Zeit dauern, bis alle Objekte angezeigt werden. Daher wird ein Schwellenwert für das Vertrauen festgelegt.

import math
import matplotlib.pyplot as plt

#Mit Zuversicht entsprechend abschneiden
min_confidence = 0.7

#Stellen Sie verschiedene Figuren ein
col_count = 4
row_count = math.ceil(len(images) / col_count)
fig = plt.figure(figsize = (col_count * 4, row_count * 3), dpi = 100)
num = 0

#Zeigen Sie Standbilder nebeneinander an
for index, row in df.iterrows():
    if row.Confidence < min_confidence:
        continue
    num += 1
    fig.add_subplot(row_count, col_count, num, title = '%s : (%s%s)' % (row.Description, round(row.Confidence * 100, 2), '%'))
    plt.imshow(boxed_images[index], cmap='gray')
    plt.axis('off')

Bei der Ausführung werden die folgenden Ergebnisse erhalten.

Referenz

[Zeigen Sie das Ergebnis der Analyse des Videos mithilfe der Cloud Video Intelligence-API von Colaboratory an. ](Https://qiita.com/sosuke/items/533909d31244f986ad47#%E3%82%B5%E3%83%BC%E3%83%93%E3%82%B9%E3%82%A2%E3%82 % AB% E3% 82% A6% E3% 83% B3% E3% 83% 88% E3% 81% AE% E8% AA% 8D% E8% A8% BC% E6% 83% 85% E5% A0% B1 % E3% 82% 92% E3% 82% A2% E3% 83% 83% E3% 83% 97% E3% 83% AD% E3% 83% BC% E3% 83% 89% E3% 81% 99% E3 % 82% 8B) Offizieller Leitfaden für die ersten Schritte