spacr 0.2.32__py3-none-any.whl → 0.2.45__py3-none-any.whl

spacr/gui_utils.py

@@ -1,48 +1,19 @@
-import os, io, sys, ast, ctypes, re, ast, sqlite3
+import os, io, sys, ast, ctypes, ast, sqlite3, requests, time, traceback
+import traceback
 import tkinter as tk
 from tkinter import ttk
+import matplotlib
+import matplotlib.pyplot as plt
+matplotlib.use('Agg')
+from huggingface_hub import list_repo_files
 
 from . gui_core import initiate_root
-from .gui_elements import spacrLabel, spacrCheckbutton, AnnotateApp, spacrEntry, spacrCheck, spacrCombo, set_default_font
+from .gui_elements import AnnotateApp, spacrEntry, spacrCheck, spacrCombo, set_default_font
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
-
-def proceed_with_app_v1(root, app_name, app_func):
-    from .gui import gui_app
-
-    # Clear the current content frame
-    if hasattr(root, 'content_frame'):
-        for widget in root.content_frame.winfo_children():
-            try:
-                widget.destroy()
-            except tk.TclError as e:
-                print(f"Error destroying widget: {e}")
-    else:
-        root.content_frame = tk.Frame(root)
-        root.content_frame.grid(row=1, column=0, sticky="nsew")
-        root.grid_rowconfigure(1, weight=1)
-        root.grid_columnconfigure(0, weight=1)
-
-    # Initialize the new app in the content frame
-    if app_name == "Mask":
-        initiate_root(root.content_frame, 'mask')
-    elif app_name == "Measure":
-        initiate_root(root.content_frame, 'measure')
-    elif app_name == "Classify":
-        initiate_root(root.content_frame, 'classify')
-    elif app_name == "Sequencing":
-        initiate_root(root.content_frame, 'sequencing')
-    elif app_name == "Umap":
-        initiate_root(root.content_frame, 'umap')
-    elif app_name == "Annotate":
-        initiate_root(root.content_frame, 'annotate')
-    elif app_name == "Make Masks":
-        initiate_root(root.content_frame, 'make_masks')
-    else:
-        raise ValueError(f"Invalid app name: {app_name}")
     
 def proceed_with_app(root, app_name, app_func):
     # Clear the current content frame
@@ -93,19 +64,25 @@ def parse_list(value):
     
 # Usage example in your create_input_field function
 def create_input_field(frame, label_text, row, var_type='entry', options=None, default_value=None):
+    from .gui_elements import set_dark_style
     label_column = 0
     widget_column = 1
 
+    style_out = set_dark_style(ttk.Style())
+
+    # Replace underscores with spaces and capitalize the first letter
+    label_text = label_text.replace('_', ' ').capitalize()
+
     # Configure the column widths
     frame.grid_columnconfigure(label_column, weight=0)  # Allow the label column to expand
     frame.grid_columnconfigure(widget_column, weight=1)  # Allow the widget column to expand
 
-    # Right-align the label text and the label itself
-    label = ttk.Label(frame, text=label_text, background="black", foreground="white", anchor='e', justify='right')
-    label.grid(column=label_column, row=row, sticky=tk.E, padx=(5, 2), pady=5)  # Align label to the right
+    # Create and configure the label
+    label = ttk.Label(frame, text=label_text, background=style_out['bg_color'], foreground=style_out['fg_color'], font=(style_out['font_family'], style_out['font_size']), anchor='e', justify='right')
+    label.grid(column=label_column, row=row, sticky=tk.E, padx=(5, 2), pady=5)
 
     if var_type == 'entry':
-        var = tk.StringVar(value=default_value)  # Set default value
+        var = tk.StringVar(value=default_value)
         entry = spacrEntry(frame, textvariable=var, outline=False)
         entry.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
         return (label, entry, var)  # Return both the label and the entry, and the variable
@@ -157,23 +134,6 @@ def main_thread_update_function(root, q, fig_queue, canvas_widget):
         #ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
         while not q.empty():
             message = q.get_nowait()
-            #clean_message = ansi_escape_pattern.sub('', message)
-            #if clean_message.startswith("Progress"):
-            #    progress_label.config(text=clean_message)
-            #if clean_message.startswith("\rProgress"):
-            #    progress_label.config(text=clean_message)
-            #elif clean_message.startswith("Successfully"):
-            #    progress_label.config(text=clean_message)
-            #elif clean_message.startswith("Processing"):
-            #    progress_label.config(text=clean_message)
-            #elif clean_message.startswith("scale"):
-            #    pass
-            #elif clean_message.startswith("plot_cropped_arrays"):
-            #    pass
-            #elif clean_message == "" or clean_message == "\r" or clean_message.strip() == "":
-            #    pass
-            #else:
-            #    print(clean_message)
     except Exception as e:
         print(f"Error updating GUI canvas: {e}")
     finally:
@@ -349,4 +309,302 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
     # Call load_images after setting up the root window
     app.load_images()
 
+def set_element_size(widget):
+    screen_width = widget.winfo_screenwidth()
+    screen_height = widget.winfo_screenheight()
+    btn_size = screen_width // 40
+    bar_size = screen_width // 50
+    settings_width = screen_width // 6
+    panel_height = screen_height // 12
+    panel_width = settings_width
+    size_dict = {
+        'btn_size': btn_size,
+        'bar_size': bar_size,
+        'settings_width': settings_width,
+        'panel_width': panel_width,
+        'panel_height': panel_height
+    }
+    return size_dict
+
+def convert_settings_dict_for_gui(settings):
+    from torchvision import models as torch_models
+    torchvision_models = [name for name, obj in torch_models.__dict__.items() if callable(obj)]
+    chans = ['0', '1', '2', '3', '4', '5', '6', '7', '8', None]
+    chans_v2 = [0, 1, 2, 3, None]
+    variables = {}
+    special_cases = {
+        'metadata_type': ('combo', ['cellvoyager', 'cq1', 'nikon', 'zeis', 'custom'], 'cellvoyager'),
+        'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'cell_mask_dim': ('combo', chans, None),
+        'cell_chann_dim': ('combo', chans, None),
+        'nucleus_mask_dim': ('combo', chans, None),
+        'nucleus_chann_dim': ('combo', chans, None),
+        'pathogen_mask_dim': ('combo', chans, None),
+        'pathogen_chann_dim': ('combo', chans, None),
+        'crop_mode': ('combo', ['cell', 'nucleus', 'pathogen', '[cell, nucleus, pathogen]', '[cell,nucleus, pathogen]'], ['cell']),
+        'magnification': ('combo', [20, 40, 60], 20),
+        'nucleus_channel': ('combo', chans_v2, None),
+        'cell_channel': ('combo', chans_v2, None),
+        'channel_of_interest': ('combo', chans_v2, None),
+        'pathogen_channel': ('combo', chans_v2, None),
+        'timelapse_mode': ('combo', ['trackpy', 'btrack'], 'trackpy'),
+        'train_mode': ('combo', ['erm', 'irm'], 'erm'),
+        'clustering': ('combo', ['dbscan', 'kmean'], 'dbscan'),
+        'reduction_method': ('combo', ['umap', 'tsne'], 'umap'),
+        'model_name': ('combo', ['cyto', 'cyto_2', 'cyto_3', 'nuclei'], 'cyto'),
+        'regression_type': ('combo', ['ols','gls','wls','rlm','glm','mixed','quantile','logit','probit','poisson','lasso','ridge'], 'ols'),
+        'timelapse_objects': ('combo', ['cell', 'nucleus', 'pathogen', 'cytoplasm', None], None),
+        'model_type': ('combo', torchvision_models, 'resnet50'),
+        'optimizer_type': ('combo', ['adamw', 'adam'], 'adamw'),
+        'schedule': ('combo', ['reduce_lr_on_plateau', 'step_lr'], 'reduce_lr_on_plateau'),
+        'loss_type': ('combo', ['focal_loss', 'binary_cross_entropy_with_logits'], 'focal_loss'),
+        'normalize_by': ('combo', ['fov', 'png'], 'png'),
+        'agg_type': ('combo', ['mean', 'median'], 'mean'),
+        'grouping': ('combo', ['mean', 'median'], 'mean'),
+        'min_max': ('combo', ['allq', 'all'], 'allq'),
+        'transform': ('combo', ['log', 'sqrt', 'square', None], None)
+    }
+
+    for key, value in settings.items():
+        if key in special_cases:
+            variables[key] = special_cases[key]
+        elif isinstance(value, bool):
+            variables[key] = ('check', None, value)
+        elif isinstance(value, int) or isinstance(value, float):
+            variables[key] = ('entry', None, value)
+        elif isinstance(value, str):
+            variables[key] = ('entry', None, value)
+        elif value is None:
+            variables[key] = ('entry', None, value)
+        elif isinstance(value, list):
+            variables[key] = ('entry', None, str(value))
+        else:
+            variables[key] = ('entry', None, str(value))
+    return variables
+
+def spacrFigShow(fig_queue=None):
+    """
+    Replacement for plt.show() that queues figures instead of displaying them.
+    """
+    fig = plt.gcf()
+    if fig_queue:
+        fig_queue.put(fig)
+    else:
+        fig.show()
+    plt.close(fig)
+
+def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imports=1):
 
+    """
+    Wraps the run_multiple_simulations function to integrate with GUI processes.
+    
+    Parameters:
+    - settings: dict, The settings for the run_multiple_simulations function.
+    - q: multiprocessing.Queue, Queue for logging messages to the GUI.
+    - fig_queue: multiprocessing.Queue, Queue for sending figures to the GUI.
+    """
+
+    # Temporarily override plt.show
+    original_show = plt.show
+    plt.show = lambda: spacrFigShow(fig_queue)
+
+    try:
+        if imports == 1:
+            function(settings=settings)
+        elif imports == 2:
+            function(src=settings['src'], settings=settings)
+    except Exception as e:
+        # Send the error message to the GUI via the queue
+        errorMessage = f"Error during processing: {e}"
+        q.put(errorMessage) 
+        traceback.print_exc()
+    finally:
+        # Restore the original plt.show function
+        plt.show = original_show
+
+def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
+    from .gui_utils import process_stdout_stderr
+    from .core import preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
+    from .io import generate_cellpose_train_test
+    from .measure import measure_crop
+    from .sim import run_multiple_simulations
+    from .deep_spacr import train_test_model
+    from .sequencing import analyze_reads, map_barcodes_folder, perform_regression
+    process_stdout_stderr(q)
+
+    print(f'run_function_gui settings_type: {settings_type}') 
+    
+    if settings_type == 'mask':
+        function = preprocess_generate_masks
+        imports = 2
+    elif settings_type == 'measure':
+        function = measure_crop
+        imports = 1
+    elif settings_type == 'simulation':
+        function = run_multiple_simulations
+        imports = 1
+    elif settings_type == 'sequencing':
+        function = analyze_reads
+        imports = 1
+    elif settings_type == 'classify':
+        function = train_test_model
+        imports = 2
+    elif settings_type == 'train_cellpose':
+        function = train_cellpose
+        imports = 1
+    elif settings_type == 'ml_analyze':
+        function = generate_ml_scores
+        imports = 2
+    elif settings_type == 'cellpose_masks':
+        function = identify_masks_finetune
+        imports = 1
+    elif settings_type == 'cellpose_all':
+        function = check_cellpose_models
+        imports = 1
+    elif settings_type == 'map_barcodes':
+        function = map_barcodes_folder
+        imports = 2
+    elif settings_type == 'regression':
+        function = perform_regression
+        imports = 2
+    elif settings_type == 'recruitment':
+        function = analyze_recruitment
+        imports = 2
+    else:
+        raise ValueError(f"Invalid settings type: {settings_type}")
+    try:
+        function_gui_wrapper(function, settings, q, fig_queue, imports)
+    except Exception as e:
+        q.put(f"Error during processing: {e}")
+        traceback.print_exc()
+    finally:
+        stop_requested.value = 1
+
+def hide_all_settings(vars_dict, categories):
+    """
+    Function to initially hide all settings in the GUI.
+
+    Parameters:
+    - categories: dict, The categories of settings with their corresponding settings.
+    - vars_dict: dict, The dictionary containing the settings and their corresponding widgets.
+    """
+
+    if categories is None:
+        from .settings import categories
+
+    for category, settings in categories.items():
+        if any(setting in vars_dict for setting in settings):
+            vars_dict[category] = (None, None, tk.IntVar(value=0))
+            
+            # Initially hide all settings
+            for setting in settings:
+                if setting in vars_dict:
+                    label, widget, _ = vars_dict[setting]
+                    label.grid_remove()
+                    widget.grid_remove()
+    return vars_dict
+
+def setup_frame(parent_frame):
+    from .gui_elements import set_dark_style, set_default_font
+    style = ttk.Style(parent_frame)
+    size_dict = set_element_size(parent_frame)
+    
+    settings_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, width=size_dict['settings_width'])
+    vertical_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL)
+    horizontal_container = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL, height=size_dict['panel_height'])
+
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_rowconfigure(1, weight=0)
+    parent_frame.grid_columnconfigure(0, weight=0)  # Change this line
+    parent_frame.grid_columnconfigure(1, weight=1)  # Change this line
+
+    settings_container.grid(row=0, column=0, rowspan=2, sticky="nsew")  # Change this line
+    vertical_container.grid(row=0, column=1, sticky="nsew")  # Change this line
+    horizontal_container.grid(row=1, column=1, sticky="ew")  # Change this line
+
+    set_dark_style(style, parent_frame, [settings_container, vertical_container, horizontal_container])
+    set_default_font(parent_frame, font_name="Helvetica", size=8)
+
+    return parent_frame, vertical_container, horizontal_container, settings_container
+
+def download_hug_dataset(q, vars_dict):
+    dataset_repo_id = "einarolafsson/toxo_mito"
+    settings_repo_id = "einarolafsson/spacr_settings"
+    dataset_subfolder = "plate1"
+    local_dir = os.path.join(os.path.expanduser("~"), "datasets")  # Set to the home directory
+
+    # Download the dataset
+    try:
+        dataset_path = download_dataset(q, dataset_repo_id, dataset_subfolder, local_dir)
+        if 'src' in vars_dict:
+            vars_dict['src'][2].set(dataset_path)
+            q.put(f"Set source path to: {vars_dict['src'][2].get()}\n")
+        q.put(f"Dataset downloaded to: {dataset_path}\n")
+    except Exception as e:
+        q.put(f"Failed to download dataset: {e}\n")
+
+    # Download the settings files
+    try:
+        settings_path = download_dataset(q, settings_repo_id, "", local_dir)
+        q.put(f"Settings downloaded to: {settings_path}\n")
+    except Exception as e:
+        q.put(f"Failed to download settings: {e}\n")
+
+def download_dataset(q, repo_id, subfolder, local_dir=None, retries=5, delay=5):
+    """
+    Downloads a dataset or settings files from Hugging Face and returns the local path.
+
+    Args:
+        repo_id (str): The repository ID (e.g., 'einarolafsson/toxo_mito' or 'einarolafsson/spacr_settings').
+        subfolder (str): The subfolder path within the repository (e.g., 'plate1' or the settings subfolder).
+        local_dir (str): The local directory where the files will be saved. Defaults to the user's home directory.
+        retries (int): Number of retry attempts in case of failure.
+        delay (int): Delay in seconds between retries.
+
+    Returns:
+        str: The local path to the downloaded files.
+    """
+    if local_dir is None:
+        local_dir = os.path.join(os.path.expanduser("~"), "datasets")
+
+    local_subfolder_dir = os.path.join(local_dir, subfolder if subfolder else "settings")
+    if not os.path.exists(local_subfolder_dir):
+        os.makedirs(local_subfolder_dir)
+    elif len(os.listdir(local_subfolder_dir)) > 0:
+        q.put(f"Files already downloaded to: {local_subfolder_dir}")
+        return local_subfolder_dir
+
+    attempt = 0
+    while attempt < retries:
+        try:
+            files = list_repo_files(repo_id, repo_type="dataset")
+            subfolder_files = [file for file in files if file.startswith(subfolder) or (subfolder == "" and file.endswith('.csv'))]
+
+            for file_name in subfolder_files:
+                for download_attempt in range(retries):
+                    try:
+                        url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{file_name}?download=true"
+                        response = requests.get(url, stream=True)
+                        response.raise_for_status()
+
+                        local_file_path = os.path.join(local_subfolder_dir, os.path.basename(file_name))
+                        with open(local_file_path, 'wb') as file:
+                            for chunk in response.iter_content(chunk_size=8192):
+                                file.write(chunk)
+                        q.put(f"Downloaded file: {file_name}")
+                        break
+                    except (requests.HTTPError, requests.Timeout) as e:
+                        q.put(f"Error downloading {file_name}: {e}. Retrying in {delay} seconds...")
+                        time.sleep(delay)
+                else:
+                    raise Exception(f"Failed to download {file_name} after multiple attempts.")
+
+            return local_subfolder_dir
+
+        except (requests.HTTPError, requests.Timeout) as e:
+            q.put(f"Error downloading files: {e}. Retrying in {delay} seconds...")
+            attempt += 1
+            time.sleep(delay)
+
+    raise Exception("Failed to download files after multiple attempts.")

spacr/io.py

@@ -588,20 +588,21 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
     regular_expression = re.compile(regex)
     images_by_key = defaultdict(list)
     stack_path = os.path.join(src, 'stack')
+    files_processed = 0
     if not os.path.exists(stack_path) or (os.path.isdir(stack_path) and len(os.listdir(stack_path)) == 0):
         all_filenames = [filename for filename in os.listdir(src) if filename.endswith(img_format)]
-        print(f'All_files:{len(all_filenames)} in {src}')
+        print(f'All_files: {len(all_filenames)} in {src}')
         time_ls = []
-        processed = 0
+
         for i in range(0, len(all_filenames), batch_size):
             start = time.time()
             batch_filenames = all_filenames[i:i+batch_size]
-            processed += len(batch_filenames)
+            files_processed = 0
             for filename in batch_filenames:
                 images_by_key = _extract_filename_metadata(batch_filenames, src, images_by_key, regular_expression, metadata_type, pick_slice, skip_mode)
-
+            
             if pick_slice:
-                for key in images_by_key:
+                for i, key in enumerate(images_by_key):
                     plate, well, field, channel, mode = key
                     max_intensity_slice = max(images_by_key[key], key=lambda x: np.percentile(x, 90))
                     mip_image = Image.fromarray(max_intensity_slice)
@@ -614,16 +615,8 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
                         print(f'WARNING: A file with the same name already exists at location {output_filename}')
                     else:
                         mip_image.save(output_path)
-                    
-                    stop = time.time()
-                    duration = stop - start
-                    time_ls.append(duration)
-                    files_processed = processed
-                    files_to_process = len(all_filenames)
-                    print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type='Preprocessing filenames')
-
             else:
-                for key, images in images_by_key.items():
+                for i, (key, images) in enumerate(images_by_key.items()):
                     mip = np.max(np.stack(images), axis=0)
                     mip_image = Image.fromarray(mip)
                     plate, well, field, channel = key[:4]
@@ -636,14 +629,13 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
                         print(f'WARNING: A file with the same name already exists at location {output_filename}')
                     else:
                         mip_image.save(output_path)
-                    stop = time.time()
-                    duration = stop - start
-                    time_ls.append(duration)
-                    files_processed = processed
-                    files_to_process = len(all_filenames)
-                    print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type='Preprocessing filenames')
-
             images_by_key.clear()
+            stop = time.time()
+            duration = stop - start
+            time_ls.append(duration)
+            files_processed += len(batch_filenames)
+            files_to_process = len(all_filenames)
+            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type='Preprocessing filenames')
 
         # Move original images to a new directory
         valid_exts = [img_format]
@@ -656,6 +648,7 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
                     print(f'WARNING: A file with the same name already exists at location {move}')
                 else:
                     shutil.move(os.path.join(src, filename), move)
+    files_processed = 0
     return
 
 def _merge_file(chan_dirs, stack_dir, file_name):
@@ -975,7 +968,7 @@ def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_s
                 time_ls.append(duration)
                 files_processed = i+1
                 files_to_process = time_stack_path_lists
-                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=None, batch_size=None, operation_type="Concatinating")
+                #print_progress(files_processed, files_to_process, n_jobs=1, time_ls=None, batch_size=None, operation_type="Concatinating")
                 stack = np.stack(stack_region)
                 save_loc = os.path.join(channel_stack_loc, f'{name}.npz')
                 np.savez(save_loc, data=stack, filenames=filenames_region)
@@ -1104,7 +1097,7 @@ def _normalize_img_batch(stack, channels, save_dtype, settings):
         time_ls.append(duration)
         files_processed = i+1
         files_to_process = len(channels)
-        print_progress(files_processed, files_to_process, n_jobs=1, time_ls=None, batch_size=None, operation_type=f"Normalizing: Channel: {channel}")
+        #print_progress(files_processed, files_to_process, n_jobs=1, time_ls=None, batch_size=None, operation_type=f"Normalizing: Channel: {channel}")
 
     return normalized_stack.astype(save_dtype)
 
@@ -1191,7 +1184,6 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
         for i, path in enumerate(paths):
             start = time.time()
             array = np.load(path)
-            #array = np.take(array, channels, axis=2)
             stack_ls.append(array)
             filenames_batch.append(os.path.basename(path))
             stop = time.time()
@@ -1199,7 +1191,7 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
             time_ls.append(duration)
             files_processed = i+1
             files_to_process = nr_files
-            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=None, batch_size=None, operation_type="Concatinating")
+            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Concatinating")
 
             if (i + 1) % settings['batch_size'] == 0 or i + 1 == nr_files:
                 unique_shapes = {arr.shape[:-1] for arr in stack_ls}
@@ -1350,12 +1342,12 @@ def _normalize_stack(src, backgrounds=[100, 100, 100], remove_backgrounds=[False
                 average_time = np.mean(time_ls) if len(time_ls) > 0 else 0
                 print(f'channels:{chan_index}/{stack.shape[-1] - 1}, arrays:{array_index + 1}/{single_channel.shape[0]}, Signal:{upper:.1f}, noise:{lower:.1f}, Signal-to-noise:{average_stnr:.1f}, Time/channel:{average_time:.2f}sec')
 
-                stop = time.time()
-                duration = stop - start
-                time_ls.append(duration)
-                files_processed = file_index + 1
-                files_to_process = len(paths)
-                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Normalizing")
+                #stop = time.time()
+                #duration = stop - start
+                #time_ls.append(duration)
+                #files_processed = file_index + 1
+                #files_to_process = len(paths)
+                #print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Normalizing")
                 
             normalized_stack[:, :, :, channel] = arr_2d_normalized
         
@@ -1405,12 +1397,12 @@ def _normalize_timelapse(src, lower_percentile=2, save_dtype=np.float32):
 
                 print(f'channels:{chan_index+1}/{stack.shape[-1]}, arrays:{array_index+1}/{single_channel.shape[0]}', end='\r')
 
-                stop = time.time()
-                duration = stop - start
-                time_ls.append(duration)
-                files_processed = file_index+1
-                files_to_process = len(paths)
-                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Normalizing")
+                #stop = time.time()
+                #duration = stop - start
+                #time_ls.append(duration)
+                #files_processed = file_index+1
+                #files_to_process = len(paths)
+                #print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Normalizing")
 
         save_loc = os.path.join(output_fldr, f'{name}_norm_timelapse.npz')
         np.savez(save_loc, data=normalized_stack, filenames=filenames)
@@ -2550,7 +2542,6 @@ def _read_mask(mask_path):
         mask = img_as_uint(mask)
     return mask
 
-
 def convert_numpy_to_tiff(folder_path, limit=None):
     """
     Converts all numpy files in a folder to TIFF format and saves them in a subdirectory 'tiff'.

spacr/measure.py

@@ -941,14 +941,11 @@ def measure_crop(settings):
     settings = get_measure_crop_settings(settings)
     settings = measure_test_mode(settings)
 
-    #src_fldr = settings['src']
-    #if not os.path.basename(src_fldr).endswith('merged'):
-    #    settings['src'] = os.path.join(src_fldr, 'merged')
-    #    print(f"changed src to {src_fldr}")
-
-    #if not os.path.exists(settings['src']):
-    #    print(f'src: {settings["src"]} does not exist')
-    #    return
+    src_fldr = settings['src']
+    if not os.path.basename(src_fldr).endswith('merged'):
+        print(f"WARNING: Source folder, settings: src: {src_fldr} should end with 'merged'")
+        src_fldr = os.path.join(src_fldr, 'merged')
+        print(f"Changed source folder to: {src_fldr}")
     
     if settings['cell_mask_dim'] is None:
         settings['include_uninfected'] = True
@@ -1009,7 +1006,7 @@ def measure_crop(settings):
                 time.sleep(1)
                 files_processed = len(time_ls)
                 files_to_process = len(files)
-                print_progress(files_processed, files_to_process, n_jobs, time_ls=None)
+                print_progress(files_processed, files_to_process, n_jobs, time_ls=time_ls, operation_type='Measure and Crop')
             result.get()
 
     if settings['representative_images']: