spacr 0.2.41__py3-none-any.whl → 0.2.46__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:
@@ -352,11 +312,313 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
 def set_element_size(widget):
     screen_width = widget.winfo_screenwidth()
     screen_height = widget.winfo_screenheight()
-    btn_size = screen_width/50
-    bar_size = screen_width/75
-
-    size_dict = {'btn_size':btn_size,
-                 'bar_size':bar_size}
+    btn_size = screen_width // 40
+    bar_size = screen_width // 50
+    settings_width = screen_width // 5
+    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)
+    style_out = set_dark_style(style)
+
+    settings_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, width=size_dict['settings_width'], bg=style_out['bg_color'])
+    vertical_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, bg=style_out['bg_color'])
+    horizontal_container = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL, height=size_dict['panel_height'], bg=style_out['bg_color'])
+
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_rowconfigure(1, weight=0)
+    parent_frame.grid_columnconfigure(0, weight=0)
+    parent_frame.grid_columnconfigure(1, weight=1)
+
+    settings_container.grid(row=0, column=0, rowspan=2, sticky="nsew")
+    vertical_container.grid(row=0, column=1, sticky="nsew")
+    horizontal_container.grid(row=1, column=1, sticky="nsew")
+
+    # Lock the width of the horizontal_container
+    horizontal_container.update_idletasks()  # Ensure geometry manager calculates size
+    fixed_width = horizontal_container.winfo_width()
+    parent_frame.grid_columnconfigure(1, weight=0)
+    horizontal_container.config(width=fixed_width)
+
+    tk.Label(settings_container, text="Settings Container", bg=style_out['bg_color']).pack(fill=tk.BOTH, expand=True)
+    tk.Label(vertical_container, text="Vertical Container", bg=style_out['bg_color']).pack(fill=tk.BOTH, expand=True)
+
+    set_dark_style(style, parent_frame, [settings_container, vertical_container, horizontal_container])
+    
+    size = style_out['font_size'] - 2
+    
+    set_default_font(parent_frame, font_name=style_out['font_family'], size=size)
+
+    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")
+
+    # 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):
+
+        for idx in range(0, len(all_filenames), batch_size):
             start = time.time()
-            batch_filenames = all_filenames[i:i+batch_size]
-            processed += len(batch_filenames)
+            batch_filenames = all_filenames[idx:idx+batch_size]
+            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)
@@ -609,21 +610,19 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
                     os.makedirs(output_dir, exist_ok=True)
                     output_filename = f'{plate}_{well}_{field}.tif'
                     output_path = os.path.join(output_dir, output_filename)
-
-                    if os.path.exists(output_path):                        
-                        print(f'WARNING: A file with the same name already exists at location {output_filename}')
-                    else:
-                        mip_image.save(output_path)
-                    
+                    files_processed += 1
                     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')
 
+                    if os.path.exists(output_path):                        
+                        print(f'WARNING: A file with the same name already exists at location {output_filename}')
+                    else:
+                        mip_image.save(output_path)
             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]
@@ -631,18 +630,17 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
                     os.makedirs(output_dir, exist_ok=True)
                     output_filename = f'{plate}_{well}_{field}.tif'
                     output_path = os.path.join(output_dir, output_filename)
-
-                    if os.path.exists(output_path):                        
-                        print(f'WARNING: A file with the same name already exists at location {output_filename}')
-                    else:
-                        mip_image.save(output_path)
+                    files_processed += 1
                     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')
 
+                    if os.path.exists(output_path):                        
+                        print(f'WARNING: A file with the same name already exists at location {output_filename}')
+                    else:
+                        mip_image.save(output_path)
             images_by_key.clear()
 
         # Move original images to a new directory
@@ -656,6 +654,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 +974,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=time_ls, 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)
@@ -1006,7 +1005,7 @@ def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_s
             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) % batch_size == 0 or i+1 == nr_files:
                 unique_shapes = {arr.shape[:-1] for arr in stack_ls}
                 if len(unique_shapes) > 1:
@@ -1104,7 +1103,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=time_ls, batch_size=None, operation_type=f"Normalizing")
 
     return normalized_stack.astype(save_dtype)
 
@@ -1151,7 +1150,6 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
                         parts = file.split('_')
                         name = parts[0] + '_' + parts[1] + '_' + parts[2]
                     array = np.load(path)
-                    #array = np.take(array, channels, axis=2)
                     stack_region.append(array)
                     filenames_region.append(os.path.basename(path))
                 stop = time.time()
@@ -1159,7 +1157,7 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
                 time_ls.append(duration)
                 files_processed = i+1
                 files_to_process = len(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=time_ls, batch_size=None, operation_type="Concatinating")
                 stack = np.stack(stack_region)
 
                 normalized_stack = _normalize_img_batch(stack=stack,
@@ -1188,18 +1186,18 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
         stack_ls = []
         filenames_batch = []
         time_ls = []
+        files_processed = 0
         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()
             duration = stop - start
             time_ls.append(duration)
-            files_processed = i+1
+            files_processed += 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 +1348,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 +1403,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)
@@ -1620,8 +1618,8 @@ def preprocess_img_data(settings):
                               save_dtype=np.float32,
                               settings=settings)
 
-    if plot:
-        _plot_4D_arrays(src+'/norm_channel_stack', nr_npz=1, nr=nr)
+    #if plot:
+    #    _plot_4D_arrays(src+'/norm_channel_stack', nr_npz=1, nr=nr)
 
     return settings, src
     
@@ -1951,7 +1949,7 @@ def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_di
     all_imgs = len(os.listdir(reference_folder))
     time_ls = []
     # Iterate through each file in the reference folder
-    for filename in os.listdir(reference_folder):
+    for idx, filename in enumerate(os.listdir(reference_folder)):
         start = time.time()
         stack_ls = []
         if filename.endswith('.npy'):
@@ -2012,7 +2010,7 @@ def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_di
         stop = time.time()
         duration = stop - start
         time_ls.append(duration)
-        files_processed = count
+        files_processed = idx+1
         files_to_process = all_imgs
         print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Merging Arrays")
 
@@ -2550,7 +2548,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'.