spacr 0.0.17__py3-none-any.whl → 0.0.20__py3-none-any.whl

spacr/core.py

@@ -6,7 +6,6 @@ import pandas as pd
 
 import cellpose
 from cellpose import models as cp_models
-from cellpose import denoise
 
 import statsmodels.formula.api as smf
 import statsmodels.api as sm
@@ -29,17 +28,9 @@ matplotlib.use('Agg')
 import torchvision.transforms as transforms
 from sklearn.model_selection import train_test_split
 from sklearn.ensemble import  IsolationForest
-
 from .logger import log_function_call
 
-#from .io import TarImageDataset, NoClassDataset, MyDataset, read_db, _copy_missclassified, read_mask, load_normalized_images_and_labels, load_images_and_labels
-#from .plot import plot_merged, plot_arrays, _plot_controls, _plot_recruitment, _imshow, _plot_histograms_and_stats, _reg_v_plot, visualize_masks, plot_comparison_results
-#from .utils import extract_boundaries, boundary_f1_score, compute_segmentation_ap, jaccard_index, dice_coefficient, _object_filter
-#from .utils import resize_images_and_labels, generate_fraction_map, MLR, fishers_odds, lasso_reg, model_metrics, _map_wells_png, check_multicollinearity, init_globals, add_images_to_tar
-#from .utils import get_paths_from_db, pick_best_model, test_model_performance, evaluate_model_performance, compute_irm_penalty
-#from .utils import _pivot_counts_table, _generate_masks, _get_cellpose_channels, annotate_conditions, _calculate_recruitment, calculate_loss, _group_by_well, choose_model
 
-@log_function_call
 def analyze_plaques(folder):
     summary_data = []
     details_data = []
@@ -76,7 +67,6 @@ def analyze_plaques(folder):
     
     print(f"Analysis completed and saved to database '{db_name}'.")
 
-@log_function_call
 def compare_masks(dir1, dir2, dir3, verbose=False):
     
     from .io import _read_mask
@@ -178,10 +168,9 @@ def generate_cp_masks(settings):
     
     dst = os.path.join(src,'masks')
     os.makedirs(dst, exist_ok=True)
-		   
+	   
     identify_masks(src, dst, model_name, channels, diameter, batch_size, flow_threshold, cellprob_threshold, figuresize, cmap, verbose, plot, save, custom_model, signal_thresholds, normalize, resize, target_height, target_width, rescale, resample, net_avg, invert, circular, percentiles, overlay, grayscale)
 
-@log_function_call
 def train_cellpose(settings):
     
     from .io import _load_normalized_images_and_labels, _load_images_and_labels
@@ -281,7 +270,6 @@ def train_cellpose(settings):
 
     return print(f"Model saved at: {model_save_path}/{model_name}")
 
-@log_function_call
 def analyze_data_reg(sequencing_loc, dv_loc, agg_type = 'mean', dv_col='pred', transform=None, min_cell_count=50, min_reads=100, min_wells=2, max_wells=1000, min_frequency=0.0,remove_outlier_genes=False, refine_model=False,by_plate=False, regression_type='mlr', alpha_value=0.01, fishers=False, fisher_threshold=0.9):
     
     from .plot import _reg_v_plot
@@ -430,7 +418,6 @@ def analyze_data_reg(sequencing_loc, dv_loc, agg_type = 'mean', dv_col='pred', t
         
         return result
 
-@log_function_call
 def analyze_data_reg(sequencing_loc, dv_loc, agg_type = 'mean', min_cell_count=50, min_reads=100, min_wells=2, max_wells=1000, remove_outlier_genes=False, refine_model=False, by_plate=False, threshold=0.5, fishers=False):
     
     from .plot import _reg_v_plot
@@ -609,7 +596,6 @@ def analyze_data_reg(sequencing_loc, dv_loc, agg_type = 'mean', min_cell_count=5
 
     return max_effects, max_effects_pvalues, model, df
 
-@log_function_call
 def regression_analasys(dv_df,sequencing_loc, min_reads=75, min_wells=2, max_wells=0, model_type = 'mlr', min_cells=100, transform='logit', min_frequency=0.05, gene_column='gene', effect_size_threshold=0.25, fishers=True, clean_regression=False, VIF_threshold=10):
     
     from .utils import generate_fraction_map, fishers_odds, model_metrics, check_multicollinearity
@@ -777,7 +763,6 @@ def regression_analasys(dv_df,sequencing_loc, min_reads=75, min_wells=2, max_wel
     
     return
 
-@log_function_call
 def merge_pred_mes(src,
                    pred_loc,
                    target='protein of interest', 
@@ -1088,7 +1073,7 @@ def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=22
             batch_prediction_pos_prob = torch.sigmoid(outputs).cpu().numpy()
             prediction_pos_probs.extend(batch_prediction_pos_prob.tolist())
             filenames_list.extend(filenames)
-            print(f'\rbatch: {batch_idx}/{len(data_loader)}', end='\r', flush=True)
+            print(f'batch: {batch_idx}/{len(data_loader)}', end='\r', flush=True)
 
     data = {'path':filenames_list, 'pred':prediction_pos_probs}
     df = pd.DataFrame(data, index=None)
@@ -1649,15 +1634,27 @@ def analyze_recruitment(src, metadata_settings, advanced_settings):
     cells,wells = _results_to_csv(src, df, df_well)
     return [cells,wells]
 
-@log_function_call
-def preprocess_generate_masks(src, settings={},advanced_settings={}):
+def preprocess_generate_masks(src, settings={}):
 
     from .io import preprocess_img_data, _load_and_concatenate_arrays
     from .plot import plot_merged, plot_arrays
     from .utils import _pivot_counts_table
-    
-    settings = {**settings, **advanced_settings}
+
+    settings['fps'] = 2
+    settings['remove_background'] = True
+    settings['lower_quantile'] = 0.02
+    settings['merge'] = False
+    settings['normalize_plots'] = True
+    settings['all_to_mip'] = False
+    settings['pick_slice'] = False
+    settings['skip_mode'] = src
+    settings['workers'] = os.cpu_count()-4
+    settings['verbose'] = True
+    settings['examples_to_plot'] = 1
     settings['src'] = src
+    settings['upscale'] = False
+    settings['upscale_factor'] = 2.0
+
     settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
     settings_csv = os.path.join(src,'settings','preprocess_generate_masks_settings.csv')
     os.makedirs(os.path.join(src,'settings'), exist_ok=True)
@@ -1676,7 +1673,7 @@ def preprocess_generate_masks(src, settings={},advanced_settings={}):
         settings['save'] = [settings['save']]*3
 
     if settings['preprocess']:
-        preprocess_img_data(settings)
+        settings, src = preprocess_img_data(settings)
         
     if settings['masks']:
         mask_src = os.path.join(src, 'norm_channel_stack')
@@ -1747,6 +1744,7 @@ def preprocess_generate_masks(src, settings={},advanced_settings={}):
             
     torch.cuda.empty_cache()
     gc.collect()
+    print("Successfully completed run")
     return
 
 def identify_masks_finetune(src, dst, model_name, channels, diameter, batch_size, flow_threshold=30, cellprob_threshold=1, figuresize=25, cmap='inferno', verbose=False, plot=False, save=False, custom_model=None, signal_thresholds=1000, normalize=True, resize=False, target_height=None, target_width=None, rescale=True, resample=True, net_avg=False, invert=False, circular=False, percentiles=None, overlay=True, grayscale=False):
@@ -1836,8 +1834,7 @@ def identify_masks_finetune(src, dst, model_name, channels, diameter, batch_size
                 cv2.imwrite(output_filename, mask)
     return
 
-@log_function_call
-def identify_masks(src, object_type, model_name, batch_size, channels, diameter, minimum_size, maximum_size, flow_threshold=30, cellprob_threshold=1, figuresize=25, cmap='inferno', refine_masks=True, filter_size=True, filter_dimm=True, remove_border_objects=False, verbose=False, plot=False, merge=False, save=True, start_at=0, file_type='.npz', net_avg=True, resample=True, timelapse=False, timelapse_displacement=None, timelapse_frame_limits=None, timelapse_memory=3, timelapse_remove_transient=False, timelapse_mode='btrack', timelapse_objects='cell'):
+def identify_masks(src, object_type, model_name, batch_size, channels, diameter, minimum_size, maximum_size, filter_intensity, flow_threshold=30, cellprob_threshold=1, figuresize=25, cmap='inferno', refine_masks=True, filter_size=True, filter_dimm=True, remove_border_objects=False, verbose=False, plot=False, merge=False, save=True, start_at=0, file_type='.npz', net_avg=True, resample=True, timelapse=False, timelapse_displacement=None, timelapse_frame_limits=None, timelapse_memory=3, timelapse_remove_transient=False, timelapse_mode='btrack', timelapse_objects='cell'):
     """
     Identify masks from the source images.
 
@@ -1891,7 +1888,8 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
         print(f'Torch CUDA is not available, using CPU')
     
     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model = cp_models.Cellpose(gpu=True, model_type=model_name, device=device) #net_avg=net_avg
+    model = cp_models.Cellpose(gpu=True, model_type=model_name, device=device)
+
     if file_type == '.npz':
         paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
     else:
@@ -1918,9 +1916,6 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
     
     average_sizes = []
     time_ls = []
-    moving_avg_q1 = 0
-    moving_avg_q3 = 0
-    moving_count = 0
     for file_index, path in enumerate(paths):
 
         name = os.path.basename(path)
@@ -1961,7 +1956,8 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
                 if not plot:
                     batch, batch_filenames = _check_masks(batch, batch_filenames, output_folder)
                 if batch.size == 0:
-                    print(f'Processing {file_index}/{len(paths)}: Images/N100pz {batch.shape[0]}', end='\r', flush=True)
+                    print(f'Processing: {file_index}/{len(paths)}: Images/N100pz {batch.shape[0]}')
+                    #print(f'Processing {file_index}/{len(paths)}: Images/N100pz {batch.shape[0]}', end='\r', flush=True)
                     continue
                 if batch.max() > 1:
                     batch = batch / batch.max()
@@ -1977,7 +1973,7 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
                     
                 cellpose_batch_size = _get_cellpose_batch_size()
                 
-                model = cellpose.denoise.DenoiseModel(model_type=f"denoise_{model_name}", gpu=True)
+                #model = cellpose.denoise.DenoiseModel(model_type=f"denoise_{model_name}", gpu=True)
                    
                 masks, flows, _, _ = model.eval(x=batch,
                                                 batch_size=cellpose_batch_size,
@@ -1989,9 +1985,9 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
                                                 cellprob_threshold=cellprob_threshold,
                                                 rescale=None,
                                                 resample=resample,
-                                                #net_avg=net_avg,
                                                 stitch_threshold=stitch_threshold,
                                                 progress=None)
+                
                 print('Masks shape',masks.shape)                
                 if timelapse:
                     _save_object_counts_to_database(masks, object_type, batch_filenames, count_loc, added_string='_timelapse')
@@ -2015,7 +2011,7 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
 
                 else:
                     _save_object_counts_to_database(masks, object_type, batch_filenames, count_loc, added_string='_before_filtration')
-                    mask_stack = _filter_cp_masks(masks, flows, refine_masks, filter_size, minimum_size, maximum_size, remove_border_objects, merge, filter_dimm, batch, moving_avg_q1, moving_avg_q3, moving_count, plot, figuresize)
+                    mask_stack = _filter_cp_masks(masks, flows, filter_size, filter_intensity, minimum_size, maximum_size, remove_border_objects, merge, batch, plot, figuresize)
                     _save_object_counts_to_database(mask_stack, object_type, batch_filenames, count_loc, added_string='_after_filtration')
 
                 if not np.any(mask_stack):
@@ -2032,7 +2028,8 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
             average_time = np.mean(time_ls) if len(time_ls) > 0 else 0
             time_in_min = average_time/60
             time_per_mask = average_time/batch_size
-            print(f'Processing {len(paths)}  files with {batch_size} imgs: {(file_index+1)*(batch_size+1)}/{(len(paths))*(batch_size+1)}: Time/batch {time_in_min:.3f} min: Time/mask {time_per_mask:.3f}sec: {object_type} size: {overall_average_size:.3f} px2', end='\r', flush=True)
+            print(f'Processing: {len(paths)}  files with {batch_size} imgs: {(file_index+1)*(batch_size+1)}/{(len(paths))*(batch_size+1)}: Time/batch {time_in_min:.3f} min: Time/mask {time_per_mask:.3f}sec: {object_type} size: {overall_average_size:.3f} px2')
+            #print(f'Processing {len(paths)}  files with {batch_size} imgs: {(file_index+1)*(batch_size+1)}/{(len(paths))*(batch_size+1)}: Time/batch {time_in_min:.3f} min: Time/mask {time_per_mask:.3f}sec: {object_type} size: {overall_average_size:.3f} px2', end='\r', flush=True)
             if not timelapse:
                 if plot:
                     plot_masks(batch, mask_stack, flows, figuresize=figuresize, cmap=cmap, nr=batch_size, file_type='.npz')
@@ -2046,10 +2043,13 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
         gc.collect()
     return
 
-@log_function_call
-def generate_cellpose_masks(src, settings, object_type):
+def all_elements_match(list1, list2):
+    # Check if all elements in list1 are in list2
+    return all(element in list2 for element in list1)
+
+def generate_cellpose_masks_v1(src, settings, object_type):
     
-    from .utils import _masks_to_masks_stack, _filter_cp_masks, _get_cellpose_batch_size, _get_object_settings, _get_cellpose_channels
+    from .utils import _masks_to_masks_stack, _filter_cp_masks, _get_cellpose_batch_size, _get_object_settings, _get_cellpose_channels, mask_object_count
     from .io import _create_database, _save_object_counts_to_database, _check_masks, _get_avg_object_size
     from .timelapse import _npz_to_movie, _btrack_track_cells, _trackpy_track_cells
     from .plot import plot_masks
@@ -2076,7 +2076,9 @@ def generate_cellpose_masks(src, settings, object_type):
     object_settings = _get_object_settings(object_type, settings)
     model_name = object_settings['model_name']
     
-    cellpose_channels = _get_cellpose_channels(settings['nucleus_channel'], settings['pathogen_channel'], settings['cell_channel'])
+    cellpose_channels = _get_cellpose_channels(src, settings['nucleus_channel'], settings['pathogen_channel'], settings['cell_channel'])
+    if settings['verbose']:
+        print(cellpose_channels)
     channels = cellpose_channels[object_type]
     cellpose_batch_size = _get_cellpose_batch_size()
     
@@ -2094,10 +2096,7 @@ def generate_cellpose_masks(src, settings, object_type):
     
     average_sizes = []
     time_ls = []
-    moving_avg_q1 = 0
-    moving_avg_q3 = 0
-    moving_count = 0
-    
+
     for file_index, path in enumerate(paths):
         name = os.path.basename(path)
         name, ext = os.path.splitext(name)
@@ -2108,16 +2107,22 @@ def generate_cellpose_masks(src, settings, object_type):
             stack = data['data']
             filenames = data['filenames']
         if settings['timelapse']:
+
+            trackable_objects = ['cell','nucleus','pathogen']
+            if not all_elements_match(settings['timelapse_objects'], trackable_objects):
+                print(f'timelapse_objects {settings["timelapse_objects"]} must be a subset of {trackable_objects}')
+                return
+
             if len(stack) != batch_size:
                 print(f'Changed batch_size:{batch_size} to {len(stack)}, data length:{len(stack)}')
-                settings['batch_size'] = len(stack)
+                settings['timelapse_batch_size'] = len(stack)
                 batch_size = len(stack)
                 if isinstance(timelapse_frame_limits, list):
                     if len(timelapse_frame_limits) >= 2:
                         stack = stack[timelapse_frame_limits[0]: timelapse_frame_limits[1], :, :, :].astype(stack.dtype)
                         filenames = filenames[timelapse_frame_limits[0]: timelapse_frame_limits[1]]
                         batch_size = len(stack)
-                        print(f'Cut batch an indecies: {timelapse_frame_limits}, New batch_size: {batch_size} ')
+                        print(f'Cut batch at indecies: {timelapse_frame_limits}, New batch_size: {batch_size} ')
 
         for i in range(0, stack.shape[0], batch_size):
             mask_stack = []
@@ -2133,7 +2138,7 @@ def generate_cellpose_masks(src, settings, object_type):
             if not settings['plot']:
                 batch, batch_filenames = _check_masks(batch, batch_filenames, output_folder)
             if batch.size == 0:
-                print(f'Processing {file_index}/{len(paths)}: Images/N100pz {batch.shape[0]}', end='\r', flush=True)
+                print(f'Processing {file_index}/{len(paths)}: Images/npz {batch.shape[0]}')
                 continue
             if batch.max() > 1:
                 batch = batch / batch.max()
@@ -2146,10 +2151,8 @@ def generate_cellpose_masks(src, settings, object_type):
                 _npz_to_movie(batch, batch_filenames, save_path, fps=2)
             else:
                 stitch_threshold=0.0
-            #print(batch.shape)
-            #batch, _, _, _ = dn.eval(x=batch, channels=chans, diameter=object_settings['diameter'])
-            #batch = np.stack((batch, batch), axis=-1)
-            #print(f'object: {object_type} chans : {chans} channels : {channels} model: {model_name}')
+
+            print('batch.shape',batch.shape)
             masks, flows, _, _ = model.eval(x=batch,
                                             batch_size=cellpose_batch_size,
                                             normalize=False,
@@ -2161,9 +2164,220 @@ def generate_cellpose_masks(src, settings, object_type):
                                             rescale=None,
                                             resample=object_settings['resample'],
                                             stitch_threshold=stitch_threshold)
-                                            #progress=None)
+            
+            if timelapse:
+                if settings['plot']:
+                    for idx, (mask, flow, image) in enumerate(zip(masks, flows[0], batch)):
+                        if idx == 0:
+                            num_objects = mask_object_count(mask)
+                            print(f'Number of objects: {num_objects}')
+                            plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
+
+                _save_object_counts_to_database(masks, object_type, batch_filenames, count_loc, added_string='_timelapse')
+                if object_type in timelapse_objects:
+                    if timelapse_mode == 'btrack':
+                        if not timelapse_displacement is None:
+                            radius = timelapse_displacement
+                        else:
+                            radius = 100
+
+                        workers = os.cpu_count()-2
+                        if workers < 1:
+                            workers = 1
+
+                        mask_stack = _btrack_track_cells(src=src,
+                                                         name=name,
+                                                         batch_filenames=batch_filenames,
+                                                         object_type=object_type,
+                                                         plot=settings['plot'],
+                                                         save=settings['save'],
+                                                         masks_3D=masks,
+                                                         mode=timelapse_mode,
+                                                         timelapse_remove_transient=timelapse_remove_transient,
+                                                         radius=radius,
+                                                         workers=workers)
+                    if timelapse_mode == 'trackpy':
+                        mask_stack = _trackpy_track_cells(src=src,
+                                                          name=name,
+                                                          batch_filenames=batch_filenames,
+                                                          object_type=object_type,
+                                                          masks=masks,
+                                                          timelapse_displacement=timelapse_displacement,
+                                                          timelapse_memory=timelapse_memory,
+                                                          timelapse_remove_transient=timelapse_remove_transient,
+                                                          plot=settings['plot'],
+                                                          save=settings['save'],
+                                                          mode=timelapse_mode)
+                else:
+                    mask_stack = _masks_to_masks_stack(masks)
+
+            else:
+                _save_object_counts_to_database(masks, object_type, batch_filenames, count_loc, added_string='_before_filtration')
+                mask_stack = _filter_cp_masks(masks=masks,
+                                              flows=flows,
+                                              filter_size=object_settings['filter_size'],
+                                              filter_intensity=object_settings['filter_intensity'],
+                                              minimum_size=object_settings['minimum_size'],
+                                              maximum_size=object_settings['maximum_size'],
+                                              remove_border_objects=object_settings['remove_border_objects'],
+                                              merge=False,
+                                              batch=batch,
+                                              plot=settings['plot'],
+                                              figuresize=figuresize)
+                
+                _save_object_counts_to_database(mask_stack, object_type, batch_filenames, count_loc, added_string='_after_filtration')
+
+            if not np.any(mask_stack):
+                average_obj_size = 0
+            else:
+                average_obj_size = _get_avg_object_size(mask_stack)
+
+            average_sizes.append(average_obj_size) 
+            overall_average_size = np.mean(average_sizes) if len(average_sizes) > 0 else 0
+
+        stop = time.time()
+        duration = (stop - start)
+        time_ls.append(duration)
+        average_time = np.mean(time_ls) if len(time_ls) > 0 else 0
+        time_in_min = average_time/60
+        time_per_mask = average_time/batch_size
+        print(f'Processing {len(paths)}  files with {batch_size} imgs: {(file_index+1)*(batch_size+1)}/{(len(paths))*(batch_size+1)}: Time/batch {time_in_min:.3f} min: Time/mask {time_per_mask:.3f}sec: {object_type} size: {overall_average_size:.3f} px2')
+        if not timelapse:
+            if settings['plot']:
+                plot_masks(batch, mask_stack, flows, figuresize=figuresize, cmap='inferno', nr=batch_size)
+        if settings['save']:
+            for mask_index, mask in enumerate(mask_stack):
+                output_filename = os.path.join(output_folder, batch_filenames[mask_index])
+                np.save(output_filename, mask)
+            mask_stack = []
+            batch_filenames = []
+        gc.collect()
+    torch.cuda.empty_cache()
+    return
+
+def generate_cellpose_masks(src, settings, object_type):
+    
+    from .utils import _masks_to_masks_stack, _filter_cp_masks, _get_cellpose_batch_size, _get_object_settings, _get_cellpose_channels, _choose_model, mask_object_count
+    from .io import _create_database, _save_object_counts_to_database, _check_masks, _get_avg_object_size
+    from .timelapse import _npz_to_movie, _btrack_track_cells, _trackpy_track_cells
+    from .plot import plot_masks
+    
+    gc.collect()
+    if not torch.cuda.is_available():
+        print(f'Torch CUDA is not available, using CPU')
+        
+    figuresize=25
+    timelapse = settings['timelapse']
+    
+    if timelapse:
+        timelapse_displacement = settings['timelapse_displacement']
+        timelapse_frame_limits = settings['timelapse_frame_limits']
+        timelapse_memory = settings['timelapse_memory']
+        timelapse_remove_transient = settings['timelapse_remove_transient']
+        timelapse_mode = settings['timelapse_mode']
+        timelapse_objects = settings['timelapse_objects']
+    
+    batch_size = settings['batch_size']
+    cellprob_threshold = settings[f'{object_type}_CP_prob']
+    flow_threshold = 30
+    
+    object_settings = _get_object_settings(object_type, settings)
+    model_name = object_settings['model_name']
+    
+    cellpose_channels = _get_cellpose_channels(src, settings['nucleus_channel'], settings['pathogen_channel'], settings['cell_channel'])
+    if settings['verbose']:
+        print(cellpose_channels)
 
+    channels = cellpose_channels[object_type]
+    cellpose_batch_size = _get_cellpose_batch_size()
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    model = _choose_model(model_name, device, object_type='cell', restore_type=None)
+    chans = [2, 1] if model_name == 'cyto2' else [0,0] if model_name == 'nucleus' else [2,0] if model_name == 'cyto' else [2, 0] if model_name == 'cyto3' else [2, 0]
+    paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]    
+    
+    count_loc = os.path.dirname(src)+'/measurements/measurements.db'
+    os.makedirs(os.path.dirname(src)+'/measurements', exist_ok=True)
+    _create_database(count_loc)
+    
+    average_sizes = []
+    time_ls = []
+    for file_index, path in enumerate(paths):
+        name = os.path.basename(path)
+        name, ext = os.path.splitext(name)
+        output_folder = os.path.join(os.path.dirname(path), object_type+'_mask_stack')
+        os.makedirs(output_folder, exist_ok=True)
+        overall_average_size = 0
+        with np.load(path) as data:
+            stack = data['data']
+            filenames = data['filenames']
+        if settings['timelapse']:
+
+            trackable_objects = ['cell','nucleus','pathogen']
+            if not all_elements_match(settings['timelapse_objects'], trackable_objects):
+                print(f'timelapse_objects {settings["timelapse_objects"]} must be a subset of {trackable_objects}')
+                return
+
+            if len(stack) != batch_size:
+                print(f'Changed batch_size:{batch_size} to {len(stack)}, data length:{len(stack)}')
+                settings['timelapse_batch_size'] = len(stack)
+                batch_size = len(stack)
+                if isinstance(timelapse_frame_limits, list):
+                    if len(timelapse_frame_limits) >= 2:
+                        stack = stack[timelapse_frame_limits[0]: timelapse_frame_limits[1], :, :, :].astype(stack.dtype)
+                        filenames = filenames[timelapse_frame_limits[0]: timelapse_frame_limits[1]]
+                        batch_size = len(stack)
+                        print(f'Cut batch at indecies: {timelapse_frame_limits}, New batch_size: {batch_size} ')
+
+        for i in range(0, stack.shape[0], batch_size):
+            mask_stack = []
+            start = time.time()
+
+            if stack.shape[3] == 1:
+                batch = stack[i: i+batch_size, :, :, [0,0]].astype(stack.dtype)
+            else:
+                batch = stack[i: i+batch_size, :, :, channels].astype(stack.dtype)
+
+            batch_filenames = filenames[i: i+batch_size].tolist()
+
+            if not settings['plot']:
+                batch, batch_filenames = _check_masks(batch, batch_filenames, output_folder)
+            if batch.size == 0:
+                print(f'Processing {file_index}/{len(paths)}: Images/npz {batch.shape[0]}')
+                continue
+            if batch.max() > 1:
+                batch = batch / batch.max()
+
+            if timelapse:
+                stitch_threshold=100.0
+                movie_path = os.path.join(os.path.dirname(src), 'movies')
+                os.makedirs(movie_path, exist_ok=True)
+                save_path = os.path.join(movie_path, f'timelapse_{object_type}_{name}.mp4')
+                _npz_to_movie(batch, batch_filenames, save_path, fps=2)
+            else:
+                stitch_threshold=0.0
+
+            print('batch.shape',batch.shape)
+            masks, flows, _, _ = model.eval(x=batch,
+                                            batch_size=cellpose_batch_size,
+                                            normalize=False,
+                                            channels=chans,
+                                            channel_axis=3,
+                                            diameter=object_settings['diameter'],
+                                            flow_threshold=flow_threshold,
+                                            cellprob_threshold=cellprob_threshold,
+                                            rescale=None,
+                                            resample=object_settings['resample'],
+                                            stitch_threshold=stitch_threshold)
+            
             if timelapse:
+
+                if settings['plot']:
+                    for idx, (mask, flow, image) in enumerate(zip(masks, flows[0], batch)):
+                        if idx == 0:
+                            num_objects = mask_object_count(mask)
+                            print(f'Number of objects: {num_objects}')
+                            plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
+
                 _save_object_counts_to_database(masks, object_type, batch_filenames, count_loc, added_string='_timelapse')
                 if object_type in timelapse_objects:
                     if timelapse_mode == 'btrack':
@@ -2192,13 +2406,13 @@ def generate_cellpose_masks(src, settings, object_type):
                                                           name=name,
                                                           batch_filenames=batch_filenames,
                                                           object_type=object_type,
-                                                          masks_3D=masks,
+                                                          masks=masks,
                                                           timelapse_displacement=timelapse_displacement,
                                                           timelapse_memory=timelapse_memory,
                                                           timelapse_remove_transient=timelapse_remove_transient,
                                                           plot=settings['plot'],
                                                           save=settings['save'],
-                                                          timelapse_mode=timelapse_mode)
+                                                          mode=timelapse_mode)
                 else:
                     mask_stack = _masks_to_masks_stack(masks)
 
@@ -2207,15 +2421,12 @@ def generate_cellpose_masks(src, settings, object_type):
                 mask_stack = _filter_cp_masks(masks=masks,
                                               flows=flows,
                                               filter_size=object_settings['filter_size'],
+                                              filter_intensity=object_settings['filter_intensity'],
                                               minimum_size=object_settings['minimum_size'],
                                               maximum_size=object_settings['maximum_size'],
                                               remove_border_objects=object_settings['remove_border_objects'],
                                               merge=False,
-                                              filter_dimm=object_settings['filter_dimm'], 
                                               batch=batch,
-                                              moving_avg_q1=moving_avg_q1,
-                                              moving_avg_q3=moving_avg_q3,
-                                              moving_count=moving_count,
                                               plot=settings['plot'],
                                               figuresize=figuresize)
                 
@@ -2235,7 +2446,7 @@ def generate_cellpose_masks(src, settings, object_type):
         average_time = np.mean(time_ls) if len(time_ls) > 0 else 0
         time_in_min = average_time/60
         time_per_mask = average_time/batch_size
-        print(f'Processing {len(paths)}  files with {batch_size} imgs: {(file_index+1)*(batch_size+1)}/{(len(paths))*(batch_size+1)}: Time/batch {time_in_min:.3f} min: Time/mask {time_per_mask:.3f}sec: {object_type} size: {overall_average_size:.3f} px2', end='\r', flush=True)
+        print(f'Processing {len(paths)}  files with {batch_size} imgs: {(file_index+1)*(batch_size+1)}/{(len(paths))*(batch_size+1)}: Time/batch {time_in_min:.3f} min: Time/mask {time_per_mask:.3f}sec: {object_type} size: {overall_average_size:.3f} px2')
         if not timelapse:
             if settings['plot']:
                 plot_masks(batch, mask_stack, flows, figuresize=figuresize, cmap='inferno', nr=batch_size)