[PYTHON] Détecter les objets vidéo avec l'API Video Intelligence

Choses à faire

Identifiez ce qui se trouve dans quelle position dans quelle image de la vidéo. Utilisez l '[API Video Intelligence] de google (https://cloud.google.com/video-intelligence?hl=ja) pour détecter les objets des vidéos. Le code présenté dans cet article est basé sur le Guide de démarrage officiel.

Préparation

Video Intelligence API [Authentication for API] dans le guide officiel (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) et obtenez le fichier de clé du compte de service.

google colaboratory Utilisez google colaboratory pour mettre en œuvre et vérifier les résultats.

[Cet article](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 Téléchargez le fichier de clé de compte de service dans le laboratoire comme indiqué dans% 99% E3% 82% 8B) Si vous ne voulez pas le faire à chaque fois, vous pouvez le mettre dans le lecteur Google que vous montez, mais veillez à ne pas le partager accidentellement.

Image à analyser

Avec l'API Video Intelligence

• Fichiers vidéo enregistrés dans GCP Storage
• Fichiers vidéo enregistrés localement

Peut être analysé. Si vous souhaitez utiliser un fichier vidéo enregistré dans GCP Storage, des frais d'utilisation pour le stockage vous seront facturés en plus des frais d'API. Par conséquent, si vous souhaitez simplement essayer, le local est recommandé.

Cette fois, nous utiliserons la méthode d'analyse des "fichiers vidéo enregistrés localement", donc enregistrez la vidéo que vous souhaitez analyser dans Google Drive et montez le lecteur en colaboratory. Les lecteurs peuvent être montés à partir du volet gauche du colaboratoire.

Lors de la préparation d'une vidéo, tenez compte des Frais d'utilisation de l'API Video Intelligence.

[Supplément] Frais d'utilisation de l'API Video Intelligence (à compter de mars 2020)

L'API Video Intelligence est payante en fonction de la durée de la vidéo analysée. La durée est calculée en minutes et moins de 1 minute est arrondie, donc si vous annotez avec les trois modèles suivants, les frais d'utilisation seront les mêmes.

1. Une vidéo de 2 minutes et 30 secondes
2. Une vidéo de 1 minute 30 secondes et une vidéo de 30 secondes
3. Trois vidéos de 30 secondes

Le prix de chaque annotation est le suivant

la mise en oeuvre

Intelligence vidéo prête à l'emploi

Installez le client de videointelligence

!pip install -U google-cloud-videointelligence

Créer un client de videointelligence

Tout d'abord, [Authentication for API](https://cloud.google.com/video-intelligence/docs/how-to?hl=ja#api-%E3%81%AB%E5%AF%BE%E3%81 Authentifiez-vous à l'aide du fichier de clé de compte de service obtenu en% 99% E3% 82% 8B% E8% AA% 8D% E8% A8% BC). service_account_key_name est le chemin du fichier de clé de compte de service téléchargé vers colaboratory.

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

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

#Créer un client
video_client = videointelligence.VideoIntelligenceServiceClient(credentials=creds)

Exécutez l'API

Commencez par charger la vidéo à partir du lecteur.

#Spécifiez la vidéo à traiter et chargez-la
import io

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

Ensuite, exécutez l'API et obtenez le résultat

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')

Vérifiez le résultat

Afficher une liste des objets détectés

Le notebook jupyter dessine joliment les pandas DataFrame, donc [Response](https://cloud.google.com/video-intelligence/docs/object-tracking?hl=ja#vision-object- Extraire uniquement les informations nécessaires du tracking-gcs-protocol) et générer un DataFrame.

Cette fois, récupérez ce qui suit dans la réponse ʻobject_annotations`.

#Lister les objets détectés
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
        ])
        #Comme ce sera énorme, seule la première image de chaque segment pour le moment
        break

df=pd.DataFrame(result_table, columns=columns)
pd.set_option('display.max_rows', len(result_table))
#Trier et afficher par confiance
df.sort_values('Confidence', ascending=False)

Une fois exécutés, les résultats suivants seront obtenus.

Répertoriez les images dans lesquelles l'objet a été détecté en tant qu'image fixe

Tout d'abord, l'image est extraite de la vidéo sur la base des informations "time_offset" mentionnées ci-dessus. Utilisez ʻopenCV` pour obtenir une image fixe d'une vidéo. Puisqu'il est nécessaire de spécifier l'image fixe à découper en images, le nombre approximatif d'images est calculé à partir du FPS de la vidéo et de «time_offset» (secondes).

import cv2

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

if cap.isOpened():
    fps = cap.get(cv2.CAP_PROP_FPS)
    for sec in df['FrameTime']:
        #Calculez le nombre d'images à partir de fps et de secondes
        cap.set(cv2.CAP_PROP_POS_FRAMES, round(fps * sec))
        ret, frame = cap.read()
        if ret:
            images.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))

Ensuite, ajoutez un cadre à l'objet montré dans chaque image fixe découpée avec rectangle de ʻopenCV. Puisque rectangledoit spécifier les sommets supérieur gauche et inférieur droit du rectangle à dessiner, il est nécessaire d'obtenir ces deux points. La «normalized_bounding_box» renvoyée par l'API contient des informations sur quatre côtés («gauche», «haut», «droite», «bas»). Par exemple, dans la case ci-dessous, la position de «personne» est affichée. La valeur de «left» est «l (largeur du bord gauche de l'image au bord gauche de la boîte) / width (largeur de l'image entière)», donc lors du calcul de la coordonnée x du sommet 1 («pt1») à partir de la valeur de «left» Vous pouvez calculer en arrière avecwidth * left`. Préparez une méthode de manière appropriée.

#Trouvez les coordonnées sur l'image
def ratio_to_pics(size_pics, ratio):
    return math.ceil(size_pics * ratio)

#Obtenez les sommets en haut à gauche et en bas à droite de la boîte
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])
        )
    ]

Lors du calcul de la position du sommet du cadre à l'aide de la méthode ci-dessus, écrivez le cadre sur l'image.

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))

Enfin, chaque image est affichée avec Description et Confiance. En fonction de la longueur de la vidéo et du nombre d'objets détectés, l'affichage de tous peut prendre un certain temps. Un seuil est donc défini pour Confiance.

import math
import matplotlib.pyplot as plt

#Coupez correctement avec confiance
min_confidence = 0.7

#Définir divers chiffres
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

#Afficher les images fixes côte à côte
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')

Une fois exécutés, les résultats suivants seront obtenus.

référence

[Affichez le résultat de l'analyse vidéo à l'aide de l'API Cloud Video Intelligence de Colaboratory. ](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) Guide de démarrage officiel