Créez un outil d'analyse vidéo simple avec python wxpython + openCV

ordre du jour

1.Tout d'abord 2. Démo de l'outil fini 3. Analyse vidéo avec openCV 4. Créez une interface graphique avec wxpython 5. exe avec pyinstaller

introduction

J'ai déjà voulu savoir «à quelle heure» et «quel genre de personne sortira» dans la vidéo. J'ai créé un simple outil d'analyse vidéo avec wxpython et openCV que j'étudiais. Je vais le présenter ici comme un mémo pour moi-même.

Télécharger les ici GitLab ChuntaMovieAnalyzer

Démo de l'outil fini

Tout d'abord, depuis l'écran de démonstration de l'outil. Spécifiez la vidéo et sortez le rapport html. Un visage humain est extrait et affiché chaque seconde de la vidéo. Vous pouvez modifier l'intervalle entre les secondes et le nombre maximum de personnes à extraire dans l'interface graphique.

Télécharger les ici GitLab ChuntaMovieAnalyzer

Analyse vidéo avec openCV

La bibliothèque utilisée pour analyser la vidéo est openCV. Cette fois, une image de la vidéo est utilisée comme données d'image. Le visage est détecté à partir des données d'image et découpé. Les données découpées sont sorties sous forme d'image pour HTML. Je vais vous présenter le code de la partie qui semble être le point.

Charger la vidéo et l'image de sortie

La vidéo est chargée et traitée à des intervalles du nombre de secondes spécifié en utilisant le nombre total d'images de la vidéo et fps (nombre d'images par seconde).

def get_sampling_data_list(self, movie_path, report_path, interval_time, max_human, is_advance):
    sampling_data_list = []
    
    cap = cv2.VideoCapture(movie_path)
    
    if not cap.isOpened():
        print('cannot open movie file.')
        return []
    
    #Obtenez le nombre total d'images
    all_frame_cnt = cap.get(cv2.CAP_PROP_FRAME_COUNT)
    
    #Calculer le nombre d'images à échantillonner à partir de la fréquence d'images
    fps = cap.get(cv2.CAP_PROP_FPS)
    sampling_frame_num = math.floor( fps * interval_time )
    
    frame_cnt = 1
    
    while True:
        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_cnt)
        ret, frame = cap.read()
        
        if ret:
            sampling_data = self.get_sampling_data(frame, frame_cnt, fps, report_path, max_human, is_advance)
            sampling_data_list.append(sampling_data)
            
            frame_cnt = frame_cnt + sampling_frame_num
        else:
            break
    
    return sampling_data_list

Traitement pour chaque image

Convertir 1 image en données d'image ⇒ Détecter le visage à partir des données d'image ⇒ Couper ⇒ Sortie comme image pour html Le traitement est effectué dans l'ordre de.

def get_sampling_data(self, frame, frame_cnt, fps, report_path, max_human, is_advance):
    data = sampling_data(frame_cnt, fps)
    
    face_cascade = cv2.CascadeClassifier(resourcePath('cascade/haarcascade_frontalface_default.xml'))
    src_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faceInfoList = face_cascade.detectMultiScale(src_gray)
    
    human_cnt = 0
    
    for x, y, w, h in faceInfoList:
        #Sortir de la boucle si le nombre maximum de personnes est dépassé
        if human_cnt >= max_human:
            break
        
        #garniture
        img_trim = frame[y:(y + h), x:(x + w)]
        
        data2 = None
        
        data2 = human_data()
        
        #Créer un dossier pour la sortie d'image
        if False == os.path.exists(report_path + '/img'):
            os.mkdir(report_path + '/img')
        
        #Sortie d'image
        file_name = str(frame_cnt) + '_' + str(human_cnt) + '.jpg'
        cv2.imwrite(report_path + '/img/' + file_name, img_trim)
        data2.set_img_src(report_path, file_name)
        
        data.append_human_data(data2)
        
        human_cnt = human_cnt + 1
    
    return data

Création d'interface graphique avec wxpython

La source de la partie GUI. Je vais vous présenter le code de la partie qui semble être le point.

Traitement de l'analyse vidéo Traitement des appels

Étant donné que le processus d'analyse vidéo prend du temps, il sera occupé à moins qu'il ne soit appelé de manière asynchrone. Pour éviter cela, la partie appelante est asynchrone.

import threading

#Thread kick pour empêcher l'écran de se figer car le traitement prend beaucoup de temps
analysis_thread = threading.Thread(target=exec_analyze, args=(self.analysis, self.btn, movie_path, interval_time, max_human, is_advance, token, report_path))
analysis_thread.start()

def exec_analyze(analysis, btn, movie_path, interval_time, max_human, is_advance, token, report_path):
    analysis.analyze(movie_path, int(interval_time), int(max_human), is_advance, token, report_path)
    
    wx.MessageBox('Le fichier html a été envoyé dans le dossier spécifié.', 'Traitement terminé')

conversion exe

J'ai utilisé pyinstaller lors de la conversion en exe. Il était nécessaire de concevoir lors de la clôture de la ressource externe dans exe. Elle a été réalisée en référence au site suivant.

URL référencée Créer un exe comprenant des ressources avec Pyinstaller

Exécutez ce qui suit à l'invite de commande

pyinstaller --onefile --icon=icon.ico -n chuntaMovieAnalyzer view_gui.py

Modifiez le fichier de spécification créé et exécutez à nouveau ce qui suit à l'invite de commande

pyinstaller chuntaMovieAnalyzer.spec

Télécharger les ici GitLab ChuntaMovieAnalyzer