spacr 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

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,210 @@ 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_separate_files_to_yokogawa(folder, regex):
+    ROWS = "ABCDEFGHIJKLMNOP"
+    COLS = [f"{i:02d}" for i in range(1, 25)]
+    WELLS = [f"{r}{c}" for r in ROWS for c in COLS]
+
+    def _get_next_well(used_wells):
+        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"
+
+    pattern = re.compile(regex, re.I)
+
+    files_by_fov = {}
+    rename_log = []
+    csv_path = os.path.join(folder, "rename_log.csv")
+    used_wells = set(os.listdir(folder))
+    fov_to_well = {}
+
+    # Group files by FOV
+    for file in os.listdir(folder):
+        match = pattern.match(file)
+        if not match:
+            print(f"Skipping {file}: does not match regex.")
+            continue
+
+        meta = match.groupdict()
+
+        # Extract required metadata
+        fov = meta['fov']
+        channel = int(meta['channel'])
+
+        # Optional metadata with defaults
+        time = int(meta.get('time', 1))
+        z_slice = int(meta.get('slice', 1))
+
+        files_by_fov.setdefault(fov, []).append((file, channel, time, z_slice))
+
+    # Assign wells per FOV
+    for fov, file_list in files_by_fov.items():
+        if fov not in fov_to_well:
+            fov_to_well[fov] = _get_next_well(used_wells)
+            used_wells.add(fov_to_well[fov])
+
+        well = fov_to_well[fov]
+
+        for original_file, channel, time, z_slice in file_list:
+            img = tifffile.imread(os.path.join(folder, original_file))
+            dtype = img.dtype
+
+            filename = f"{well}_T{time:04d}F001L01C{channel:02d}Z{z_slice:03d}.tif"
+            filepath = os.path.join(folder, filename)
+            tifffile.imwrite(filepath, img.astype(dtype))
+
+            rename_log.append({"Original File": original_file, "Renamed TIFF": filename})
+
+    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: