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

spacr/gui_utils.py

@@ -3,20 +3,13 @@ import tkinter as tk
 from tkinter import ttk
 
 from . gui_core import initiate_root
-from .gui_elements import spacrLabel, spacrCheckbutton, AnnotateApp
+from .gui_elements import spacrLabel, spacrCheckbutton, AnnotateApp, spacrEntry, spacrCheck, spacrCombo, set_default_font
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
 
-def set_default_font(root, font_name="Helvetica", size=12):
-    default_font = (font_name, size)
-    root.option_add("*Font", default_font)
-    root.option_add("*TButton.Font", default_font)
-    root.option_add("*TLabel.Font", default_font)
-    root.option_add("*TEntry.Font", default_font)
-
 def proceed_with_app_v1(root, app_name, app_func):
     from .gui import gui_app
 
@@ -98,6 +91,7 @@ def parse_list(value):
     except (ValueError, SyntaxError) as e:
         raise ValueError(f"Invalid format for list: {value}. Error: {e}")
     
+# Usage example in your create_input_field function
 def create_input_field(frame, label_text, row, var_type='entry', options=None, default_value=None):
     label_column = 0
     widget_column = 1
@@ -107,22 +101,22 @@ def create_input_field(frame, label_text, row, var_type='entry', options=None, d
     frame.grid_columnconfigure(widget_column, weight=1)  # Allow the widget column to expand
 
     # Right-align the label text and the label itself
-    label = spacrLabel(frame, text=label_text, background="black", foreground="white", anchor='e', justify='right')
+    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
 
     if var_type == 'entry':
         var = tk.StringVar(value=default_value)  # Set default value
-        entry = ttk.Entry(frame, textvariable=var, style='TEntry')  # Apply TEntry style for entries
+        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
     elif var_type == 'check':
         var = tk.BooleanVar(value=default_value)  # Set default value (True/False)
-        check = spacrCheckbutton(frame, text="", variable=var, style='TCheckbutton')
+        check = spacrCheck(frame, text="", variable=var)
         check.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
         return (label, check, var)  # Return both the label and the checkbutton, and the variable
     elif var_type == 'combo':
         var = tk.StringVar(value=default_value)  # Set default value
-        combo = ttk.Combobox(frame, textvariable=var, values=options, style='TCombobox')  # Apply TCombobox style
+        combo = spacrCombo(frame, textvariable=var, values=options)  # Apply TCombobox style
         combo.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
         if default_value:
             combo.set(default_value)
@@ -158,32 +152,32 @@ def cancel_after_tasks(frame):
             frame.after_cancel(task)
         frame.after_tasks.clear()
 
-def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label):
+def main_thread_update_function(root, q, fig_queue, canvas_widget):
     try:
-        ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
+        #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)
+            #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:
-        root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
+        root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget))
 
 def annotate(settings):
     from .settings import set_annotate_default_settings
@@ -324,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])