spacr 0.4.60__py3-none-any.whl → 0.9.0__py3-none-any.whl

spacr/io.py

@@ -1,4 +1,4 @@
-import os, re, sqlite3, gc, torch, time, random, shutil, cv2, tarfile, cellpose, glob, queue, tifffile, czifile, atexit, datetime
+import os, re, sqlite3, gc, torch, time, random, shutil, cv2, tarfile, cellpose, glob, queue, tifffile, czifile, atexit, datetime, traceback
 import numpy as np
 import pandas as pd
 from PIL import Image, ImageOps
@@ -24,6 +24,7 @@ from nd2reader import ND2Reader
 from torchvision import transforms
 from sklearn.model_selection import train_test_split
 import readlif
+from pylibCZIrw import czi as pyczi
 
 def process_non_tif_non_2D_images(folder):
     """Processes all images in the folder and splits them into grayscale channels, preserving bit depth."""
@@ -652,7 +653,7 @@ def load_images_from_paths(images_by_key):
     return images_dict
 
 #@log_function_call 
-def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=False, skip_mode='01', metadata_type='', img_format='.tif'):
+def _rename_and_organize_image_files(src, regex, batch_size=100, metadata_type='', img_format='.tif', timelapse=False):
     """
     Convert z-stack images to maximum intensity projection (MIP) images.
 
@@ -660,8 +661,6 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
         src (str): The source directory containing the z-stack images.
         regex (str): The regular expression pattern used to match the filenames of the z-stack images.
         batch_size (int, optional): The number of images to process in each batch. Defaults to 100.
-        pick_slice (bool, optional): Whether to pick a specific slice based on the provided skip mode. Defaults to False.
-        skip_mode (str, optional): The skip mode used to filter out specific slices. Defaults to '01'.
         metadata_type (str, optional): The type of metadata associated with the images. Defaults to ''.
 
     Returns:
@@ -679,8 +678,9 @@ 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 any(filename.endswith(ext) for ext in img_format)]
         print(f'All files: {len(all_filenames)} in {src}')
+        all_filenames = [f for f in all_filenames if not f.startswith('.')] #Exclude hidden files
         time_ls = []
-        image_paths_by_key = _extract_filename_metadata(all_filenames, src, regular_expression, metadata_type, pick_slice, skip_mode)
+        image_paths_by_key = _extract_filename_metadata(all_filenames, src, regular_expression, metadata_type)
         # Convert dictionary keys to a list for batching
         batching_keys = list(image_paths_by_key.keys())
         print(f'All unique FOV: {len(image_paths_by_key)} in {src}')
@@ -691,47 +691,34 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
             batch_keys = batching_keys[idx:idx+batch_size]
             batch_images_by_key = {key: image_paths_by_key[key] for key in batch_keys}
             images_by_key = load_images_from_paths(batch_images_by_key)
-
-            if pick_slice:
-                for i, key in enumerate(images_by_key):
-                    plate, well, field, channel, mode = key
-                    max_intensity_slice = max(images_by_key[key], key=lambda x: np.percentile(x, 90))
-                    mip_image = Image.fromarray(max_intensity_slice)
-                    output_dir = os.path.join(src, channel)
-                    os.makedirs(output_dir, exist_ok=True)
-                    output_filename = f'{plate}_{well}_{field}.tif'
-                    output_path = os.path.join(output_dir, output_filename)
-                    files_processed += 1
-                    stop = time.time()
-                    duration = stop - start
-                    time_ls.append(duration)
-                    files_to_process = len(all_filenames)
-                    print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type='Preprocessing filenames')
-
-                    if not os.path.exists(output_path):
-                        mip_image.save(output_path)
-                    else:
-                        print(f'WARNING: A file with the same name already exists at location {output_filename}')
-            else:
-                for i, (key, images) in enumerate(images_by_key.items()):
-                    plate, well, field, channel = key[:4]
-                    output_dir = os.path.join(src, channel)
-                    mip = np.max(np.stack(images), axis=0)
-                    mip_image = Image.fromarray(mip)
-                    os.makedirs(output_dir, exist_ok=True)
+            
+            # Process each batch of images
+            for i, (key, images) in enumerate(images_by_key.items()):
+                
+                plate, well, field, channel, timeID, sliceID = key
+                
+                if timelapse:
                     output_filename = f'{plate}_{well}_{field}.tif'
-                    output_path = os.path.join(output_dir, output_filename)
-                    files_processed += 1
-                    stop = time.time()
-                    duration = stop - start
-                    time_ls.append(duration)
-                    files_to_process = len(all_filenames)
-                    print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type='Preprocessing filenames')
-
-                    if not os.path.exists(output_path):
-                        mip_image.save(output_path)
-                    else:
-                        print(f'WARNING: A file with the same name already exists at location {output_filename}')
+                else:
+                    output_filename = f'{plate}_{well}_{field}_{timeID}.tif'
+                    
+                output_dir = os.path.join(src, channel)
+                os.makedirs(output_dir, exist_ok=True)
+                output_path = os.path.join(output_dir, output_filename)
+                mip = np.max(np.stack(images), axis=0)
+                mip_image = Image.fromarray(mip)
+               
+                files_processed += 1
+                stop = time.time()
+                duration = stop - start
+                time_ls.append(duration)
+                files_to_process = len(all_filenames)
+                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type='Preprocessing filenames')
+
+                if not os.path.exists(output_path):
+                    mip_image.save(output_path)
+                else:
+                    print(f'WARNING: A file with the same name already exists at location {output_filename}')
 
             images_by_key.clear()
 
@@ -1188,7 +1175,7 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
 
     paths = []
     time_ls = []
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
 
     if settings['timelapse']:
@@ -1243,7 +1230,11 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
         files_processed = 0
         for i, path in enumerate(paths):
             start = time.time()
-            array = np.load(path)
+            try:
+                array = np.load(path)
+            except Exception as e:
+                print(f"Error loading file {path}: {e}")
+                continue
             stack_ls.append(array)
             filenames_batch.append(os.path.basename(path))
             stop = time.time()
@@ -1342,7 +1333,7 @@ def _normalize_stack(src, backgrounds=[100, 100, 100], remove_backgrounds=[False
         None
     """
     paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
     time_ls = []
     
@@ -1427,7 +1418,7 @@ def _normalize_timelapse(src, lower_percentile=2, save_dtype=np.float32):
         save_dtype (numpy.dtype, optional): The data type to save the normalized stack. Defaults to np.float32.
     """
     paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
 
     for file_index, path in enumerate(paths):
@@ -1571,59 +1562,62 @@ def preprocess_img_data(settings):
         save_dtype (type, optional): The data type used for saving the preprocessed images. Defaults to np.float32.
         randomize (bool, optional): Whether to randomize the order of the images. Defaults to True.
         all_to_mip (bool, optional): Whether to convert all images to MIP. Defaults to False.
-        pick_slice (bool, optional): Whether to pick a specific slice based on the provided skip mode. Defaults to False.
-        skip_mode (str, optional): The skip mode used to filter out specific slices. Defaults to '01'.
         settings (dict, optional): Additional settings for preprocessing. Defaults to {}.
 
     Returns:
         None
     """
-    
     src = settings['src']
-    valid_ext = ['tif', 'tiff', 'png', 'jpeg']
+    
+    if len(os.listdir(src)) < 100:
+        delete_empty_subdirectories(src)
+    
     files = os.listdir(src)
-    extensions = [file.split('.')[-1] for file in files]
-    extension_counts = Counter(extensions)
-    most_common_extension = extension_counts.most_common(1)[0][0]
+    valid_ext = ['tif', 'tiff', 'png', 'jpg', 'jpeg', 'bmp', 'nd2', 'czi', 'lif']
+    extensions = [file.split('.')[-1].lower() for file in files]
+    # Filter only valid extensions
+    valid_extensions = [ext for ext in extensions if ext in valid_ext]
+    # Determine most common valid extension
     img_format = None
+    if valid_extensions:
+        extension_counts = Counter(valid_extensions)
+        most_common_extension = Counter(valid_extensions).most_common(1)[0][0]
+        img_format = most_common_extension
+    
+        print(f"Found {extension_counts[most_common_extension]} {most_common_extension} files")
     
-    delete_empty_subdirectories(src)
-
-    # Check if the most common extension is one of the specified image formats
-    if most_common_extension in valid_ext:
-        img_format = f'.{most_common_extension}'
-        print(f'Found {extension_counts[most_common_extension]} {most_common_extension} files')
     else:
-        print(f'Could not find any {valid_ext} files in {src} only found {extension_counts[0]}')
+        print(f"Could not find any {valid_ext} files in {src} only found {extension_counts[0]}")
+        print(f"{files} in {src}")
+        print(f"Please check the folder and try again")
         
         if os.path.exists(os.path.join(src,'stack')):
             print('Found existing stack folder.')
         if os.path.exists(os.path.join(src,'channel_stack')):
             print('Found existing channel_stack folder.')
-        if os.path.exists(os.path.join(src,'norm_channel_stack')):
-            print('Found existing norm_channel_stack folder. Skipping preprocessing')
+        if os.path.exists(os.path.join(src,'masks')):
+            print('Found existing masks folder. Skipping preprocessing')
             return settings, src
-        
+
     mask_channels = [settings['nucleus_channel'], settings['cell_channel'], settings['pathogen_channel']]
-    backgrounds = [settings['nucleus_background'], settings['cell_background'], settings['pathogen_background']]
-    
-    settings, metadata_type, custom_regex, nr, plot, batch_size, timelapse, lower_percentile, randomize, all_to_mip, pick_slice, skip_mode, cmap, figuresize, normalize, save_dtype, test_mode, test_images, random_test = set_default_settings_preprocess_img_data(settings)
-    
-    regex = _get_regex(metadata_type, img_format, custom_regex)
-    
-    if test_mode:
 
-        print(f'Running spacr in test mode')
+    settings = set_default_settings_preprocess_img_data(settings)
+
+    regex = _get_regex(settings['metadata_type'], img_format, settings['custom_regex'])
+    
+    if settings['test_mode']:
+        print(f"Running spacr in test mode")
         settings['plot'] = True
-        try:
-            os.rmdir(os.path.join(src, 'test'))
-            print(f"Deleted test directory: {os.path.join(src, 'test')}")
-        except OSError as e:
-            print(f"Error deleting test directory: {e}")
-            print(f"Delete manually before running test mode")
-            pass
+        if os.path.exists(os.path.join(src,'test')):
+            try:
+                os.rmdir(os.path.join(src, 'test'))
+                print(f"Deleted test directory: {os.path.join(src, 'test')}")
+            except OSError as e:
+                print(f"Error deleting test directory: {e}")
+                print(f"Delete manually before running test mode")
+                pass
 
-        src = _run_test_mode(settings['src'], regex, timelapse, test_images, random_test)
+        src = _run_test_mode(settings['src'], regex, settings['timelapse'], settings['test_images'], settings['random_test'])
         settings['src'] = src
     
     stack_path = os.path.join(src, 'stack')
@@ -1634,26 +1628,23 @@ def preprocess_img_data(settings):
     if not os.path.exists(stack_path):
         try:
             if not img_format == None:
-                if timelapse:
-                    _move_to_chan_folder(src, regex, timelapse, metadata_type)
-                else:
-                    img_format = ['.tif', '.tiff', '.png', '.jpg', '.jpeg', '.bmp', '.nd2', '.czi', '.lif']
-                    _rename_and_organize_image_files(src, regex, batch_size, pick_slice, skip_mode, metadata_type, img_format)
-                    
-                    #Make sure no batches will be of only one image
-                    all_imgs = len(stack_path)
-                    full_batches = all_imgs // batch_size
-                    last_batch_size = all_imgs % batch_size
-                    
-                    # Check if the last batch is of size 1
-                    if last_batch_size == 1:
-                        # If there's only one batch and its size is 1, it's also an issue
-                        if full_batches == 0:
-                            raise ValueError("Only one batch of size 1 detected. Adjust the batch size.")
-                        # If the last batch is of size 1, merge it with the second last batch
-                        elif full_batches > 0:
-                            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.")
+                img_format = ['.tif', '.tiff', '.png', '.jpg', '.jpeg', '.bmp', '.nd2', '.czi', '.lif']
+                _rename_and_organize_image_files(src, regex, settings['batch_size'], settings['metadata_type'], img_format)
+                
+                #Make sure no batches will be of only one image
+                all_imgs = len(stack_path)
+                full_batches = all_imgs // settings['batch_size']
+                last_batch_size = all_imgs % settings['batch_size']
+                
+                # Check if the last batch is of size 1
+                if last_batch_size == 1:
+                    # If there's only one batch and its size is 1, it's also an issue
+                    if full_batches == 0:
+                        raise ValueError("Only one batch of size 1 detected. Adjust the batch size.")
+                    # If the last batch is of size 1, merge it with the second last batch
+                    elif full_batches > 0:
+                        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.")
         
                 nr_channel_folders = _merge_channels(src, plot=False)
                 
@@ -1663,18 +1654,19 @@ def preprocess_img_data(settings):
                     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)
+                if settings['timelapse']:
+                    _create_movies_from_npy_per_channel(stack_path, fps=settings['fps'])
 
-                if plot:
-                    print(f'plotting {nr} images from {src}/stack')
-                    plot_arrays(stack_path, figuresize, cmap, nr=nr, normalize=normalize)
+                if settings['plot']:
+                    print(f"plotting {settings['nr']} images from {src}/stack")
+                    plot_arrays(stack_path, settings['figuresize'], settings['cmap'], nr=settings['nr'], normalize=settings['normalize'])
 
-                if all_to_mip:
+                if settings['all_to_mip']:
                     _mip_all(stack_path)
-                    if plot:
-                        print(f'plotting {nr} images from {src}/stack')
-                        plot_arrays(stack_path, figuresize, cmap, nr=nr, normalize=normalize)
+                    if settings['plot']:
+                        print(f"plotting {settings['nr']} images from {src}/stack")
+                        plot_arrays(stack_path, settings['figuresize'], settings['cmap'], nr=settings['nr'], normalize=settings['normalize'])
+        
         except Exception as e:
             print(f"Error: {e}")
     
@@ -1683,9 +1675,6 @@ def preprocess_img_data(settings):
                               save_dtype=np.float32,
                               settings=settings)
 
-    #if plot:
-    #    _plot_4D_arrays(src+'/norm_channel_stack', nr_npz=1, nr=nr)
-
     return settings, src
     
 def _check_masks(batch, batch_filenames, output_folder):
@@ -2002,12 +1991,12 @@ def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_di
     """
     folder_paths = [os.path.join(src+'/stack')]
 
-    if cell_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'cell_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','cell_mask_stack')]
-    if nucleus_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'nucleus_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','nucleus_mask_stack')]
-    if pathogen_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'pathogen_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','pathogen_mask_stack')]
+    if cell_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'cell_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','cell_mask_stack')]
+    if nucleus_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'nucleus_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','nucleus_mask_stack')]
+    if pathogen_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'pathogen_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','pathogen_mask_stack')]
 
     output_folder = src+'/merged'
     reference_folder = folder_paths[0]
@@ -2881,7 +2870,6 @@ def generate_training_dataset(settings):
 
         return class_paths_ls
     
-    from .io import _read_and_merge_data, _read_db
     from .utils import get_paths_from_db, annotate_conditions, save_settings
     from .settings import set_generate_training_dataset_defaults
     
@@ -3208,28 +3196,13 @@ def convert_separate_files_to_yokogawa(folder, regex):
 
     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:
-    #            used_wells.add(well_name)
-    #            return well_name
-    #        if well == "P24":  
-    #            plate += 1  
-    #    raise ValueError("All wells exhausted.")
-    
+       
     def _get_next_well(used_wells):
         """
         Determines the next available well position across multiple 384-well plates.
@@ -3297,75 +3270,92 @@ def convert_to_yokogawa(folder):
                                 filepath = os.path.join(folder, filename)
 
                                 tifffile.imwrite(filepath, mip_image.astype(dtype))
-                                rename_log.append({"Original File": file, "Renamed TIFF": filename})
+                                rename_log.append({"Original File": file, 
+                                                   "Renamed TIFF": filename,
+                                                   "ext": ext,
+                                                   "time": t_idx,
+                                                   "field": f_idx,
+                                                   "channel": channel,
+                                                   "z": z_levels})
 
                             except IndexError:
                                 print(f"Warning: ND2 file {file} has an incomplete data structure. Skipping.")
 
             except Exception as e:
                 print(f"Error processing ND2 file {file}: {e}")
-
-        ### **Process Zeiss CZI Files**
+        
         elif ext == 'czi':
-            with czifile.CziFile(path) as czi:
-                img_data = czi.asarray()  # Read the full image array
-
-                # Remove singleton dimensions (if any)
-                img_data = np.squeeze(img_data)
-
-                # Get the actual shape of the data
-                shape = img_data.shape
-                num_dims = len(shape)
-
-                # Default values if dimensions are missing
-                timepoints = 1
-                z_levels = 1
-                channels = 1
-
-                # Determine dimension mapping dynamically
-                if num_dims == 2:  # (Y, X) → Single 2D image
-                    y_dim, x_dim = shape
-                    img_data = img_data.reshape(1, 1, 1, y_dim, x_dim)  # Add missing dimensions
-                elif num_dims == 3:  # (C, Y, X) or (Z, Y, X)
-                    if shape[0] <= 4:  # Likely (C, Y, X)
-                        channels, y_dim, x_dim = shape
-                        img_data = img_data.reshape(1, 1, channels, y_dim, x_dim)  # Add missing dimensions
-                    else:  # Likely (Z, Y, X)
-                        z_levels, y_dim, x_dim = shape
-                        img_data = img_data.reshape(1, z_levels, 1, y_dim, x_dim)  # Add missing dimensions
-                elif num_dims == 4:  # Could be (T, C, Y, X) or (T, Z, Y, X) or (Z, C, Y, X)
-                    if shape[1] <= 4:  # Assume (T, C, Y, X)
-                        timepoints, channels, y_dim, x_dim = shape
-                        img_data = img_data.reshape(timepoints, 1, channels, y_dim, x_dim)  # Add missing Z
-                    else:  # Assume (T, Z, Y, X) or (Z, C, Y, X)
-                        timepoints, z_levels, y_dim, x_dim = shape
-                        img_data = img_data.reshape(timepoints, z_levels, 1, y_dim, x_dim)  # Add missing C
-                elif num_dims == 5:  # Standard (T, Z, C, Y, X)
-                    timepoints, z_levels, channels, y_dim, x_dim = shape
-                else:
-                    raise ValueError(f"Unexpected CZI shape: {shape}. Unable to process.")
-
-                # Iterate over detected timepoints, channels, and perform MIP over Z
-                for t_idx in range(timepoints):
-                    for c_idx in range(channels):
-                        # Extract Z-stack or single image
-                        if z_levels > 1:
-                            z_stack = img_data[t_idx, :, c_idx, :, :]  # MIP over Z
-                            mip_image = np.max(z_stack, axis=0)
-                        else:
-                            mip_image = img_data[t_idx, 0, c_idx, :, :]  # No Z, take directly
-
-                        # Ensure correct dtype
-                        dtype = mip_image.dtype
-
-                        # Generate Yokogawa-style filename
-                        filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
-                        filepath = os.path.join(folder, filename)
-
-                        # Save the extracted image
-                        tifffile.imwrite(filepath, mip_image.astype(dtype))
+            try:
+                # Open the CZI in streaming mode
+                with pyczi.open_czi(path) as czidoc:
+
+                    # 1) Global dimension ranges
+                    bbox    = czidoc.total_bounding_box
+                    _, tlen = bbox.get('T', (0,1))
+                    _, clen = bbox.get('C', (0,1))
+                    _, zlen = bbox.get('Z', (0,1))
+
+                    # 2) Scene → list of scene indices
+                    scenes_bb = czidoc.scenes_bounding_rectangle
+                    scenes    = sorted(scenes_bb.keys()) if scenes_bb else [None]
+
+                    # 3) Output folder (same as .czi)
+                    folder = os.path.dirname(path)
+
+                    # 4) Loop scene × time × channel × Z
+                    for scene in scenes:
+                        # *** assign a unique well for this scene ***
+                        scene_well = _get_next_well(used_wells)
+
+                        # Field index = scene+1 (or 1 if no scene)
+                        F_idx = scene + 1 if scene is not None else 1
+                        # Scene index for “A”
+                        A_idx = scene + 1 if scene is not None else 1
+
+                        for t in range(tlen):
+                            for c in range(clen):
+                                for z in range(zlen):
+                                    # Read exactly one 2D plane
+                                    arr = czidoc.read(
+                                        plane={'T': t, 'C': c, 'Z': z},
+                                        scene=scene
+                                    )
+                                    plane = np.squeeze(arr)
+
+                                    # Build Yokogawa‐style filename:
+                                    fn = (
+                                        f"{scene_well}_"
+                                        f"T{t+1:04d}"
+                                        f"F{F_idx:03d}"
+                                        f"L01"
+                                        f"A{A_idx:02d}"
+                                        f"Z{z+1:02d}"
+                                        f"C{c+1:02d}.tif"
+                                    )
+                                    outpath = os.path.join(folder, fn)
+
+                                    # Write with lossless compression
+                                    tifffile.imwrite(
+                                        outpath,
+                                        plane.astype(plane.dtype),
+                                        compression='zlib'
+                                    )
+
+                                    # Log it
+                                    rename_log.append({
+                                        "Original File": file,
+                                        "Renamed TIFF": fn,
+                                        "ext": ext,
+                                        "scene": scene,
+                                        "time": t,
+                                        "slice": z,
+                                        "field": F_idx,
+                                        "channel": c,
+                                        "well": scene_well
+                                    })
 
-                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
+            except Exception as e:
+                print(f"Error processing CZI file {file}: {e}")
 
         ### **Process Leica LIF Files**
         elif ext == 'lif':
@@ -3445,7 +3435,6 @@ def convert_to_yokogawa(folder):
             except Exception as e:
                 print(f"Error processing standard image file {file}: {e}")
 
-
     # 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/mediar.py

@@ -15,14 +15,18 @@ if not os.path.exists(init_file):
 # Add MEDIAR to sys.path
 sys.path.insert(0, mediar_path)
 
-try:
-    # Now import the dependencies from MEDIAR
-    from core.MEDIAR import Predictor, EnsemblePredictor
-    from train_tools.models import MEDIARFormer
-finally:
-    # Remove the temporary __init__.py file after the import
-    if os.path.exists(init_file):
-        os.remove(init_file)  # Remove the __init__.py file
+#try:
+#     Now import the dependencies from MEDIAR
+#    from core.MEDIAR import Predictor, EnsemblePredictor
+#    from train_tools.models import MEDIARFormer
+
+#    from train_tools.models import MEDIARFormer
+Predictor, EnsemblePredictor, MEDIARFormer = None, None, None
+
+#finally:
+#    # Remove the temporary __init__.py file after the import
+#    if os.path.exists(init_file):
+#        os.remove(init_file)  # Remove the __init__.py file
 
 def display_imgs_in_list(lists_of_imgs, cmaps=None):
     """