spacr 0.2.3__py3-none-any.whl → 0.2.31__py3-none-any.whl

spacr/gui_elements.py

@@ -3,7 +3,7 @@ import tkinter as tk
 from tkinter import ttk
 import tkinter.font as tkFont
 from queue import Queue
-from tkinter import Label
+from tkinter import Label, Frame, Button
 import numpy as np
 from PIL import Image, ImageOps, ImageTk
 from concurrent.futures import ThreadPoolExecutor
@@ -368,9 +368,11 @@ class spacrProgressBar(ttk.Progressbar):
 
         # Get the style colors
         style_out = set_dark_style(ttk.Style())
-        self.inactive_color = style_out['inactive_color']
+       
+        self.fg_color = style_out['fg_color']
         self.bg_color = style_out['bg_color']
         self.active_color = style_out['active_color']
+        self.inactive_color = style_out['inactive_color']
 
         # Configure the style for the progress bar
         self.style = ttk.Style()
@@ -387,6 +389,29 @@ class spacrProgressBar(ttk.Progressbar):
         # Set initial value to 0
         self['value'] = 0
 
+        # Create the progress label
+        self.progress_label = tk.Label(parent, text="Processing: 0/0", anchor='w', justify='left', bg=self.inactive_color, fg=self.fg_color)
+        self.progress_label.grid(row=1, column=0, columnspan=2, pady=5, padx=5, sticky='ew')
+
+        # Initialize attributes for time and operation
+        self.operation_type = None
+        self.time_image = None
+        self.time_batch = None
+        self.time_left = None
+
+    def update_label(self):
+        # Update the progress label with current progress and additional info
+        label_text = f"Processing: {self['value']}/{self['maximum']}"
+        if self.operation_type:
+            label_text += f", {self.operation_type}"
+        if self.time_image:
+            label_text += f", Time/image: {self.time_image:.3f} sec"
+        if self.time_batch:
+            label_text += f", Time/batch: {self.time_batch:.3f} sec"
+        if self.time_left:
+            label_text += f", Time_left: {self.time_left:.3f} min"
+        self.progress_label.config(text=label_text)
+
 class spacrFrame(ttk.Frame):
     def __init__(self, container, width=None, *args, bg='black', **kwargs):
         super().__init__(container, *args, **kwargs)
@@ -1561,14 +1586,19 @@ class ModifyMaskApp:
         self.update_display()
 
 class AnnotateApp:
-    def __init__(self, root, db_path, src, image_type=None, channels=None, grid_rows=None, grid_cols=None, image_size=(200, 200), annotation_column='annotate', normalize=False, percentiles=(1,99), measurement=None, threshold=None):
+    def __init__(self, root, db_path, src, image_type=None, channels=None, image_size=200, annotation_column='annotate', normalize=False, percentiles=(1, 99), measurement=None, threshold=None):
         self.root = root
         self.db_path = db_path
         self.src = src
         self.index = 0
-        self.grid_rows = grid_rows
-        self.grid_cols = grid_cols
-        self.image_size = image_size
+        
+        if isinstance(image_size, list):
+            self.image_size = (int(image_size[0]), int(image_size[0]))
+        elif isinstance(image_size, int):
+            self.image_size = (image_size, image_size)
+        else:
+            raise ValueError("Invalid image size")
+        
         self.annotation_column = annotation_column
         self.image_type = image_type
         self.channels = channels
@@ -1580,22 +1610,72 @@ class AnnotateApp:
         self.adjusted_to_original_paths = {}
         self.terminate = False
         self.update_queue = Queue()
-        self.status_label = Label(self.root, text="", font=("Arial", 12))
-        self.status_label.grid(row=self.grid_rows + 1, column=0, columnspan=self.grid_cols)
         self.measurement = measurement
         self.threshold = threshold
 
+        print('self.image_size', self.image_size)
+
+        style_out = set_dark_style(ttk.Style())
+        self.root.configure(bg=style_out['inactive_color'])
+
         self.filtered_paths_annotations = []
         self.prefilter_paths_annotations()
 
         self.db_update_thread = threading.Thread(target=self.update_database_worker)
         self.db_update_thread.start()
 
-        for i in range(grid_rows * grid_cols):
-            label = Label(root)
-            label.grid(row=i // grid_cols, column=i % grid_cols)
+        # Set the initial window size and make it fit the screen size
+        self.root.geometry(f"{self.root.winfo_screenwidth()}x{self.root.winfo_screenheight()}")
+        self.root.update_idletasks()
+
+        # Create the status label
+        self.status_label = Label(root, text="", font=("Arial", 12), bg=self.root.cget('bg'))
+        self.status_label.grid(row=2, column=0, padx=10, pady=10, sticky="w")
+
+        # Place the buttons at the bottom right
+        self.button_frame = Frame(root, bg=self.root.cget('bg'))
+        self.button_frame.grid(row=2, column=1, padx=10, pady=10, sticky="se")
+
+        self.next_button = Button(self.button_frame, text="Next", command=self.next_page, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.next_button.pack(side="right", padx=5)
+
+        self.previous_button = Button(self.button_frame, text="Back", command=self.previous_page, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.previous_button.pack(side="right", padx=5)
+
+        self.exit_button = Button(self.button_frame, text="Exit", command=self.shutdown, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.exit_button.pack(side="right", padx=5)
+
+        # Calculate grid rows and columns based on the root window size and image size
+        self.calculate_grid_dimensions()
+
+        # Create a frame to hold the image grid
+        self.grid_frame = Frame(root, bg=self.root.cget('bg'))
+        self.grid_frame.grid(row=0, column=0, columnspan=2, padx=0, pady=0, sticky="nsew")
+
+        for i in range(self.grid_rows * self.grid_cols):
+            label = Label(self.grid_frame, bg=self.root.cget('bg'))
+            label.grid(row=i // self.grid_cols, column=i % self.grid_cols, padx=2, pady=2, sticky="nsew")
             self.labels.append(label)
 
+        # Make the grid frame resize with the window
+        self.root.grid_rowconfigure(0, weight=1)
+        self.root.grid_columnconfigure(0, weight=1)
+        self.root.grid_columnconfigure(1, weight=1)
+
+        self.grid_frame.grid_rowconfigure(0, weight=1)
+        self.grid_frame.grid_columnconfigure(0, weight=1)
+
+    def calculate_grid_dimensions(self):
+        window_width = self.root.winfo_width()
+        window_height = self.root.winfo_height()
+
+        self.grid_cols = window_width // (self.image_size[0] + 4)
+        self.grid_rows = (window_height - self.button_frame.winfo_height() - 4) // (self.image_size[1] + 4)
+
+        # Update to make sure grid_rows and grid_cols are at least 1
+        self.grid_cols = max(1, self.grid_cols)
+        self.grid_rows = max(1, self.grid_rows)
+
     def prefilter_paths_annotations(self):
         from .io import _read_and_join_tables
         from .utils import is_list_of_lists
@@ -1849,6 +1929,7 @@ class AnnotateApp:
             self.update_queue.put(self.pending_updates.copy())
         self.pending_updates.clear()
         self.index += self.grid_rows * self.grid_cols
+        self.prefilter_paths_annotations()  # Re-fetch annotations from the database
         self.load_images()
 
     def previous_page(self):
@@ -1858,6 +1939,7 @@ class AnnotateApp:
         self.index -= self.grid_rows * self.grid_cols
         if self.index < 0:
             self.index = 0
+        self.prefilter_paths_annotations()  # Re-fetch annotations from the database
         self.load_images()
 
     def shutdown(self):

spacr/gui_utils.py

@@ -318,3 +318,35 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
     # Call load_images after setting up the root window
     app.load_images()
 
+def annotate_with_image_refs(settings, root, shutdown_callback):
+    from .settings import set_annotate_default_settings
+
+    settings = set_annotate_default_settings(settings)
+    src = settings['src']
+
+    db = os.path.join(src, 'measurements/measurements.db')
+    conn = sqlite3.connect(db)
+    c = conn.cursor()
+    c.execute('PRAGMA table_info(png_list)')
+    cols = c.fetchall()
+    if settings['annotation_column'] not in [col[1] for col in cols]:
+        c.execute(f"ALTER TABLE png_list ADD COLUMN {settings['annotation_column']} integer")
+    conn.commit()
+    conn.close()
+
+    screen_width = root.winfo_screenwidth()
+    screen_height = root.winfo_screenheight()
+    root.geometry(f"{screen_width}x{screen_height}")
+
+    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
+
+    # Set the canvas background to black
+    root.configure(bg='black')
+
+    # Store the shutdown function and next app details in the root
+    root.current_app_exit_func = lambda: [app.shutdown(), shutdown_callback()]
+
+    # Call load_images after setting up the root window
+    app.load_images()
+
+

spacr/io.py

@@ -583,7 +583,7 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
         None
     """
     
-    from .utils import _extract_filename_metadata
+    from .utils import _extract_filename_metadata, print_progress
     
     regular_expression = re.compile(regex)
     images_by_key = defaultdict(list)
@@ -591,10 +591,15 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
     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}')
+        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)
             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:
                     plate, well, field, channel, mode = key
@@ -609,6 +614,14 @@ 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():
                     mip = np.max(np.stack(images), axis=0)
@@ -623,6 +636,12 @@ 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()
 
@@ -826,6 +845,7 @@ def _merge_channels(src, plot=False):
     """
 
     from .plot import plot_arrays
+    from .utils import print_progress
     
     stack_dir = os.path.join(src, 'stack')
     allowed_names = ['01', '02', '03', '04', '00', '1', '2', '3', '4', '0']
@@ -835,8 +855,7 @@ def _merge_channels(src, plot=False):
     chan_dirs.sort()
 
     print(f'List of folders in src: {chan_dirs}. Single channel folders.')
-    start_time = time.time()
-
+    
     # Assuming chan_dirs[0] is not empty and exists, adjust according to your logic
     first_dir_path = os.path.join(src, chan_dirs[0])
     dir_files = os.listdir(first_dir_path)
@@ -847,14 +866,18 @@ def _merge_channels(src, plot=False):
     print(f'Generated folder with merged arrays: {stack_dir}')
 
     if _is_dir_empty(stack_dir):
-        for file_name in dir_files:
+        time_ls = []
+        files_to_process = len(dir_files)
+        for i, file_name in enumerate(dir_files):
+            start_time = time.time()
             full_file_path = os.path.join(first_dir_path, file_name)
             if os.path.isfile(full_file_path):
                 _merge_file([os.path.join(src, d) for d in chan_dirs], stack_dir, file_name)
-
-    elapsed_time = time.time() - start_time
-    avg_time = elapsed_time / len(dir_files) if dir_files else 0
-    print(f'Average Time: {avg_time:.3f} sec, Total Elapsed Time: {elapsed_time:.3f} sec')
+            stop_time = time.time()
+            duration = stop_time - start_time
+            time_ls.append(duration)
+            files_processed = i + 1
+            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type='Merging channels into npy stacks')
 
     if plot:
         plot_arrays(os.path.join(src, 'stack'))
@@ -911,6 +934,7 @@ def _mip_all(src, include_first_chan=True):
 
 #@log_function_call
 def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_size=100):
+    from .utils import print_progress
     """
     Concatenates channel data from multiple files and saves the concatenated data as numpy arrays.
 
@@ -926,6 +950,7 @@ def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_s
     """
     channels = [item for item in channels if item is not None]
     paths = []
+    time_ls = []
     index = 0
     channel_stack_loc = os.path.join(os.path.dirname(src), 'channel_stack')
     os.makedirs(channel_stack_loc, exist_ok=True)
@@ -944,8 +969,13 @@ def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_s
                     array = np.take(array, channels, axis=2)
                     stack_region.append(array)
                     filenames_region.append(os.path.basename(path))
-                #clear_output(wait=True)
-                print(f'Region {i+1}/ {len(time_stack_path_lists)}', end='\r', flush=True)
+
+                stop = time.time()
+                duration = stop - start
+                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")
                 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)
@@ -964,23 +994,24 @@ def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_s
         nr_files = len(paths)
         batch_index = 0  # Added this to name the output files
         stack_ls = []
-        filenames_batch = []  # to hold filenames of the current batch
+        filenames_batch = []
         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))  # store the filename
-            #clear_output(wait=True)
-            print(f'Concatenated: {i+1}/{nr_files} files')
-            #print(f'Concatenated: {i+1}/{nr_files} files', end='\r', flush=True)
-
+            stop = time.time()
+            duration = stop - start
+            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")
             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:
                     max_dims = np.max(np.array(list(unique_shapes)), axis=0)
-                    #clear_output(wait=True)
                     print(f'Warning: arrays with multiple shapes found in batch {i+1}. Padding arrays to max X,Y dimentions {max_dims}')
-                    #print(f'Warning: arrays with multiple shapes found in batch {i+1}. Padding arrays to max X,Y dimentions {max_dims}', end='\r', flush=True)
                     padded_stack_ls = []
                     for arr in stack_ls:
                         pad_width = [(0, max_dim - dim) for max_dim, dim in zip(max_dims, arr.shape[:-1])]
@@ -1002,6 +1033,7 @@ def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_s
 
 def _normalize_img_batch(stack, channels, save_dtype, settings):
     
+    from .utils import print_progress
     """
     Normalize the stack of images.
 
@@ -1018,7 +1050,9 @@ def _normalize_img_batch(stack, channels, save_dtype, settings):
     normalized_stack = np.zeros_like(stack, dtype=np.float32)
     
     #for channel in range(stack.shape[-1]):
-    for channel in channels:
+    time_ls = []
+    for i, channel in enumerate(channels):
+        start = time.time()
         if channel == settings['nucleus_channel']:
             background = settings['nucleus_background']
             signal_threshold = settings['nucleus_Signal_to_noise']*settings['nucleus_background']
@@ -1065,10 +1099,18 @@ def _normalize_img_batch(stack, channels, save_dtype, settings):
             arr_2d_normalized = exposure.rescale_intensity(arr_2d, in_range=(global_lower, global_upper), out_range=(0, 1))
             normalized_stack[array_index, :, :, channel] = arr_2d_normalized
 
+        stop = time.time()
+        duration = stop - start
+        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}")
+
     return normalized_stack.astype(save_dtype)
 
 def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={}):
-    
+    from .utils import print_progress
+
     """
     Concatenates and normalizes channel data from multiple files and saves the normalized data.
 
@@ -1088,10 +1130,11 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
     Returns:
         str: The directory path where the concatenated and normalized channel data is saved.
     """
-    # n c p
+
     channels = [item for item in channels if item is not None]
 
     paths = []
+    time_ls = []
     output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
     os.makedirs(output_fldr, exist_ok=True)
 
@@ -1099,6 +1142,7 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
         try:
             time_stack_path_lists = _generate_time_lists(os.listdir(src))
             for i, time_stack_list in enumerate(time_stack_path_lists):
+                start = time.time()
                 stack_region = []
                 filenames_region = []
                 for idx, file in enumerate(time_stack_list):
@@ -1110,7 +1154,12 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
                     #array = np.take(array, channels, axis=2)
                     stack_region.append(array)
                     filenames_region.append(os.path.basename(path))
-                print(f'Region {i + 1}/ {len(time_stack_path_lists)}', end='\r', flush=True)
+                stop = time.time()
+                duration = stop - start
+                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")
                 stack = np.stack(stack_region)
 
                 normalized_stack = _normalize_img_batch(stack=stack,
@@ -1138,13 +1187,19 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
         batch_index = 0
         stack_ls = []
         filenames_batch = []
-
+        time_ls = []
         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))
-            print(f'Concatenated: {i + 1}/{nr_files} files')
+            stop = time.time()
+            duration = stop - start
+            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")
 
             if (i + 1) % settings['batch_size'] == 0 or i + 1 == nr_files:
                 unique_shapes = {arr.shape[:-1] for arr in stack_ls}
@@ -1219,6 +1274,7 @@ def _get_lists_for_normalization(settings):
     return backgrounds, signal_to_noise, signal_thresholds, remove_background
 
 def _normalize_stack(src, backgrounds=[100, 100, 100], remove_backgrounds=[False, False, False], lower_percentile=2, save_dtype=np.float32, signal_to_noise=[5, 5, 5], signal_thresholds=[1000, 1000, 1000]):
+    from .utils import print_progress
     """
     Normalize the stack of images.
 
@@ -1266,10 +1322,11 @@ def _normalize_stack(src, backgrounds=[100, 100, 100], remove_backgrounds=[False
                 global_upper = np.percentile(non_zero_single_channel, upper_p)
                 if global_upper >= signal_threshold:
                     break
-
+            
             # Normalize the pixels in each image to the global percentiles and then dtype.
             arr_2d_normalized = np.zeros_like(single_channel, dtype=single_channel.dtype)
             signal_to_noise_ratio_ls = []
+            time_ls = []
             for array_index in range(single_channel.shape[0]):
                 start = time.time()
                 arr_2d = single_channel[array_index, :, :]
@@ -1291,8 +1348,15 @@ def _normalize_stack(src, backgrounds=[100, 100, 100], remove_backgrounds=[False
                 duration = (stop - start) * single_channel.shape[0]
                 time_ls.append(duration)
                 average_time = np.mean(time_ls) if len(time_ls) > 0 else 0
-                print(f'Progress: files {file_index + 1}/{len(paths)}, 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')
+                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")
+                
             normalized_stack[:, :, :, channel] = arr_2d_normalized
         
         save_loc = os.path.join(output_fldr, f'{name}_norm_stack.npz')
@@ -1303,6 +1367,7 @@ def _normalize_stack(src, backgrounds=[100, 100, 100], remove_backgrounds=[False
     return print(f'Saved stacks: {output_fldr}')
 
 def _normalize_timelapse(src, lower_percentile=2, save_dtype=np.float32):
+    from .utils import print_progress
     """
     Normalize the timelapse data by rescaling the intensity values based on percentiles.
 
@@ -1326,8 +1391,9 @@ def _normalize_timelapse(src, lower_percentile=2, save_dtype=np.float32):
 
         for chan_index in range(stack.shape[-1]):
             single_channel = stack[:, :, :, chan_index]
-
+            time_ls = []
             for array_index in range(single_channel.shape[0]):
+                start = time.time()
                 arr_2d = single_channel[array_index]
                 # Calculate the 1% and 98% percentiles for this specific image
                 q_low = np.percentile(arr_2d[arr_2d != 0], lower_percentile)
@@ -1337,7 +1403,14 @@ def _normalize_timelapse(src, lower_percentile=2, save_dtype=np.float32):
                 arr_2d_rescaled = exposure.rescale_intensity(arr_2d, in_range=(q_low, q_high), out_range='dtype')
                 normalized_stack[array_index, :, :, chan_index] = arr_2d_rescaled
 
-                print(f'Progress: files {file_index+1}/{len(paths)}, channels:{chan_index+1}/{stack.shape[-1]}, arrays:{array_index+1}/{single_channel.shape[0]}', end='\r')
+                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")
 
         save_loc = os.path.join(output_fldr, f'{name}_norm_timelapse.npz')
         np.savez(save_loc, data=normalized_stack, filenames=filenames)
@@ -1602,6 +1675,7 @@ def _get_avg_object_size(masks):
         return 0  # Return 0 if no objects are found
     
 def _save_figure(fig, src, text, dpi=300, i=1, all_folders=1):
+    from .utils import print_progress
     """
     Save a figure to a specified location.
 
@@ -1611,6 +1685,7 @@ def _save_figure(fig, src, text, dpi=300, i=1, all_folders=1):
     text (str): The text to be included in the figure name.
     dpi (int, optional): The resolution of the saved figure. Defaults to 300.
     """
+
     save_folder = os.path.dirname(src)
     obj_type = os.path.basename(src)
     name = os.path.basename(save_folder)
@@ -1619,10 +1694,11 @@ def _save_figure(fig, src, text, dpi=300, i=1, all_folders=1):
     fig_name = f'{obj_type}_{name}_{text}.pdf'        
     save_location = os.path.join(save_folder, fig_name)
     fig.savefig(save_location, bbox_inches='tight', dpi=dpi)
-    clear_output(wait=True)
-    print(f'Progress: {i}/{all_folders}, Saved single cell figure: {os.path.basename(save_location)}')
-    #print(f'Progress: {i}/{all_folders}, Saved single cell figure: {os.path.basename(save_location)}', end='\r', flush=True)
-    # Close and delete the figure to free up memory
+
+    files_processed = i
+    files_to_process = all_folders
+    print_progress(files_processed, files_to_process, n_jobs=1, time_ls=None, batch_size=None, operation_type="Saving Figures")
+    print(f'Saved single cell figure: {os.path.basename(save_location)}')
     plt.close(fig)
     del fig
     gc.collect()
@@ -1842,6 +1918,9 @@ def _create_database(db_path):
             conn.close() 
     
 def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_dim, pathogen_chann_dim):
+
+    from .utils import print_progress
+
     """
     Load and concatenate arrays from multiple folders.
 
@@ -1870,9 +1949,10 @@ def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_di
 
     count=0
     all_imgs = len(os.listdir(reference_folder))
-
+    time_ls = []
     # Iterate through each file in the reference folder
     for filename in os.listdir(reference_folder):
+        start = time.time()
         stack_ls = []
         if filename.endswith('.npy'):
             count += 1
@@ -1929,9 +2009,13 @@ def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_di
                     output_path = os.path.join(output_folder, filename)
                     np.save(output_path, stack)
         
-        #clear_output(wait=True)
-        print(f'Files merged: {count}/{all_imgs}')
-        #print(f'Files merged: {count}/{all_imgs}', end='\r', flush=True)
+        stop = time.time()
+        duration = stop - start
+        time_ls.append(duration)
+        files_processed = count
+        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")
+
     return
     
 def _read_db(db_loc, tables):
@@ -2211,7 +2295,7 @@ def _save_model(model, model_type, results_df, dst, epoch, epochs, intermedeate_
     
     def save_model_at_threshold(threshold, epoch, suffix=""):
         percentile = str(threshold * 100)
-        print(f'\rfound: {percentile}% accurate model', end='\r', flush=True)
+        print(f'\rfound: {percentile}% accurate model')#, end='\r', flush=True)
         torch.save(model, f'{dst}/{model_type}_epoch_{str(epoch)}{suffix}_acc_{percentile}_channels_{channels_str}.pth')
 
     if epoch % 100 == 0 or epoch == epochs:
@@ -2545,5 +2629,5 @@ def generate_cellpose_train_test(src, test_split=0.1):
             new_mask_path = os.path.join(dst_mask, filename)            
             shutil.copy(img_path, new_img_path)
             shutil.copy(mask_path, new_mask_path)
-            print(f'Copied {idx+1}/{len(ls)} images to {_type} set', end='\r', flush=True)
+            print(f'Copied {idx+1}/{len(ls)} images to {_type} set')#, end='\r', flush=True)
             

spacr/measure.py

@@ -935,7 +935,7 @@ def measure_crop(settings):
     from .io import _save_settings_to_db
     from .timelapse import _timelapse_masks_to_gif, _scmovie
     from .plot import _save_scimg_plot
-    from .utils import _list_endpoint_subdirectories, _generate_representative_images, measure_test_mode
+    from .utils import _list_endpoint_subdirectories, _generate_representative_images, measure_test_mode, print_progress
     from .settings import get_measure_crop_settings
 
     settings = get_measure_crop_settings(settings)
@@ -996,24 +996,20 @@ def measure_crop(settings):
         return
     
     _save_settings_to_db(settings)
-
     files = [f for f in os.listdir(settings['src']) if f.endswith('.npy')]
     n_jobs = settings['n_jobs'] or mp.cpu_count()-4
     print(f'using {n_jobs} cpu cores')
-
     with mp.Manager() as manager:
         time_ls = manager.list()
         with mp.Pool(n_jobs) as pool:
             result = pool.starmap_async(_measure_crop_core, [(index, time_ls, file, settings) for index, file in enumerate(files)])
 
             # Track progress in the main process
-            while not result.ready():  # Run the loop until all tasks have finished
-                time.sleep(1)  # Wait for a short amount of time to avoid excessive printing
+            while not result.ready():
+                time.sleep(1)
                 files_processed = len(time_ls)
                 files_to_process = len(files)
-                average_time = np.mean(time_ls) if len(time_ls) > 0 else 0
-                time_left = (((files_to_process-files_processed)*average_time)/n_jobs)/60
-                print(f'Progress: {files_processed}/{files_to_process} Time/img {average_time:.3f}sec, Time Remaining {time_left:.3f} min.', end='\r', flush=True)
+                print_progress(files_processed, files_to_process, n_jobs, time_ls=None)
             result.get()
 
     if settings['representative_images']:
@@ -1114,3 +1110,5 @@ def get_object_counts(src):
     # Close the database connection
     conn.close()
     return grouped_df
+
+

spacr/settings.py

@@ -1143,10 +1143,7 @@ def set_annotate_default_settings(settings):
     settings.setdefault('src', 'path')
     settings.setdefault('image_type', 'cell_png')
     settings.setdefault('channels', 'r,g,b')
-    settings.setdefault('geom', "3200x2000")
-    settings.setdefault('img_size', [200, 200])
-    settings.setdefault('rows', 10)
-    settings.setdefault('columns', 18)
+    settings.setdefault('img_size', 200)
     settings.setdefault('annotation_column', 'test')
     settings.setdefault('normalize', 'False')
     settings.setdefault('percentiles', [2, 98])