derived logic update

dbm_lib/controller/process_feature.py

@@ -24,17 +24,22 @@ def audio_to_wav(input_filepath):
         input_filepath: (str)  
     Returns:
     """
-    fname, _ = splitext(input_filepath)
+    try:
-    output_filepath = fname + '.wav'
         
-    if not isfile(output_filepath):
+        fname, _ = splitext(input_filepath)
-        call = ['ffmpeg', '-i', input_filepath, '-vn', '-acodec', 'pcm_s16le', '-ar', '44100', output_filepath]
+        output_filepath = fname + '.wav'
 
-        logger.info('Converting audio from {} to wav'.format(input_filepath))
+        if not isfile(output_filepath):
-        subprocess.check_output(call)
+            call = ['ffmpeg', '-i', input_filepath, '-vn', '-acodec', 'pcm_s16le', '-ar', '44100', output_filepath]
-        logger.info('wav output saved in {}'.format(output_filepath))
+
-    else:
+            logger.info('Converting audio from {} to wav'.format(input_filepath))
-        logger.info('Output file {} already exists'.format(output_filepath))
+            subprocess.check_output(call)
+            logger.info('wav output saved in {}'.format(output_filepath))
+        else:
+            logger.info('Output file {} already exists'.format(output_filepath))
+        
+    except Exception as e:
+        logger.error('Failed to extract audio from Video')
 
 def process_acoustic(video_uri, out_dir, dbm_group, r_config):
     """

dbm_lib/dbm_features/derived_features/derive.py

@@ -9,6 +9,7 @@ import numpy as np
 import glob
 import os
 import logging
+from datetime import datetime
 
 logging.basicConfig(level=logging.INFO)
 logger=logging.getLogger()
@@ -34,7 +35,10 @@ def save_derive_output(df_list, feature, out_loc):
         df = pd.concat(df_list, ignore_index=True)
         feature_dir = 'derive_' + feature
         
-        out_dir = os.path.join(out_loc, feature)
+        now = datetime.now()
+        dt_string = now.strftime("%d_%m_%YT%H:%M:%S")
+        
+        out_dir = '{}_{}'.format(out_loc, dt_string)
         file_name = os.path.join(out_dir, feature_dir + '.csv')
         
         if not os.path.exists(out_dir):
@@ -147,5 +151,3 @@ def run_derive(input_file, input_dir, output_dir, r_config, d_config):
         except Exception as e:
             logger.error('Failed to process derived variables.')
         
-           
-            

dbm_lib/dbm_features/raw_features/audio/formant_freq.py

@@ -109,17 +109,21 @@ def run_formant(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            empty_fm(video_uri, out_loc, fl_name, r_config)
+            if float(aud_dur) < 0.064:
-            return
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
 
-        calc_formant(video_uri, audio_file, out_loc, fl_name, r_config)
+                empty_fm(video_uri, out_loc, fl_name, r_config)
+                return
+
+            calc_formant(video_uri, audio_file, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/gne.py

@@ -140,18 +140,22 @@ def run_gne(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            error_txt = 'error: length less than 0.064'
+            if float(aud_dur) < 0.064:
-            empty_gne(video_uri, out_loc, fl_name, r_config, error_txt)
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
-            return
 
-        calc_gne(video_uri, audio_file, out_loc, fl_name, r_config)
+                error_txt = 'error: length less than 0.064'
+                empty_gne(video_uri, out_loc, fl_name, r_config, error_txt)
+                return
+
+            calc_gne(video_uri, audio_file, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/hnr.py

@@ -76,17 +76,21 @@ def run_hnr(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            empty_hnr(video_uri, out_loc, fl_name, r_config)
+            if float(aud_dur) < 0.064:
-            return
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
 
-        calc_hnr(video_uri, audio_file, out_loc, fl_name, r_config)
+                empty_hnr(video_uri, out_loc, fl_name, r_config)
+                return
+
+            calc_hnr(video_uri, audio_file, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/intensity.py

@@ -72,17 +72,21 @@ def run_intensity(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            empty_intensity(video_uri, out_loc, fl_name, r_config)
+            if float(aud_dur) < 0.064:
-            return
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
 
-        calc_intensity(video_uri, audio_file, out_loc, fl_name, r_config)
+                empty_intensity(video_uri, out_loc, fl_name, r_config)
+                return
+
+            calc_intensity(video_uri, audio_file, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/jitter.py

@@ -138,18 +138,22 @@ def run_jitter(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output 
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            error_txt = 'error: length less than 0.064'
+            if float(aud_dur) < 0.064:
-            empty_jitter(video_uri, out_loc, fl_name, r_config, error_txt)
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
-            return
 
-        calc_jitter(video_uri, audio_file, out_loc, fl_name, r_config)
+                error_txt = 'error: length less than 0.064'
+                empty_jitter(video_uri, out_loc, fl_name, r_config, error_txt)
+                return
+
+            calc_jitter(video_uri, audio_file, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/mfcc.py

@@ -85,18 +85,21 @@ def run_mfcc(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output 
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            empty_mfcc(video_uri, out_loc, fl_name, r_config)
+            if float(aud_dur) < 0.064:
-            return
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
 
-        calc_mfcc(video_uri, audio_file, out_loc, fl_name, r_config) 
+                empty_mfcc(video_uri, out_loc, fl_name, r_config)
+                return
 
+            calc_mfcc(video_uri, audio_file, out_loc, fl_name, r_config) 
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/pause_segment.py

@@ -131,37 +131,42 @@ def run_pause_segment(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            error_txt = 'error: length less than 0.064'
+            if float(aud_dur) < 0.064:
-            empty_pause_segment(video_uri, out_loc, fl_name, r_config, error_txt)
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
-            return
 
-        logger.info('Converting stereo sound to mono-lD')
+                error_txt = 'error: length less than 0.064'
-        sound_mono = AudioSegment.from_wav(audio_file)
+                empty_pause_segment(video_uri, out_loc, fl_name, r_config, error_txt)
-        sound_mono = sound_mono.set_channels(1)
+                return
-        sound_mono = sound_mono.set_frame_rate(48000)
 
-        mono_wav = os.path.join(input_loc, fl_name + '_mono.wav')
+            logger.info('Converting stereo sound to mono-lD')
-        sound_mono.export(mono_wav, format="wav")
+            sound_mono = AudioSegment.from_wav(audio_file)
+            sound_mono = sound_mono.set_channels(1)
+            sound_mono = sound_mono.set_frame_rate(48000)
 
-        df_pause_seg = process_silence(mono_wav, r_config)
+            mono_wav = os.path.join(input_loc, fl_name + '_mono.wav')
-        os.remove(mono_wav)#removing mono wav file
+            sound_mono.export(mono_wav, format="wav")
 
-        if isinstance(df_pause_seg, pd.DataFrame) and len(df_pause_seg)>0:
+            df_pause_seg = process_silence(mono_wav, r_config)
-            logger.info('Processing Output file {} '.format(out_loc))
+            os.remove(mono_wav)#removing mono wav file
 
-            df_pause_seg['dbm_master_url'] = video_uri
+            if isinstance(df_pause_seg, pd.DataFrame) and len(df_pause_seg)>0:
-            ut.save_output(df_pause_seg, out_loc, fl_name, pause_seg_dir, csv_ext)
+                logger.info('Processing Output file {} '.format(out_loc))
 
-        else:
+                df_pause_seg['dbm_master_url'] = video_uri
-            error_txt = 'error: webrtcvad returns no segment'
+                ut.save_output(df_pause_seg, out_loc, fl_name, pause_seg_dir, csv_ext)
-            empty_pause_segment(video_uri, out_loc, fl_name, r_config, error_txt)
+
+            else:
+                error_txt = 'error: webrtcvad returns no segment'
+                empty_pause_segment(video_uri, out_loc, fl_name, r_config, error_txt)
+                
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/pitch_freq.py

@@ -93,17 +93,21 @@ def run_pitch(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            empty_pitch(video_uri, out_loc, fl_name, r_config)
+            if float(aud_dur) < 0.064:
-            return
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
 
-        calc_pitch(video_uri, audio_file, out_loc, fl_name, r_config)
+                empty_pitch(video_uri, out_loc, fl_name, r_config)
+                return
+
+            calc_pitch(video_uri, audio_file, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/shimmer.py

@@ -139,19 +139,22 @@ def run_shimmer(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output 
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            error_txt = 'error: length less than 0.064'
+            if float(aud_dur) < 0.064:
-            empty_shimmer(video_uri, out_loc, fl_name, r_config, error_txt)
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
-            return
 
-        calc_shimmer(video_uri, audio_file, out_loc, fl_name, r_config)
+                error_txt = 'error: length less than 0.064'
+                empty_shimmer(video_uri, out_loc, fl_name, r_config, error_txt)
+                return
 
+            calc_shimmer(video_uri, audio_file, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/audio/voice_frame_score.py

@@ -91,17 +91,21 @@ def run_vfs(video_uri, out_dir, r_config):
         video_uri: video path; r_config: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
-    if len(aud_filter)>0:
         
-        audio_file = aud_filter[0]
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        aud_dur = librosa.get_duration(filename=audio_file)
+        aud_filter = glob.glob(join(input_loc, fl_name + '.wav'))
+        if len(aud_filter)>0:
 
-        if float(aud_dur) < 0.064:
+            audio_file = aud_filter[0]
-            logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
+            aud_dur = librosa.get_duration(filename=audio_file)
 
-            empty_vfs(video_uri, out_loc, fl_name, r_config)
+            if float(aud_dur) < 0.064:
-            return
+                logger.info('Output file {} size is less than 0.064sec'.format(audio_file))
 
-        calc_vfs(video_uri, audio_file, out_loc, fl_name, r_config)
+                empty_vfs(video_uri, out_loc, fl_name, r_config)
+                return
+
+            calc_vfs(video_uri, audio_file, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process audio file')

dbm_lib/dbm_features/raw_features/movement/eye_blink.py

@@ -145,12 +145,16 @@ def run_eye_blink(video_uri, out_dir, r_config, facial_landmarks):
         out_dir: (str) Output directory for processed output; r_config: raw variable config object;
         facial_landmarks: landmark model path
     """
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+    try:
-    vid_file_path = os.path.exists(video_uri)
-    if vid_file_path==True:
         
-        logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-        df_blink = blink_detection(video_uri, facial_landmarks, r_config)
+        vid_file_path = os.path.exists(video_uri)
-        ut.save_output(df_blink, out_loc, fl_name, movement_expr_dir, csv_ext)
+        if vid_file_path==True:
 
+            logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+            df_blink = blink_detection(video_uri, facial_landmarks, r_config)
+            ut.save_output(df_blink, out_loc, fl_name, movement_expr_dir, csv_ext)
+            
+    except Exception as e:
+        logger.error('Failed to process video file')
         

dbm_lib/dbm_features/raw_features/movement/head_motion.py

@@ -178,16 +178,18 @@ def run_head_movement(video_uri, out_dir, r_config):
         video_uri: video path; input_dir : input directory for video's
         out_dir: (str) Output directory for processed output; r_config: raw variable config object
     """
+    try:
         
-    #filtering path to generate input & output path
+        #filtering path to generate input & output path
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
-    of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
+        of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
 
-    if len(of_csv_path)>0:
+        if len(of_csv_path)>0:
 
-        of_csv = of_csv_path[0]
+            of_csv = of_csv_path[0]
-        df_of = pd.read_csv(of_csv, error_bad_lines=False)
+            df_of = pd.read_csv(of_csv, error_bad_lines=False)
-        
-        logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
-        calc_head_mov(video_uri, df_of, out_loc, fl_name, r_config)
 
+            logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+            calc_head_mov(video_uri, df_of, out_loc, fl_name, r_config)
+    except Exception as e:
+        logger.error('Failed to process video file')

dbm_lib/dbm_features/raw_features/video/face_asymmetry.py

@@ -333,19 +333,23 @@ def run_face_asymmetry(video_uri, out_dir, f_cfg):
         video_uri: video path; f_cfg: face config object
         out_dir: (str) Output directory for processed output
     """
-    #Baseline logic
+    try:
-    cfr = ConfigFaceReader()
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
         
-    of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
+        #Baseline logic
-    if len(of_csv_path)>0:
+        cfr = ConfigFaceReader()
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
 
-        of_csv = of_csv_path[0]
+        of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
-        asym_df_list = calc_asym_feature(of_csv, f_cfg)
+        if len(of_csv_path)>0:
 
-        asym_final_df = pd.concat(asym_df_list, ignore_index=True)
+            of_csv = of_csv_path[0]
-        asym_final_df['dbm_master_url'] = video_uri
+            asym_df_list = calc_asym_feature(of_csv, f_cfg)
 
-        logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+            asym_final_df = pd.concat(asym_df_list, ignore_index=True)
-        ut.save_output(asym_final_df, out_loc, fl_name, face_asym_dir, csv_ext)
+            asym_final_df['dbm_master_url'] = video_uri
 
+            logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+            ut.save_output(asym_final_df, out_loc, fl_name, face_asym_dir, csv_ext)
+        
+    except Exception as e:
+        logger.error('Failed to process video file')

dbm_lib/dbm_features/raw_features/video/face_au.py

@@ -68,27 +68,31 @@ def run_face_au(video_uri, out_dir, f_cfg):
         video_uri: video path; f_cfg: face config object
         out_dir: (str) Output directory for processed output
     """
-    #Baseline logic
+    try:
-    cfr = ConfigFaceReader()
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
         
-    of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
+        #Baseline logic
-    if len(of_csv_path)>0:
+        cfr = ConfigFaceReader()
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
 
-        df_of = pd.read_csv(of_csv_path[0], error_bad_lines=False)
+        of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
-        df_au = df_of[extract_col_nm_au(df_of)]
+        if len(of_csv_path)>0:
-        df_au = df_au.copy()
 
-        df_au['frame'] = df_of['frame']
+            df_of = pd.read_csv(of_csv_path[0], error_bad_lines=False)
-        df_au['face_id'] = df_of[' face_id']
+            df_au = df_of[extract_col_nm_au(df_of)]
-        df_au['timestamp'] = df_of[' timestamp']
+            df_au = df_au.copy()
-        df_au['confidence'] = df_of[' confidence']
-        df_au['success'] = df_of[' success']
 
-        df_au = au_col_nm_map(df_au)
+            df_au['frame'] = df_of['frame']
-        df_au['dbm_master_url'] = video_uri
+            df_au['face_id'] = df_of[' face_id']
+            df_au['timestamp'] = df_of[' timestamp']
+            df_au['confidence'] = df_of[' confidence']
+            df_au['success'] = df_of[' success']
 
-        logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+            df_au = au_col_nm_map(df_au)
-        ut.save_output(df_au, out_loc, fl_name, face_au_dir, csv_ext)
+            df_au['dbm_master_url'] = video_uri
 
+            logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+            ut.save_output(df_au, out_loc, fl_name, face_au_dir, csv_ext)
+            
+    except Exception as e:
+        logger.error('Failed to process video file')
     

dbm_lib/dbm_features/raw_features/video/face_emotion_expressivity.py

@@ -60,19 +60,24 @@ def run_face_expressivity(video_uri, out_dir, f_cfg):
         video_uri: video path; f_cfg: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    #Baseline logic
+    try:
-    cfr = ConfigFaceReader()
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
         
-    of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
+        #Baseline logic
-    if len(of_csv_path)>0:
+        cfr = ConfigFaceReader()
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
 
-        df_of = pd.read_csv(of_csv_path[0], error_bad_lines=False)
+        of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
-        df_of = df_of[cfr.AU_fl]
+        if len(of_csv_path)>0:
-        expr_df_list = of_feature(df_of, cfr, f_cfg)
 
-        exp_final_df = pd.concat(expr_df_list, ignore_index=True)
+            df_of = pd.read_csv(of_csv_path[0], error_bad_lines=False)
-        exp_final_df['dbm_master_url'] = video_uri
+            df_of = df_of[cfr.AU_fl]
+            expr_df_list = of_feature(df_of, cfr, f_cfg)
 
-        logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+            exp_final_df = pd.concat(expr_df_list, ignore_index=True)
-        ut.save_output(exp_final_df, out_loc, fl_name, face_expr_dir, csv_ext)
+            exp_final_df['dbm_master_url'] = video_uri
+
+            logger.info('Processing Output file {} '.format(os.path.join(out_loc, fl_name)))
+            ut.save_output(exp_final_df, out_loc, fl_name, face_expr_dir, csv_ext)
+            
+    except Exception as e:
+        logger.error('Failed to process video file')

dbm_lib/dbm_features/raw_features/video/face_landmark.py

@@ -92,27 +92,31 @@ def run_face_landmark(video_uri, out_dir, f_cfg):
         video_uri: video path;  f_cfg: raw variable config object
         out_dir: (str) Output directory for processed output
     """
-    #Baseline logic
+    try:
-    cfr = ConfigFaceReader()
-    input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
         
-    of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
+        #Baseline logic
-    if len(of_csv_path)>0:
+        cfr = ConfigFaceReader()
+        input_loc, out_loc, fl_name = ut.filter_path(video_uri, out_dir)
 
-        df_of = pd.read_csv(of_csv_path[0], error_bad_lines=False)
+        of_csv_path = glob.glob(join(out_loc, fl_name + '_OF_features/*.csv'))
-        df_lmk = df_of[extract_col_nm_lmk(df_of)]
+        if len(of_csv_path)>0:
-        df_lmk = df_lmk.copy()
 
-        df_lmk['frame'] = df_of['frame']
+            df_of = pd.read_csv(of_csv_path[0], error_bad_lines=False)
-        df_lmk['face_id'] = df_of[' face_id']
+            df_lmk = df_of[extract_col_nm_lmk(df_of)]
-        df_lmk['timestamp'] = df_of[' timestamp']
+            df_lmk = df_lmk.copy()
-        df_lmk['confidence'] = df_of[' confidence']
-        df_lmk['success'] = df_of[' success']
 
-        df_lmk = lmk_col_nm_map(df_lmk)
+            df_lmk['frame'] = df_of['frame']
-        df_lmk = add_disp_3D(df_lmk)
+            df_lmk['face_id'] = df_of[' face_id']
-        df_lmk['dbm_master_url'] = video_uri
+            df_lmk['timestamp'] = df_of[' timestamp']
+            df_lmk['confidence'] = df_of[' confidence']
+            df_lmk['success'] = df_of[' success']
 
-        logger.info('Processing Output file {} '.format(join(out_loc, fl_name)))
+            df_lmk = lmk_col_nm_map(df_lmk)
-        ut.save_output(df_lmk, out_loc, fl_name, face_lmk_dir, csv_ext)
+            df_lmk = add_disp_3D(df_lmk)
+            df_lmk['dbm_master_url'] = video_uri
 
+            logger.info('Processing Output file {} '.format(join(out_loc, fl_name)))
+            ut.save_output(df_lmk, out_loc, fl_name, face_lmk_dir, csv_ext)
+    
+    except Exception as e:
+        logger.error('Failed to process video file')

dbm_lib/dbm_features/raw_features/video/open_face_process.py

@@ -60,8 +60,13 @@ def process_open_face(video_uri, input_dir, out_dir, of_path, dbm_group):
         out_dir: (str) Output directory for processed output; of_path: OpenFace source code path 
         
     """
-    if dbm_group != None and len(dbm_group) == 1 and 'acoustic' in dbm_group:
+    try:
-        return
         
-    filepaths = [video_uri]
+        if dbm_group != None and len(dbm_group) == 1 and 'acoustic' in dbm_group:
-    csv_filepaths = batch_open_face(filepaths, video_uri, input_dir, out_dir, of_path)
+            return
+
+        filepaths = [video_uri]
+        csv_filepaths = batch_open_face(filepaths, video_uri, input_dir, out_dir, of_path)
+        
+    except Exception as e:
+        logger.error('Failed to process video file')