spacr 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

spacr/gui_elements.py

@@ -2285,6 +2285,9 @@ class AnnotateApp:
         
         self.train_button = Button(self.button_frame,text="orig.",command=self.swich_back_annotation_column,bg=self.bg_color,fg=self.fg_color,highlightbackground=self.fg_color,highlightcolor=self.fg_color,highlightthickness=1)
         self.train_button.pack(side="right", padx=5)
+        
+        self.settings_button = Button(self.button_frame, text="Settings", command=self.open_settings_window, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color,highlightcolor=self.fg_color,highlightthickness=1)
+        self.settings_button.pack(side="right", padx=5)
 
         # Calculate grid rows and columns based on the root window size and image size
         self.calculate_grid_dimensions()
@@ -2308,6 +2311,134 @@ class AnnotateApp:
         for col in range(self.grid_cols):
             self.grid_frame.grid_columnconfigure(col, weight=1)
             
+    def open_settings_window(self):
+        from .gui_utils import generate_annotate_fields, convert_to_number
+
+        # Create settings window
+        settings_window = tk.Toplevel(self.root)
+        settings_window.title("Modify Annotation Settings")
+
+        style_out = set_dark_style(ttk.Style())
+        settings_window.configure(bg=style_out['bg_color'])
+        
+        settings_frame = tk.Frame(settings_window, bg=style_out['bg_color'])
+        settings_frame.pack(fill=tk.BOTH, expand=True)
+
+        # Generate fields with current settings pre-filled
+        vars_dict = generate_annotate_fields(settings_frame)
+
+        # Pre-fill the current settings into vars_dict
+        current_settings = {
+            'image_type': self.image_type or '',
+            'channels': ','.join(self.channels) if self.channels else '',
+            'img_size': f"{self.image_size[0]},{self.image_size[1]}",
+            'annotation_column': self.annotation_column or '',
+            'normalize': str(self.normalize),
+            'percentiles': ','.join(map(str, self.percentiles)),
+            'measurement': ','.join(self.measurement) if self.measurement else '',
+            'threshold': str(self.threshold) if self.threshold is not None else '',
+            'normalize_channels': ','.join(self.normalize_channels) if self.normalize_channels else ''
+        }
+
+        for key, data in vars_dict.items():
+            if key in current_settings:
+                data['entry'].delete(0, tk.END)
+                data['entry'].insert(0, current_settings[key])
+
+        def apply_new_settings():
+            settings = {key: data['entry'].get() for key, data in vars_dict.items()}
+            
+            # Process settings exactly as your original initiation function does
+            settings['channels'] = settings['channels'].split(',') if settings['channels'] else None
+            settings['img_size'] = list(map(int, settings['img_size'].split(',')))
+            settings['percentiles'] = list(map(convert_to_number, settings['percentiles'].split(','))) if settings['percentiles'] else [1, 99]
+            settings['normalize'] = settings['normalize'].lower() == 'true'
+            settings['normalize_channels'] = settings['normalize_channels'].split(',') if settings['normalize_channels'] else None
+
+            try:
+                settings['measurement'] = settings['measurement'].split(',') if settings['measurement'] else None
+                settings['threshold'] = None if settings['threshold'].lower() == 'none' else int(settings['threshold'])
+            except:
+                settings['measurement'] = None
+                settings['threshold'] = None
+
+            # Convert empty strings to None
+            for key, value in settings.items():
+                if isinstance(value, list):
+                    settings[key] = [v if v != '' else None for v in value]
+                elif value == '':
+                    settings[key] = None
+
+            # Apply these settings dynamically using update_settings method
+            self.update_settings(**{
+                'image_type': settings.get('image_type'),
+                'channels': settings.get('channels'),
+                'image_size': settings.get('img_size'),
+                'annotation_column': settings.get('annotation_column'),
+                'normalize': settings.get('normalize'),
+                'percentiles': settings.get('percentiles'),
+                'measurement': settings.get('measurement'),
+                'threshold': settings.get('threshold'),
+                'normalize_channels': settings.get('normalize_channels')
+            })
+
+            settings_window.destroy()
+
+        apply_button = spacrButton(settings_window, text="Apply Settings", command=apply_new_settings,show_text=False)
+        apply_button.pack(pady=10)
+        
+    def update_settings(self, **kwargs):
+        allowed_attributes = {
+            'image_type', 'channels', 'image_size', 'annotation_column',
+            'normalize', 'percentiles', 'measurement', 'threshold', 'normalize_channels'
+        }
+
+        updated = False
+
+        for attr, value in kwargs.items():
+            if attr in allowed_attributes and value is not None:
+                setattr(self, attr, value)
+                updated = True
+
+        if 'image_size' in kwargs:
+            if isinstance(self.image_size, list):
+                self.image_size = (int(self.image_size[0]), int(self.image_size[0]))
+            elif isinstance(self.image_size, int):
+                self.image_size = (self.image_size, self.image_size)
+            else:
+                raise ValueError("Invalid image size")
+
+            self.calculate_grid_dimensions()
+            self.recreate_image_grid()
+
+        if updated:
+            current_index = self.index  # Retain current index
+            self.prefilter_paths_annotations()
+
+            # Ensure the retained index is still valid (not out of bounds)
+            max_index = len(self.filtered_paths_annotations) - 1
+            self.index = min(current_index, max_index := max(0, max(0, max(len(self.filtered_paths_annotations) - self.grid_rows * self.grid_cols, 0))))
+            self.load_images()
+
+    def recreate_image_grid(self):
+        # Remove current labels
+        for label in self.labels:
+            label.destroy()
+        self.labels.clear()
+
+        # Recreate the labels grid with updated dimensions
+        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)
+
+        # Reconfigure grid weights
+        for row in range(self.grid_rows):
+            self.grid_frame.grid_rowconfigure(row, weight=1)
+        for col in range(self.grid_cols):
+            self.grid_frame.grid_columnconfigure(col, weight=1)
+
+            
     def swich_back_annotation_column(self):
         self.annotation_column = self.orig_annotation_columns
         self.prefilter_paths_annotations()

spacr/gui_utils.py

@@ -106,7 +106,6 @@ 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):
     """
     Create an input field in the specified frame.
@@ -365,27 +364,30 @@ 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]
+    chan_list = ['[0,1,2,3,4,5,6,7,8]','[0,1,2,3,4,5,6,7]','[0,1,2,3,4,5,6]','[0,1,2,3,4,5]','[0,1,2,3,4]','[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]', '[0,0]']
     chans_v2 = [0, 1, 2, 3, None]
+    chans_v3 = list(range(0, 21, 1)) + [None]
+    chans_v4 = [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,0]'], '[0,1,2,3]'),
+        'metadata_type': ('combo', ['cellvoyager', 'cq1', 'auto', 'custom'], 'cellvoyager'),
+        'channels': ('combo', chan_list, '[0,1,2,3]'),
         'train_channels': ('combo', ["['r','g','b']", "['r','g']", "['r','b']", "['g','b']", "['r']", "['g']", "['b']"], "['r','g','b']"),
-        'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'channel_dims': ('combo', chan_list, '[0,1,2,3]'),
         'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'metadata'),
         'cov_type': ('combo', ['HC0', 'HC1', 'HC2', 'HC3', None], None),
-        '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'], ['cell', 'pathogen'], ['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),
+        #'cell_mask_dim': ('combo', chans_v3, None),
+        #'cell_chann_dim': ('combo', chans_v3, None),
+        #'nucleus_mask_dim': ('combo', chans_v3, None),
+        #'nucleus_chann_dim': ('combo', chans_v3, None),
+        #'pathogen_mask_dim': ('combo', chans_v3, None),
+        #'pathogen_chann_dim': ('combo', chans_v3, None),
+        'crop_mode': ('combo', ["['cell']", "['nucleus']", "['pathogen']", "['cell', 'nucleus']", "['cell', 'pathogen']", "['nucleus', 'pathogen']", "['cell', 'nucleus', 'pathogen']"], "['cell']"),
+         #'magnification': ('combo', [20, 40, 60], 20),
+        #'nucleus_channel': ('combo', chans_v3, None),
+        #'cell_channel': ('combo', chans_v3, None),
+        #'channel_of_interest': ('combo', chans_v3, None),
+        #'pathogen_channel': ('combo', chans_v3, None),
         'timelapse_mode': ('combo', ['trackpy', 'btrack'], 'trackpy'),
         'train_mode': ('combo', ['erm', 'irm'], 'erm'),
         'clustering': ('combo', ['dbscan', 'kmean'], 'dbscan'),
@@ -462,10 +464,11 @@ def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imp
     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 generate_image_umap, preprocess_generate_masks
     from .cellpose import identify_masks_finetune, check_cellpose_models, compare_cellpose_masks
     from .submodules import analyze_recruitment
@@ -476,9 +479,10 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     from .sim import run_multiple_simulations
     from .deep_spacr import deep_spacr, apply_model_to_tar
     from .sequencing import generate_barecode_mapping
+    
     process_stdout_stderr(q)
-
-    print(f'run_function_gui settings_type: {settings_type}') 
+    
+    print(f'run_function_gui settings_type: {settings_type}')
     
     if settings_type == 'mask':
         function = preprocess_generate_masks
@@ -523,7 +527,7 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
         function = process_non_tif_non_2D_images
         imports = 1
     else:
-        raise ValueError(f"Invalid settings type: {settings_type}")
+        raise ValueError(f"Error: Invalid settings type: {settings_type}")
     try:
         function_gui_wrapper(function, settings, q, fig_queue, imports)
     except Exception as e:

spacr/io.py

@@ -891,11 +891,16 @@ def _merge_channels(src, plot=False):
     from .utils import print_progress
     
     stack_dir = os.path.join(src, 'stack')
-    allowed_names = ['01', '02', '03', '04', '00', '1', '2', '3', '4', '0']
+    #allowed_names = ['01', '02', '03', '04', '00', '1', '2', '3', '4', '0']
+    
+    string_list = [str(i) for i in range(101)]+[f"{i:02d}" for i in range(10)]
+    allowed_names = sorted(string_list, key=lambda x: int(x))
     
     # List directories that match the allowed names
     chan_dirs = [d for d in os.listdir(src) if os.path.isdir(os.path.join(src, d)) and d in allowed_names]
     chan_dirs.sort()
+    
+    num_matching_folders = len(chan_dirs)
 
     print(f'List of folders in src: {chan_dirs}. Single channel folders.')
     
@@ -925,7 +930,7 @@ def _merge_channels(src, plot=False):
     if plot:
         plot_arrays(os.path.join(src, 'stack'))
 
-    return
+    return num_matching_folders
 
 def _mip_all(src, include_first_chan=True):
     
@@ -1584,10 +1589,6 @@ def preprocess_img_data(settings):
     else:
         print(f'Could not find any {valid_ext} files in {src} only found {extension_counts[0]}')
         
-        
-        
-        
-        
         if os.path.exists(os.path.join(src,'stack')):
             print('Found existing stack folder.')
         if os.path.exists(os.path.join(src,'channel_stack')):
@@ -1644,7 +1645,13 @@ def preprocess_img_data(settings):
                             print(f"all images: {all_imgs},  full batch: {full_batches}, last batch: {last_batch_size}")
                             raise ValueError("Last batch of size 1 detected. Adjust the batch size.")
         
-                _merge_channels(src, plot=False)
+                nr_channel_folders = _merge_channels(src, plot=False)
+                
+                if len(settings['channels']) != nr_channel_folders:
+                    print(f"Number of channels does not match number of channel folders. channels: {settings['channels']} channel folders: {nr_channel_folders}")
+                    new_channels = list(range(nr_channel_folders))
+                    print(f"Changing channels from {settings['channels']} to {new_channels}")
+                    settings['channels'] = new_channels
 
                 if timelapse:
                     _create_movies_from_npy_per_channel(stack_path, fps=2)
@@ -3095,4 +3102,301 @@ def generate_dataset_from_lists(dst, class_data, classes, test_split=0.1):
         test_class_dir = os.path.join(dst, f'test/{cls}')
         print(f'Train class {cls}: {len(os.listdir(train_class_dir))}, Test class {cls}: {len(os.listdir(test_class_dir))}')
 
-    return os.path.join(dst, 'train'), os.path.join(dst, 'test')
+    return os.path.join(dst, 'train'), os.path.join(dst, 'test')
+
+def convert_to_yokogawa_v1(folder):
+    """
+    Detects file type in the folder and converts them
+    to Yokogawa-style naming with Maximum Intensity Projection (MIP).
+    """
+    
+    def _get_next_well(used_wells):
+        """
+        Determines the next available well position in a 384-well format.
+        Iterates wells, and after P24, switches to plate2.
+        """
+        plate = 1
+        for well in WELLS:
+            well_name = f"plate{plate}_{well}"
+            if well_name not in used_wells:
+                return well_name
+            if well == "P24":  
+                plate += 1  
+        return f"plate{plate}_A01"
+
+    # Define 384-well plate format
+    ROWS = "ABCDEFGHIJKLMNOP"
+    COLS = [f"{i:02d}" for i in range(1, 25)]
+    WELLS = [f"{r}{c}" for r in ROWS for c in COLS]
+
+    filenames = []
+    rename_log = []
+    csv_path = os.path.join(folder, "rename_log.csv")
+    used_wells = set(os.listdir(folder))
+
+    for file in os.listdir(folder):
+        path = os.path.join(folder, file)
+        ext = file.lower().split('.')[-1]
+
+        ### **Process Nikon ND2 Files**
+        if ext == 'nd2':
+            nd2 = ND2Reader(path)
+            metadata = nd2.metadata
+
+            timepoints = metadata.get("frames", [0])
+            fields = metadata.get("fields_of_view", [0])
+            z_levels = list(metadata.get("z_levels", range(1)))
+            channels = metadata.get("channels", [])
+
+            for t_idx in timepoints:
+                for f_idx in fields:
+                    for c_idx, channel in enumerate(channels):
+                        well = _get_next_well(used_wells)
+
+                        z_stack = [nd2.get_frame_2D(t=t_idx, v=f_idx, z=z_idx, c=c_idx) for z_idx in z_levels]
+                        mip_image = np.max(np.stack(z_stack), axis=0)
+                        dtype = z_stack[0].dtype
+
+                        filename = f"{well}_T{t_idx+1:04d}F{f_idx+1:03d}L01C{c_idx+1:02d}.tif"
+                        filepath = os.path.join(folder, filename)
+                        tifffile.imwrite(filepath, mip_image.astype(dtype))
+                        used_wells.add(well)
+                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+        ### **Process Zeiss CZI Files**
+        elif ext == 'czi':
+            with czifile.CziFile(path) as czi:
+                shape = czi.shape  
+
+                timepoints = range(shape[0])
+                z_levels = range(shape[1])
+                channels = range(shape[2])
+
+                for t_idx in timepoints:
+                    for c_idx in channels:
+                        well = _get_next_well(used_wells)
+
+                        z_stack = [czi.asarray()[t_idx, z_idx, c_idx] for z_idx in z_levels]
+                        mip_image = np.max(np.stack(z_stack), axis=0)
+                        dtype = z_stack[0].dtype
+
+                        filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
+                        filepath = os.path.join(folder, filename)
+                        tifffile.imwrite(filepath, mip_image.astype(dtype))
+                        used_wells.add(well)
+                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+        ### **Process Leica LIF Files**
+        elif ext == 'lif':
+            lif_file = readlif.Reader(path)
+
+            for image in lif_file.getIterImage():
+                timepoints = range(image.dims.t)
+                z_levels = range(image.dims.z)
+                channels = range(image.dims.c)
+
+                for t_idx in timepoints:
+                    for c_idx in channels:
+                        well = _get_next_well(used_wells)
+
+                        z_stack = [image.getFrame(z=z_idx, t=t_idx, c=c_idx) for z_idx in z_levels]
+                        mip_image = np.max(np.stack(z_stack), axis=0)
+                        dtype = z_stack[0].dtype
+
+                        filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
+                        filepath = os.path.join(folder, filename)
+                        tifffile.imwrite(filepath, mip_image.astype(dtype))
+                        used_wells.add(well)
+                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+        ### **Process Standard Images (.tif, .tiff, .png, .jpg, .bmp, etc.)**
+        elif ext in ['tif', 'tiff', 'png', 'jpg', 'jpeg', 'bmp'] and not file.startswith("plate"):
+            with tifffile.TiffFile(path) as tif:
+                well = _get_next_well(used_wells)
+                num_pages = len(tif.pages)
+
+                if num_pages > 1:
+                    # Assume multi-channel or z-stack
+                    images = tif.asarray()
+                    if images.ndim == 4:  # (T, Z, C, Y, X)
+                        timepoints = range(images.shape[0])
+                        z_levels = range(images.shape[1])
+                        channels = range(images.shape[2])
+
+                        for t_idx in timepoints:
+                            for c_idx in channels:
+                                mip_image = np.max(images[t_idx, :, c_idx], axis=0)
+                                dtype = images.dtype
+
+                                filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
+                                filepath = os.path.join(folder, filename)
+                                tifffile.imwrite(filepath, mip_image.astype(dtype))
+                                used_wells.add(well)
+                                rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+                    elif images.ndim == 3:  # (Z, Y, X) or (C, Y, X)
+                        z_stack = images if images.shape[0] > 1 else [images]
+                        mip_image = np.max(np.stack(z_stack), axis=0)
+                        dtype = images.dtype
+
+                        filename = f"{well}_T0001F001L01C01.tif"
+                        filepath = os.path.join(folder, filename)
+                        tifffile.imwrite(filepath, mip_image.astype(dtype))
+                        used_wells.add(well)
+                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
+                else:
+                    image = tif.pages[0].asarray()
+                    dtype = image.dtype
+
+                    filename = f"{well}_T0001F001L01C01.tif"
+                    filepath = os.path.join(folder, filename)
+                    tifffile.imwrite(filepath, image.astype(dtype))
+                    used_wells.add(well)
+                    rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+    # Save rename log as CSV
+    pd.DataFrame(rename_log).to_csv(csv_path, index=False)
+    print(f"Processing complete. Files saved in {folder} and rename log saved as {csv_path}.")
+
+def convert_to_yokogawa(folder):
+    """
+    Detects file type in the folder and converts them
+    to Yokogawa-style naming with Maximum Intensity Projection (MIP).
+    """
+
+    def _get_next_well(used_wells):
+        """
+        Determines the next available well position in a 384-well format.
+        Iterates wells, and after P24, switches to plate2.
+        """
+        plate = 1
+        for well in WELLS:
+            well_name = f"plate{plate}_{well}"
+            if well_name not in used_wells:
+                return well_name
+            if well == "P24":  
+                plate += 1  
+        return f"plate{plate}_A01"
+
+    # Define 384-well plate format
+    ROWS = "ABCDEFGHIJKLMNOP"
+    COLS = [f"{i:02d}" for i in range(1, 25)]
+    WELLS = [f"{r}{c}" for r in ROWS for c in COLS]
+
+    filenames = []
+    rename_log = []
+    csv_path = os.path.join(folder, "rename_log.csv")
+    used_wells = set(os.listdir(folder))
+
+    # **Dictionary to store well assignments per original file**
+    file_to_well = {}
+
+    for file in os.listdir(folder):
+        path = os.path.join(folder, file)
+        ext = file.lower().split('.')[-1]
+
+        # **Assign a well only once per original file**
+        if file not in file_to_well:
+            file_to_well[file] = _get_next_well(used_wells)
+            used_wells.add(file_to_well[file])  # Mark it as used
+
+        well = file_to_well[file]  # Use the same well for all channels/times
+
+        ### **Process Nikon ND2 Files**
+        if ext == 'nd2':
+            nd2 = ND2Reader(path)
+            metadata = nd2.metadata
+
+            timepoints = metadata.get("frames", [0])
+            fields = metadata.get("fields_of_view", [0])
+            z_levels = list(metadata.get("z_levels", range(1)))
+            channels = metadata.get("channels", [])
+
+            for t_idx in timepoints:
+                for f_idx in fields:
+                    for c_idx, channel in enumerate(channels):
+                        z_stack = [nd2.get_frame_2D(t=t_idx, v=f_idx, z=z_idx, c=c_idx) for z_idx in z_levels]
+                        mip_image = np.max(np.stack(z_stack), axis=0)
+                        dtype = z_stack[0].dtype
+
+                        filename = f"{well}_T{t_idx+1:04d}F{f_idx+1:03d}L01C{c_idx+1:02d}.tif"
+                        filepath = os.path.join(folder, filename)
+                        tifffile.imwrite(filepath, mip_image.astype(dtype))
+
+                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+        ### **Process Zeiss CZI Files**
+        elif ext == 'czi':
+            with czifile.CziFile(path) as czi:
+                shape = czi.shape  
+                timepoints = range(shape[0])
+                z_levels = range(shape[1])
+                channels = range(shape[2])
+
+                for t_idx in timepoints:
+                    for c_idx in channels:
+                        z_stack = [czi.asarray()[t_idx, z_idx, c_idx] for z_idx in z_levels]
+                        mip_image = np.max(np.stack(z_stack), axis=0)
+                        dtype = z_stack[0].dtype
+
+                        filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
+                        filepath = os.path.join(folder, filename)
+                        tifffile.imwrite(filepath, mip_image.astype(dtype))
+
+                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+        ### **Process Leica LIF Files**
+        elif ext == 'lif':
+            lif_file = readlif.Reader(path)
+
+            for image in lif_file.getIterImage():
+                timepoints = range(image.dims.t)
+                z_levels = range(image.dims.z)
+                channels = range(image.dims.c)
+
+                for t_idx in timepoints:
+                    for c_idx in channels:
+                        z_stack = [image.getFrame(z=z_idx, t=t_idx, c=c_idx) for z_idx in z_levels]
+                        mip_image = np.max(np.stack(z_stack), axis=0)
+                        dtype = z_stack[0].dtype
+
+                        filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
+                        filepath = os.path.join(folder, filename)
+                        tifffile.imwrite(filepath, mip_image.astype(dtype))
+
+                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+        ### **Process Standard Image Files**
+        elif ext in ['tif', 'tiff', 'png', 'jpg', 'jpeg', 'bmp'] and not file.startswith("plate"):
+            with tifffile.TiffFile(path) as tif:
+                num_pages = len(tif.pages)
+
+                if num_pages > 1:
+                    images = tif.asarray()
+                    if images.ndim == 4:  
+                        timepoints = range(images.shape[0])
+                        channels = range(images.shape[2])
+
+                        for t_idx in timepoints:
+                            for c_idx in channels:
+                                mip_image = np.max(images[t_idx, :, c_idx], axis=0)
+                                dtype = images.dtype
+
+                                filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
+                                filepath = os.path.join(folder, filename)
+                                tifffile.imwrite(filepath, mip_image.astype(dtype))
+
+                                rename_log.append({"Original File": file, "Renamed TIFF": filename})
+                else:
+                    image = tif.pages[0].asarray()
+                    dtype = image.dtype
+
+                    filename = f"{well}_T0001F001L01C01.tif"
+                    filepath = os.path.join(folder, filename)
+                    tifffile.imwrite(filepath, image.astype(dtype))
+
+                    rename_log.append({"Original File": file, "Renamed TIFF": filename})
+
+    # Save rename log as CSV
+    pd.DataFrame(rename_log).to_csv(csv_path, index=False)
+    print(f"Processing complete. Files saved in {folder} and rename log saved as {csv_path}.")

spacr/measure.py

@@ -945,20 +945,25 @@ def measure_crop(settings):
 
     from .io import _save_settings_to_db
     from .timelapse import _timelapse_masks_to_gif
-    from .utils import measure_test_mode, print_progress, delete_intermedeate_files, save_settings
+    from .utils import measure_test_mode, print_progress, delete_intermedeate_files, save_settings, format_path_for_system, normalize_src_path
     from .settings import get_measure_crop_settings
 
     if not isinstance(settings['src'], (str, list)):
         ValueError(f'src must be a string or a list of strings')
         return
     
+    settings['src'] = normalize_src_path(settings['src'])
+    
     if isinstance(settings['src'], str):
         settings['src'] = [settings['src']]
 
     if isinstance(settings['src'], list):
         source_folders = settings['src']
+        
         for source_folder in source_folders:
             print(f'Processing folder: {source_folder}')
+            
+            source_folder = format_path_for_system(source_folder)
             settings['src'] = source_folder
             src = source_folder
 
@@ -966,15 +971,12 @@ def measure_crop(settings):
             settings = measure_test_mode(settings)
 
             src_fldr = settings['src']
+            
             if not os.path.basename(src_fldr).endswith('merged'):
                 print(f"WARNING: Source folder, settings: src: {src_fldr} should end with '/merged'")
                 src_fldr = os.path.join(src_fldr, 'merged')
+                settings['src'] = src_fldr
                 print(f"Changed source folder to: {src_fldr}")
-
-            #if settings['save_measurements']:
-                #source_folder = os.path.dirname(settings['src'])
-                #os.makedirs(source_folder+'/measurements', exist_ok=True)
-                #_create_database(source_folder+'/measurements/measurements.db')
             
             if settings['cell_mask_dim'] is None:
                 settings['uninfected'] = True
@@ -995,12 +997,9 @@ def measure_crop(settings):
                 print(f'Warning reserving 6 CPU cores for other processes, setting n_jobs to {spacr_cores}')
                 settings['n_jobs'] = spacr_cores
 
-            #dirname = os.path.dirname(settings['src'])
-            #settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
-            #settings_csv = os.path.join(dirname,'settings','measure_crop_settings.csv')
-            #os.makedirs(os.path.join(dirname,'settings'), exist_ok=True)
-            #settings_df.to_csv(settings_csv, index=False)
-            save_settings(settings, name='measure_crop_settings', show=True)
+            settings_save = settings.copy()
+            settings_save['src'] = os.path.dirname(settings['src'])
+            save_settings(settings_save, name='measure_crop_settings', show=True)
 
             if settings['timelapse_objects'] == 'nucleus':
                 if not settings['cell_mask_dim'] is None:

spacr/plot.py

@@ -2705,7 +2705,7 @@ class spacrGraph:
     def perform_posthoc_tests(self, is_normal, unique_groups):
         """Perform post-hoc tests for multiple groups based on all_to_all flag."""
 
-        from .stats import choose_p_adjust_method
+        from .sp_stats import choose_p_adjust_method
 
         posthoc_results = []
         if is_normal and len(unique_groups) > 2 and self.all_to_all:
@@ -3815,7 +3815,7 @@ def plot_proportion_stacked_bars(settings, df, group_column, bin_column, prc_col
     - pairwise_results (list): Pairwise test results from `chi_pairwise`.
     """
     
-    from .stats import chi_pairwise
+    from .sp_stats import chi_pairwise
     
     # Calculate contingency table for overall chi-squared test
     raw_counts = df.groupby([group_column, bin_column]).size().unstack(fill_value=0)