Abs features only

tierpsy/analysis/compress/compressVideo.py

@@ -122,16 +122,16 @@ def normalizeImage(img):
     # normalise image intensities if the data type is other
     # than uint8
     image = image.astype(np.double)
-    
+
     imax = img.max()
     imin = img.min()
     factor = 255/(imax-imin)
-    
+
     imgN = ne.evaluate('(img-imin)*factor')
     imgN = imgN.astype(np.uint8)
 
     return imgN, (imin, imax)
- 
+
 def reduceBuffer(Ibuff, is_light_background):
     if is_light_background:
         return np.min(Ibuff, axis=0)
@@ -175,36 +175,36 @@ def createImgGroup(fid, name, tot_frames, im_height, im_width, is_expandable=Tru
 
     return img_dataset
 
-def initMasksGroups(fid, expected_frames, im_height, im_width, 
+def initMasksGroups(fid, expected_frames, im_height, im_width,
     attr_params, save_full_interval, is_expandable=True):
 
     # open node to store the compressed (masked) data
     mask_dataset = createImgGroup(fid, "/mask", expected_frames, im_height, im_width, is_expandable)
-    
+
 
     tot_save_full = (expected_frames // save_full_interval) + 1
     full_dataset = createImgGroup(fid, "/full_data", tot_save_full, im_height, im_width, is_expandable)
     full_dataset._v_attrs['save_interval'] = save_full_interval
-    
+
 
     assert all(x in ['expected_fps', 'is_light_background', 'microns_per_pixel'] for x in attr_params)
     set_unit_conversions(mask_dataset, **attr_params)
     set_unit_conversions(full_dataset, **attr_params)
 
     if is_expandable:
-        mean_intensity = fid.create_earray('/', 
+        mean_intensity = fid.create_earray('/',
                                         'mean_intensity',
                                         atom=tables.Float32Atom(),
                                         shape=(0,),
                                         expectedrows=expected_frames,
                                         filters=TABLE_FILTERS)
     else:
-        mean_intensity = fid.create_carray('/', 
+        mean_intensity = fid.create_carray('/',
                                         'mean_intensity',
                                         atom=tables.Float32Atom(),
                                         shape=(expected_frames,),
                                         filters=TABLE_FILTERS)
-    
+
     return mask_dataset, full_dataset, mean_intensity
 
 
@@ -230,13 +230,13 @@ def compressVideo(video_file, masked_image_file, mask_param,  expected_fps=25,
     '''
 
     #get the default values if there is any bad parameter
-    output = compress_defaults(masked_image_file, 
-                                expected_fps, 
-                                buffer_size = buffer_size, 
+    output = compress_defaults(masked_image_file,
+                                expected_fps,
+                                buffer_size = buffer_size,
                                 save_full_interval = save_full_interval)
 
-    buffer_size = output['buffer_size'] 
-    save_full_interval = output['save_full_interval'] 
+    buffer_size = output['buffer_size']
+    save_full_interval = output['save_full_interval']
 
     if len(bgnd_param) > 0:
         is_bgnd_subtraction = True
@@ -253,14 +253,14 @@ def compressVideo(video_file, masked_image_file, mask_param,  expected_fps=25,
 
     # processes identifier.
     base_name = masked_image_file.rpartition('.')[0].rpartition(os.sep)[-1]
-    
+
     # select the video reader class according to the file type.
     vid = selectVideoReader(video_file)
-    
+
     # delete any previous  if it existed
     with tables.File(masked_image_file, "w") as mask_fid:
         pass
-    
+
     #Extract metadata
     if is_extract_timestamp:
         # extract and store video metadata using ffprobe
@@ -270,7 +270,7 @@ def compressVideo(video_file, masked_image_file, mask_param,  expected_fps=25,
 
     else:
         expected_frames = 1
-    
+
     # Initialize background subtraction if required
 
     if is_bgnd_subtraction:
@@ -282,28 +282,28 @@ def compressVideo(video_file, masked_image_file, mask_param,  expected_fps=25,
     frame_number = 0
     full_frame_number = 0
     image_prev = np.zeros([])
-    
+
     # Initialise FOV splitting if needed
     if is_fov_tosplit:
-        # masked video does not exist yet so have to initialise from data  
+        # masked video does not exist yet so have to initialise from data
         # use either background or first frame
         if is_bgnd_subtraction:
             img_fov = bgnd_subtractor.bgnd.astype(np.uint8)
         else:
             ret, img_fov = vid.read()
             # close and reopen the video, to restart from the beginning
             vid.release()
-            vid = selectVideoReader(video_file); 
-        # TODO: change class creator so it only needs the video name? by using 
+            vid = selectVideoReader(video_file);
+        # TODO: change class creator so it only needs the video name? by using
         # Tierpsy's functions such as selectVideoReader it can then read the first image by itself
-        
+
         camera_serial = parse_camera_serial(masked_image_file)
-        
+
         fovsplitter = FOVMultiWellsSplitter(img_fov,
                                             camera_serial=camera_serial,
                                             px2um=microns_per_pixel,
                                             **fovsplitter_param)
-        
+
 
 
     # initialize timers
@@ -325,26 +325,26 @@ def compressVideo(video_file, masked_image_file, mask_param,  expected_fps=25,
             microns_per_pixel = microns_per_pixel,
             is_light_background = int(mask_param['is_light_background'])
             )
-        mask_dataset, full_dataset, mean_intensity = initMasksGroups(mask_fid, 
+        mask_dataset, full_dataset, mean_intensity = initMasksGroups(mask_fid,
             expected_frames, vid.height, vid.width,
             attr_params, save_full_interval)
-        
+
         if is_bgnd_subtraction:
             bg_dataset = createImgGroup(mask_fid, "/bgnd", 1, vid.height, vid.width, is_expandable=False)
             # because we only save the one background:
-            bg_dataset._v_attrs['save_interval'] = vid.frame_max-vid.first_frame + 1 
+            bg_dataset._v_attrs['save_interval'] = vid.frame_max-vid.first_frame + 1
             bg_dataset[0,:,:] = img_fov
-            
+
         if vid.dtype != np.uint8:
             # this will worm as flags to be sure that the normalization took place.
-            normalization_range = mask_fid.create_earray('/', 
+            normalization_range = mask_fid.create_earray('/',
                                         'normalization_range',
                                         atom=tables.Float32Atom(),
                                         shape=(0, 2),
                                         expectedrows=expected_frames,
                                         filters=TABLE_FILTERS
                                         )
-    
+
         while frame_number < max_frame:
 
             ret, image = vid.read()
@@ -396,23 +396,23 @@ def compressVideo(video_file, masked_image_file, mask_param,  expected_fps=25,
                 Ibuff = Ibuff[:ind_buff + 1]
 
             # mask buffer and save data into the hdf5 file
-            if (ind_buff == buffer_size - 1 or ret == 0) and Ibuff.size > 0:                
+            if (ind_buff == buffer_size - 1 or ret == 0) and Ibuff.size > 0:
                 if is_bgnd_subtraction:
                     Ibuff_b  = bgnd_subtractor.apply(Ibuff, frame_number)
                 else:
                     Ibuff_b = Ibuff
-                
+
                 #calculate the max/min in the of the buffer
                 img_reduce = reduceBuffer(Ibuff_b, mask_param['is_light_background'])
 
                 mask = getROIMask(img_reduce, **mask_param)
-                
+
                 Ibuff *= mask
 
                 # now apply the well_mask if is MWP
                 if is_fov_tosplit:
                     fovsplitter.apply_wells_mask(Ibuff) # Ibuff will be modified after this
-                    
+
                 # add buffer to the hdf5 file
                 frame_first_buff = frame_number - Ibuff.shape[0]
                 mask_dataset.append(Ibuff)
@@ -421,20 +421,17 @@ def compressVideo(video_file, masked_image_file, mask_param,  expected_fps=25,
                 # calculate the progress and put it in a string
                 progress_str = progressTime.get_str(frame_number)
                 print_flush(base_name + ' ' + progress_str)
-                
+
             # finish process
             if ret == 0:
                 break
 
         # close the video
         vid.release()
-        
+
     # save fovsplitting data
     if is_fov_tosplit:
         fovsplitter.write_fov_wells_to_file(masked_image_file)
 
     read_and_save_timestamp(masked_image_file)
     print_flush(base_name + ' Compressed video done.')
-
-
-