code refactored and imports modified

src/SumMeVideo.py

 from scipy.io import loadmat
 import os
-from moviepy.editor import VideoFileClip
+from BaseVideoClip import BaseVideoClip
 import numpy as np
 
 
-class SumMeVideo(VideoFileClip):
+class SumMeVideo(BaseVideoClip):
     def __init__(self, video_name, video_path, gt_base_dir):
-        self.video_clip = VideoFileClip(video_path)
-        self.fps = int(self.video_clip.fps)
-        self.duration = int(self.video_clip.duration)
+        super().__init__(video_name, video_path, gt_base_dir)
         self.gt_path = os.path.join(gt_base_dir, video_name + '.mat')
-        self.video_name = video_name
 
     def get_gt(self):
         video_gt = loadmat(self.gt_path)
         video_gt = video_gt['user_score']  # (n_frames,n_annotator)
         return self.bin_classify_user_score(video_gt)
 
-    """
-    :param user scores
-    :returns binary nparray
-    """
-
     def bin_classify_user_score(self, video_gt):
         user_scores = video_gt
         result = []
         for user in range(user_scores.shape[1]):
-            print(user_scores[:, user].shape)
+            #print(user_scores[:, user].shape)
             result.append([int(item > 0.5) for item in user_scores[:, user]])
         return np.asarray(result).T  # (n_frames,n_annotator)
-
-    def get_frames(self):
-        return list(self.video_clip.iter_frames(with_times=False))

src/TVSumVideo.py

 import os
 import numpy as np
 import pandas as pd
-from moviepy.editor import VideoFileClip
+from BaseVideoClip import BaseVideoClip
 
 
-class TVSumVideo(VideoFileClip):
+class TVSumVideo(BaseVideoClip):
     GT_FILE = 'ydata-tvsum50-anno.tsv'
 
     def __init__(self, video_name, video_path, gt_base_dir):
-        self.video_clip = VideoFileClip(video_path)
-        self.fps = int(self.video_clip.fps)
-        self.duration = int(self.video_clip.duration)
+        super().__init__(video_name, video_path, gt_base_dir)
         self.gt_path = os.path.join(gt_base_dir, self.GT_FILE)
-        self.video_name = video_name
 
     def get_gt(self):
         gt_df = pd.read_csv(self.gt_path, sep="\t", header=None, index_col=0)
@@ -28,5 +25,3 @@ class TVSumVideo(VideoFileClip):
         users_gt = users_gt.astype(int)
         return np.rint(users_gt.mean(axis=0))
 
-    def get_frames(self):
-        return list(self.video_clip.iter_frames(with_times=False))

src/VSUMMVideo.py

 import os
-from moviepy.editor import VideoFileClip
 import numpy as np
-from src.utils import digits_in_string, has_string
+from utils import digits_in_string, has_string, get_dir_in_path
+from BaseVideoClip import BaseVideoClip
 
 
-class VSUMMVideo(VideoFileClip):
+class VSUMMVideo(BaseVideoClip):
     def __init__(self, video_name, video_path, gt_base_dir):
-        self.video_clip = VideoFileClip(video_path)
-        self.fps = int(self.video_clip.fps)
-        self.duration = int(self.video_clip.duration)
+        super().__init__(video_name, video_path, gt_base_dir)
         self.gt_path = os.path.join(gt_base_dir, video_name)
-        self.video_name = video_name
-        self.nframes = self.video_clip.reader.infos['video_nframes']
 
     def get_gt(self):
         vid_scores = []
-        for i, user in enumerate(os.listdir(self.gt_path)):
-            user_dir = os.path.join(self.gt_path, user)
+        dirs = get_dir_in_path(self.gt_path)
+        for i, user in enumerate(dirs):
             frame_idx = []
-            for idx, summary in enumerate(os.listdir(user_dir)):
+            for idx, summary in enumerate(os.listdir(user)):
                 if has_string(summary, 'frame'):
                     frame_idx.append(digits_in_string(summary))  # Frame123--> 123
             vid_scores.append(frame_idx)
@@ -26,13 +22,11 @@ class VSUMMVideo(VideoFileClip):
 
         return binary_scores
 
+
     def bin_classify_user_score(self, user_scores_list):
         result = []
         for frames_idx in list(user_scores_list):
-            vid_frames = np.zeros(self.nframes)
+            vid_frames = np.zeros(self.n_frames)
             np.put(vid_frames, frames_idx, [1])  # replace all selected frames with 1
             result.append(vid_frames)
         return np.asarray(result).T  # (n_frames,n_annotator)
-
-    def get_frames(self):
-        return list(self.video_clip.iter_frames(with_times=False))

src/utils.py

@@ -110,3 +110,6 @@ def has_string(string, sub_string):
     sub_string = str(sub_string).lower()
 
     return sub_string in string
+
+def get_dir_in_path(dir):
+    return [os.path.join(dir, o) for o in os.listdir(dir) if os.path.isdir(os.path.join(dir, o))]

src/video2frames.py

 import argparse
-from src.utils import *
-from src.SumMeVideo import SumMeVideo
-from src.TVSumVideo import TVSumVideo
-from src.VSUMMVideo import VSUMMVideo
-from src.FeatureExtractor import FeatureExtractor
+from utils import *
+from SumMeVideo import SumMeVideo
+from TVSumVideo import TVSumVideo
+from VSUMMVideo import VSUMMVideo
+from FeatureExtractor import FeatureExtractor
 from PIL import Image
 from tqdm import tqdm
+import gc
 
 
 def create_video_obj(dataset, video_name, video_path, gt_dir):
@@ -19,16 +20,16 @@ def create_video_obj(dataset, video_name, video_path, gt_dir):
 
 
 def arg_parser():
-    # ../data/SumMe/videos  ../data/SumMe/videos/GT
+    # ../data/SumMe/videos  ../data/SumMe/GT
     # ../ data / TVSum / video /  ../data/TVSum/data
     # ../data/VSUMM/new_database  ../data/VSUMM/newUserSummary
     parser = argparse.ArgumentParser(description='Extract Features')
-    parser.add_argument('--dataset', default='VSUMM', type=str, help='SumMe, TVSum or VSUMM')
-    parser.add_argument('--videos_dir', metavar='DIR', default='../data/VSUMM/new_database', help='path input videos')
-    parser.add_argument('--gt', metavar='GT_Dir', default='../data/VSUMM/newUserSummary', help='path ground truth')
+    parser.add_argument('--dataset', default='SumMe', type=str, help='SumMe, TVSum or VSUMM')
+    parser.add_argument('--videos_dir', metavar='DIR', default='../data/SumMe/videos', help='path input videos')
+    parser.add_argument('--gt', metavar='GT_Dir', default='../data/SumMe/GT', help='path ground truth')
     parser.add_argument('--fps', default=2, type=int, help='Frames per second for the extraction')
     parser.add_argument('--model_arch', default='googlenet',
-                        help='pretrained model architecture e.g. resnet50 or alexnet')
+                        help='pre-trained model architecture e.g. resnet50 or alexnet')
     return parser