spacr 0.4.15__py3-none-any.whl → 0.5.0__py3-none-any.whl

spacr/utils.py

@@ -1,5 +1,4 @@
 import os, re, sqlite3, torch, torchvision, random, string, shutil, cv2, tarfile, glob, psutil, platform, gzip, subprocess, time, requests, ast, traceback
-
 import numpy as np
 import pandas as pd
 from cellpose import models as cp_models
@@ -78,7 +77,7 @@ def filepaths_to_database(img_paths, settings, source_folder, crop_mode):
 
     parts = png_df['file_name'].apply(lambda x: pd.Series(_map_wells_png(x, timelapse=settings['timelapse'])))
 
-    columns = ['plate', 'row_name', 'column_name', 'field']
+    columns = ['plateID', 'rowID', 'columnID', 'fieldID']
 
     if settings['timelapse']:
         columns = columns + ['time_id']
@@ -113,7 +112,7 @@ def activation_maps_to_database(img_paths, source_folder, settings):
     png_df = pd.DataFrame(img_paths, columns=['png_path'])
     png_df['file_name'] = png_df['png_path'].apply(lambda x: os.path.basename(x))
     parts = png_df['file_name'].apply(lambda x: pd.Series(_map_wells_png(x, timelapse=False)))
-    columns = ['plate', 'row_name', 'column_name', 'field', 'prcfo', 'object']
+    columns = ['plateID', 'rowID', 'columnID', 'fieldID', 'prcfo', 'object']
     png_df[columns] = parts
 
     dataset_name = os.path.splitext(os.path.basename(settings['dataset']))[0]
@@ -136,7 +135,7 @@ def activation_correlations_to_database(df, img_paths, source_folder, settings):
     png_df = pd.DataFrame(img_paths, columns=['png_path'])
     png_df['file_name'] = png_df['png_path'].apply(lambda x: os.path.basename(x))
     parts = png_df['file_name'].apply(lambda x: pd.Series(_map_wells_png(x, timelapse=False)))
-    columns = ['plate', 'row_name', 'column_name', 'field', 'prcfo', 'object']
+    columns = ['plateID', 'rowID', 'columnID', 'fieldID', 'prcfo', 'object']
     png_df[columns] = parts
 
     # Align both DataFrames by file_name
@@ -319,18 +318,26 @@ def load_settings(csv_file_path, show=False, setting_key='setting_key', setting_
 
     return result_dict
 
-
 def save_settings(settings, name='settings', show=False):
     
-    settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
-    if show:
-        display(settings_df)
+    settings_2 = settings.copy()
     
-    if isinstance(settings['src'], list):
-        src = settings['src'][0]
+    if isinstance(settings_2['src'], list):
+        src = settings_2['src'][0]
         name = f"{name}_list"
     else:
-        src = settings['src']
+        src = settings_2['src']
+        
+    if 'test_mode' in settings_2.keys():
+        settings_2['test_mode'] = False
+        
+        if 'plot' in settings_2.keys():
+            settings_2['plot'] = False
+            
+    settings_df = pd.DataFrame(list(settings_2.items()), columns=['Key', 'Value'])
+    
+    if show:
+        display(settings_df)
 
     settings_csv = os.path.join(src,'settings',f'{name}.csv')
     os.makedirs(os.path.join(src,'settings'), exist_ok=True)
@@ -546,10 +553,10 @@ def _get_cellpose_batch_size():
     except Exception as e:
         return 8
 
-def _extract_filename_metadata(filenames, src, regular_expression, metadata_type='cellvoyager', pick_slice=False, skip_mode='01'):
+def _extract_filename_metadata(filenames, src, regular_expression, metadata_type='cellvoyager'):
     
     images_by_key = defaultdict(list)
-    
+
     for filename in filenames:
         match = regular_expression.match(filename)
         if match:
@@ -560,39 +567,44 @@ def _extract_filename_metadata(filenames, src, regular_expression, metadata_type
                     plate = os.path.basename(src)
 
                 well = match.group('wellID')
-                field = match.group('fieldID')
-                channel = match.group('chanID')
-                mode = None
-
                 if well[0].isdigit():
                     well = str(_safe_int_convert(well))
+                
+                field = match.group('fieldID')
                 if field[0].isdigit():
                     field = str(_safe_int_convert(field))
+                    
+                channel = match.group('chanID')
                 if channel[0].isdigit():
                     channel = str(_safe_int_convert(channel))
-
+                    
+                if 'timeID' in match.groupdict():
+                    timeID = match.group('timeID')
+                    if timeID[0].isdigit():
+                        timeID = str(_safe_int_convert(timeID))
+                else:
+                    timeID = None
+                        
+                if 'sliceID' in match.groupdict():
+                    sliceID = match.group('sliceID')
+                    if sliceID[0].isdigit():
+                        sliceID = str(_safe_int_convert(sliceID))
+                else:
+                    sliceID = None
+                    
                 if metadata_type =='cq1':
                     orig_wellID = wellID
                     wellID = _convert_cq1_well_id(wellID)
                     print(f'Converted Well ID: {orig_wellID} to {wellID}', end='\r', flush=True)
 
-                if pick_slice:
-                    try:
-                        mode = match.group('AID')
-                    except IndexError:
-                        sliceid = '00'
-
-                    if mode == skip_mode:
-                        continue
-                        
-                key = (plate, well, field, channel, mode)
-                file_path = os.path.join(src, filename)  # Store the full path
+                key = (plate, well, field, channel, timeID, sliceID)
+                file_path = os.path.join(src, filename)
                 images_by_key[key].append(file_path)
                 
             except IndexError:
                 print(f"Could not extract information from filename {filename} using provided regex")
         else:
-            print(f"Filename {filename} did not match provided regex")
+            print(f"Filename {filename} did not match provided regex: {regular_expression}")
             continue
         
     return images_by_key
@@ -634,11 +646,11 @@ def _update_database_with_merged_info(db_path, df, table='png_list', columns=['p
     if 'prcfo' not in df.columns:
         print(f'generating prcfo columns')
         try:
-            df['prcfo'] = df['plate'].astype(str) + '_' + df['row_name'].astype(str) + '_' + df['column_name'].astype(str) + '_' + df['field'].astype(str) + '_o' + df['object_label'].astype(int).astype(str)
+            df['prcfo'] = df['plateID'].astype(str) + '_' + df['rowID'].astype(str) + '_' + df['columnID'].astype(str) + '_' + df['fieldID'].astype(str) + '_o' + df['object_label'].astype(int).astype(str)
         except Exception as e:
             print('Merging on cell failed, trying with cell_id')
         try:
-            df['prcfo'] = df['plate'].astype(str) + '_' + df['row_name'].astype(str) + '_' + df['column_name'].astype(str) + '_' + df['field'].astype(str) + '_o' + df['cell_id'].astype(int).astype(str)
+            df['prcfo'] = df['plateID'].astype(str) + '_' + df['rowID'].astype(str) + '_' + df['columnID'].astype(str) + '_' + df['fieldID'].astype(str) + '_o' + df['cell_id'].astype(int).astype(str)
         except Exception as e:
             print(e)
         
@@ -730,7 +742,7 @@ def _map_values(row, values, locs):
     if locs:
         value_dict = {loc: value for value, loc_list in zip(values, locs) for loc in loc_list}
         # Determine if we're dealing with row or column based on first location identifier
-        type_ = 'row_name' if locs[0][0][0] == 'r' else 'column_name'
+        type_ = 'rowID' if locs[0][0][0] == 'r' else 'columnID'
         return value_dict.get(row[type_], None)
     return values[0] if values else None
 
@@ -915,21 +927,21 @@ def _merge_and_save_to_database(morph_df, intensity_df, table_type, source_folde
             merged_df['file_name'] = file_name
             merged_df['path_name'] = os.path.join(source_folder, file_name + '.npy')
             if timelapse:
-                merged_df[['plate', 'row_name', 'column_name', 'field', 'timeid', 'prcf']] = merged_df['file_name'].apply(lambda x: pd.Series(_map_wells(x, timelapse)))
+                merged_df[['plateID', 'rowID', 'columnID', 'fieldID', 'timeid', 'prcf']] = merged_df['file_name'].apply(lambda x: pd.Series(_map_wells(x, timelapse)))
             else:
-                merged_df[['plate', 'row_name', 'column_name', 'field', 'prcf']] = merged_df['file_name'].apply(lambda x: pd.Series(_map_wells(x, timelapse)))
+                merged_df[['plateID', 'rowID', 'columnID', 'fieldID', 'prcf']] = merged_df['file_name'].apply(lambda x: pd.Series(_map_wells(x, timelapse)))
             cols = merged_df.columns.tolist()  # get the list of all columns
             if table_type == 'cell' or table_type == 'cytoplasm':
-                column_list = ['object_label', 'plate', 'row_name', 'column_name', 'field', 'prcf', 'file_name', 'path_name']
+                column_list = ['object_label', 'plateID', 'rowID', 'columnID', 'fieldID', 'prcf', 'file_name', 'path_name']
             elif table_type == 'nucleus' or table_type == 'pathogen':
-                column_list = ['object_label', 'cell_id', 'plate', 'row_name', 'column_name', 'field', 'prcf', 'file_name', 'path_name']
+                column_list = ['object_label', 'cell_id', 'plateID', 'rowID', 'columnID', 'fieldID', 'prcf', 'file_name', 'path_name']
             else:
                 raise ValueError(f"Invalid table_type: {table_type}")
             # Check if all columns in column_list are in cols
             missing_columns = [col for col in column_list if col not in cols]
             if len(missing_columns) == 1 and missing_columns[0] == 'cell_id':
                 missing_columns = False
-                column_list = ['object_label', 'plate', 'row_name', 'column_name', 'field', 'prcf', 'file_name', 'path_name']
+                column_list = ['object_label', 'plateID', 'rowID', 'columnID', 'fieldID', 'prcf', 'file_name', 'path_name']
             if missing_columns:
                 raise ValueError(f"Columns missing in DataFrame: {missing_columns}")
             for i, col in enumerate(column_list):
@@ -1143,43 +1155,6 @@ def _masks_to_masks_stack(masks):
     for idx, mask in enumerate(masks):
         mask_stack.append(mask)
     return mask_stack
-    
-def _get_diam_v1(mag, obj):
-
-    if mag == 20:
-        if obj == 'cell':
-            diamiter = 120
-        elif obj == 'nucleus':
-            diamiter = 60
-        elif obj == 'pathogen':
-            diamiter = 20
-        else:
-            raise ValueError("Invalid magnification: Use 20, 40 or 60")
-
-    elif mag == 40:
-        if obj == 'cell':
-            diamiter = 160
-        elif obj == 'nucleus':
-            diamiter = 80
-        elif obj == 'pathogen':
-            diamiter = 40
-        else:
-            raise ValueError("Invalid magnification: Use 20, 40 or 60")
-
-    elif mag == 60:
-        if obj == 'cell':
-            diamiter = 200
-        if obj == 'nucleus':
-            diamiter = 90
-        if obj == 'pathogen':
-            diamiter = 60
-        else:
-            raise ValueError("Invalid magnification: Use 20, 40 or 60")
-
-    else:
-        raise ValueError("Invalid magnification: Use 20, 40 or 60")
-    
-    return diamiter
 
 def _get_diam(mag, obj):
 
@@ -1339,11 +1314,11 @@ def annotate_conditions(df, cells=None, cell_loc=None, pathogens=None, pathogen_
     """
     
     def _get_type(val):
-        """Determine if a value maps to 'row_name' or 'column_name'."""
+        """Determine if a value maps to 'rowID' or 'columnID'."""
         if isinstance(val, str) and val.startswith('c'):
-            return 'column_name'
+            return 'columnID'
         elif isinstance(val, str) and val.startswith('r'):
-            return 'row_name'
+            return 'rowID'
         return None
 
     def _map_or_default(column_name, values, loc, df):
@@ -1411,7 +1386,7 @@ def _split_data(df, group_by, object_type):
     # Ensure 'prcf' column exists by concatenating specific columns
     if 'prcf' not in df.columns:
         try:
-            df['prcf'] = df['plate'].astype(str) + '_' + df['row_name'].astype(str) + '_' + df['column_name'].astype(str) + '_' + df['field'].astype(str)
+            df['prcf'] = df['plateID'].astype(str) + '_' + df['rowID'].astype(str) + '_' + df['columnID'].astype(str) + '_' + df['fieldID'].astype(str)
         except Exception as e:
             print(e)    
     
@@ -1508,7 +1483,7 @@ def _group_by_well(df):
     non_numeric_cols = df.select_dtypes(include=['object']).columns
 
     # Apply mean function to numeric columns and first to non-numeric
-    df_grouped = df.groupby(['plate', 'row_name', 'column_name']).agg({**{col: np.mean for col in numeric_cols}, **{col: 'first' for col in non_numeric_cols}})
+    df_grouped = df.groupby(['plateID', 'rowID', 'columnID']).agg({**{col: np.mean for col in numeric_cols}, **{col: 'first' for col in non_numeric_cols}})
     return df_grouped
 
 ###################################################
@@ -2187,11 +2162,11 @@ def augment_classes(dst, nc, pc, generate=True,move=True):
 def annotate_predictions(csv_loc):
     df = pd.read_csv(csv_loc)
     df['filename'] = df['path'].apply(lambda x: x.split('/')[-1])
-    df[['plate', 'well', 'field', 'object']] = df['filename'].str.split('_', expand=True)
+    df[['plateID', 'well', 'fieldID', 'object']] = df['filename'].str.split('_', expand=True)
     df['object'] = df['object'].str.replace('.png', '')
     
     def assign_condition(row):
-        plate = int(row['plate'])
+        plate = int(row['plateID'])
         col = int(row['well'][1:])
         
         if col > 3:
@@ -2342,7 +2317,7 @@ def check_multicollinearity(x):
 
 def lasso_reg(merged_df, alpha_value=0.01, reg_type='lasso'):
     # Separate predictors and response
-    X = merged_df[['gene', 'grna', 'plate', 'row_name', 'column']]
+    X = merged_df[['gene', 'grna', 'plateID', 'rowID', 'columnID']]
     y = merged_df['pred']
 
     # One-hot encode the categorical predictors
@@ -3120,12 +3095,8 @@ def _get_regex(metadata_type, img_format, custom_regex=None):
         regex = f'(?P<plateID>.*)_(?P<wellID>.*)_T(?P<timeID>.*)F(?P<fieldID>.*)L(?P<laserID>..)A(?P<AID>..)Z(?P<sliceID>.*)C(?P<chanID>.*){img_format}'
     elif metadata_type == 'cq1':
         regex = f'W(?P<wellID>.*)F(?P<fieldID>.*)T(?P<timeID>.*)Z(?P<sliceID>.*)C(?P<chanID>.*){img_format}'
-    elif metadata_type == 'nikon':
-        regex = f'(?P<plateID>.*)_(?P<wellID>.*)_T(?P<timeID>.*)F(?P<fieldID>.*)L(?P<laserID>..)A(?P<AID>..)Z(?P<sliceID>.*)C(?P<chanID>.*){img_format}'
-    elif metadata_type == 'zeis':
-        regex = f'(?P<plateID>.*)_(?P<wellID>.*)_T(?P<timeID>.*)F(?P<fieldID>.*)L(?P<laserID>..)A(?P<AID>..)Z(?P<sliceID>.*)C(?P<chanID>.*){img_format}'
-    elif metadata_type == 'leica':
-        regex = f'(?P<plateID>.*)_(?P<wellID>.*)_T(?P<timeID>.*)F(?P<fieldID>.*)L(?P<laserID>..)A(?P<AID>..)Z(?P<sliceID>.*)C(?P<chanID>.*){img_format}'
+    elif metadata_type == 'auto':
+        regex = f'(?P<plateID>.*)_(?P<wellID>.*)_T(?P<timeID>.*)F(?P<fieldID>.*)L(?P<laserID>.*)C(?P<chanID>.*).tif'     
     elif metadata_type == 'custom':
         regex = f'({custom_regex}){img_format}'
         
@@ -3143,7 +3114,7 @@ def _run_test_mode(src, regex, timelapse=False, test_images=10, random_test=True
 
     if os.path.exists(os.path.join(src, 'orig')):
         src = os.path.join(src, 'orig')
-    
+        
     all_filenames = [filename for filename in os.listdir(src) if regular_expression.match(filename)]
     print(f'Found {len(all_filenames)} files')
     images_by_set = defaultdict(list)
@@ -3185,7 +3156,6 @@ def _choose_model(model_name, device, object_type='cell', restore_type=None, obj
             model_path = os.path.join(current_dir, 'models', 'cp', 'toxo_pv_lumen.CP_model')
             print(model_path)
             model = cp_models.CellposeModel(gpu=torch.cuda.is_available(), model_type=None, pretrained_model=model_path, diam_mean=diameter, device=device)
-            #model = cp_models.Cellpose(gpu=torch.cuda.is_available(), model_type='cyto', device=device)
             print(f'Using Toxoplasma PV lumen model to generate pathogen masks')
             return model
     
@@ -3313,15 +3283,6 @@ class SaliencyMapGenerator:
         return fig
     
     def percentile_normalize(self, img, lower_percentile=2, upper_percentile=98):
-        """
-        Normalize each channel of the image to the given percentiles.
-        Args:
-            img: Input image as numpy array with shape (H, W, C)
-            lower_percentile: Lower percentile for normalization (default 2)
-            upper_percentile: Upper percentile for normalization (default 98)
-        Returns:
-            img: Normalized image
-        """
         img_normalized = np.zeros_like(img)
 
         for c in range(img.shape[2]):  # Iterate over each channel
@@ -3331,7 +3292,6 @@ class SaliencyMapGenerator:
 
         return img_normalized
 
-
 class GradCAMGenerator:
     def __init__(self, model, target_layer, cam_type='gradcam'):
         self.model = model
@@ -3436,15 +3396,6 @@ class GradCAMGenerator:
         return fig
     
     def percentile_normalize(self, img, lower_percentile=2, upper_percentile=98):
-        """
-        Normalize each channel of the image to the given percentiles.
-        Args:
-            img: Input image as numpy array with shape (H, W, C)
-            lower_percentile: Lower percentile for normalization (default 2)
-            upper_percentile: Upper percentile for normalization (default 98)
-        Returns:
-            img: Normalized image
-        """
         img_normalized = np.zeros_like(img)
 
         for c in range(img.shape[2]):  # Iterate over each channel
@@ -4714,12 +4665,12 @@ def process_vision_results(df, threshold=0.5):
     # Split the 'path' column using _map_wells function
     mapped_values = df['path'].apply(lambda x: _map_wells(x))
     
-    df['plate'] = mapped_values.apply(lambda x: x[0])
-    df['row_name'] = mapped_values.apply(lambda x: x[1])
-    df['column'] = mapped_values.apply(lambda x: x[2])
-    df['field'] = mapped_values.apply(lambda x: x[3])
+    df['plateID'] = mapped_values.apply(lambda x: x[0])
+    df['rowID'] = mapped_values.apply(lambda x: x[1])
+    df['columnID'] = mapped_values.apply(lambda x: x[2])
+    df['fieldID'] = mapped_values.apply(lambda x: x[3])
     df['object'] = df['path'].str.split('_').str[3].str.split('.').str[0]
-    df['prc'] = df['plate'].astype(str) + '_' + df['row_name'].astype(str) + '_' + df['column'].astype(str)
+    df['prc'] = df['plateID'].astype(str) + '_' + df['rowID'].astype(str) + '_' + df['columnID'].astype(str)
     df['cv_predictions'] = (df['pred'] >= threshold).astype(int)
 
     return df
@@ -4732,10 +4683,10 @@ def get_ml_results_paths(src, model_type='xgboost', channel_of_interest=1):
     elif isinstance(channel_of_interest, int):
         feature_string = f"channel_{channel_of_interest}"
 
-    elif channel_of_interest is 'morphology':
+    elif channel_of_interest == 'morphology':
         feature_string = 'morphology'
 
-    elif channel_of_interest is None:
+    elif channel_of_interest == None:
         feature_string = 'all_features'
     else:
         raise ValueError(f"Unsupported channel_of_interest: {channel_of_interest}. Supported values are 'int', 'list', 'None', or 'morphology'.")
@@ -5134,24 +5085,24 @@ def fill_holes_in_mask(mask):
 
 def correct_metadata_column_names(df):
     if 'plate_name' in df.columns:
-        df = df.rename(columns={'plate_name': 'plate'})
+        df = df.rename(columns={'plate_name': 'plateID'})
     if 'column_name' in df.columns:
-        df = df.rename(columns={'column_name': 'column'})
+        df = df.rename(columns={'column_name': 'columnID'})
     if 'col' in df.columns:
-        df = df.rename(columns={'col': 'column'})
+        df = df.rename(columns={'col': 'columnID'})
     if 'row_name' in df.columns:
-        df = df.rename(columns={'row_name': 'row_name'})
+        df = df.rename(columns={'row_name': 'rowID'})
     if 'grna_name' in df.columns:
         df = df.rename(columns={'grna_name': 'grna'})
     if 'plate_row' in df.columns:
-        df[['plate', 'row_name']] = df['plate_row'].str.split('_', expand=True)
+        df[['plateID', 'rowID']] = df['plate_row'].str.split('_', expand=True)
     return df
 
-def control_filelist(folder, mode='column', values=['01','02']):
+def control_filelist(folder, mode='columnID', values=['01','02']):
     files = os.listdir(folder)
-    if mode is 'column':
+    if mode == 'columnID':
         filtered_files = [file for file in files if file.split('_')[1][1:] in values]
-    if mode is 'row_name':
+    if mode == 'rowID':
         filtered_files = [file for file in files if file.split('_')[1][:1] in values]
     return filtered_files
     
@@ -5169,12 +5120,12 @@ def rename_columns_in_db(db_path):
             columns_info = cursor.fetchall()
             column_names = [col[1] for col in columns_info]
 
-            # Check if columns 'row' or 'col' exist
+            # Check if columns 'rowID' or 'columnID' exist
             columns_to_rename = {}
             if 'row' in column_names:
-                columns_to_rename['row'] = 'row_name'
+                columns_to_rename['row'] = 'rowID'
             if 'col' in column_names:
-                columns_to_rename['col'] = 'column_name'
+                columns_to_rename['col'] = 'columnID'
             
             # Rename columns if necessary
             if columns_to_rename:
@@ -5418,3 +5369,110 @@ def normalize_src_path(src):
         return src  # Return as a string if not a list
 
     raise ValueError(f"Invalid type for 'src': {type(src).__name__}, expected str or list")
+
+def generate_image_path_map(root_folder, valid_extensions=("tif", "tiff", "png", "jpg", "jpeg", "bmp", "czi", "nd2", "lif")):
+    """
+    Recursively scans a folder and its subfolders for images, then creates a mapping of:
+    {original_image_path: new_image_path}, where the new path includes all subfolder names.
+
+    Args:
+        root_folder (str): The root directory to scan for images.
+        valid_extensions (tuple): Tuple of valid image file extensions.
+
+    Returns:
+        dict: A dictionary mapping original image paths to their new paths.
+    """
+    image_path_map = {}
+
+    for dirpath, _, filenames in os.walk(root_folder):
+        for file in filenames:
+            ext = file.lower().split('.')[-1]
+            if ext in valid_extensions:
+                # Get relative path of the image from root_folder
+                relative_path = os.path.relpath(dirpath, root_folder)
+                
+                # Construct new filename: Embed folder hierarchy into the name
+                folder_parts = relative_path.split(os.sep)  # Get all folder names
+                folder_info = "_".join(folder_parts) if folder_parts else ""  # Join with underscores
+                
+                # Generate new filename
+                new_filename = f"{folder_info}_{file}" if folder_info else file
+
+                # Store in dictionary (original path -> new path)
+                original_path = os.path.join(dirpath, file)
+                new_path = os.path.join(root_folder, new_filename)
+                image_path_map[original_path] = new_path
+
+    return image_path_map
+
+def copy_images_to_consolidated(image_path_map, root_folder):
+    """
+    Copies images from their original locations to a 'consolidated' folder,
+    renaming them according to the generated dictionary.
+
+    Args:
+        image_path_map (dict): Dictionary mapping {original_path: new_path}.
+        root_folder (str): The root directory where the 'consolidated' folder will be created.
+    """
+    
+    consolidated_folder = os.path.join(root_folder, "consolidated")
+    os.makedirs(consolidated_folder, exist_ok=True)  # Ensure 'consolidated' folder exists
+    files_processed = 0
+    files_to_process = len(image_path_map)
+    time_ls= []
+    
+    for original_path, new_path in image_path_map.items():
+        
+        start = time.time()
+        new_filename = os.path.basename(new_path)  # Extract only the new filename
+        new_file_path = os.path.join(consolidated_folder, new_filename)  # Place in 'consolidated' folder
+        
+        shutil.copy2(original_path, new_file_path)  # Copy file with metadata preserved
+        
+        files_processed += 1
+        stop = time.time()
+        duration = (stop - start)
+        time_ls.append(duration)
+        
+        print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type=f'Consolidating images')
+        #print(f"Copied: {original_path} -> {new_file_path}")
+        
+def correct_metadata(df):
+    
+    #if 'object' in df.columns:
+    #    df['objectID'] = df['object']
+        
+    if 'object_name' in df.columns:
+        df['objectID'] = df['object_name']
+    
+    if 'field_name' in df.columns:
+        df['fieldID'] = df['field_name']
+    
+    if 'plate' in df.columns:
+        df['plateID'] = df['plate']
+    
+    if 'plate_name' in df.columns:
+        df['plateID'] = df['plate_name']
+    
+    if 'row' in df.columns:
+        df = df.rename(columns={'row': 'rowID'})
+        
+    if 'row_name' in df.columns:
+        df = df.rename(columns={'row_name': 'rowID'})
+        
+    if 'col' in df.columns:
+        df = df.rename(columns={'col': 'columnID'})
+        
+    if 'column' in df.columns:
+        df = df.rename(columns={'column': 'columnID'})
+        
+    if 'column_name' in df.columns:
+        df = df.rename(columns={'column_name': 'columnID'})
+        
+    if 'field' in df.columns:
+        df = df.rename(columns={'field': 'fieldID'})
+
+    if 'field_name' in df.columns:
+        df = df.rename(columns={'field_name': 'fieldID'})
+    
+    return df

{spacr-0.4.15.dist-info → spacr-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.4.15
+Version: 0.5.0
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -41,6 +41,9 @@ Requires-Dist: pillow<11.0,>=10.2.0
 Requires-Dist: tifffile>=2023.4.12
 Requires-Dist: nd2reader<4.0,>=3.3.0
 Requires-Dist: czifile
+Requires-Dist: pylibCZIrw<6.0,>=5.0.0
+Requires-Dist: aicspylibczi
+Requires-Dist: readlif
 Requires-Dist: imageio<3.0,>=2.34.0
 Requires-Dist: pingouin<1.0,>=0.5.5
 Requires-Dist: umap-learn<1.0,>=0.5.6
@@ -78,7 +81,7 @@ Provides-Extra: headless
 Requires-Dist: opencv-python-headless; extra == "headless"
 
 .. |Documentation Status| image:: https://readthedocs.org/projects/spacr/badge/?version=latest
-   :target: https://spacr.readthedocs.io/en/latest/?badge=latest
+   :target: https://einarolafsson.github.io/spacr
 .. |PyPI version| image:: https://badge.fury.io/py/spacr.svg
    :target: https://badge.fury.io/py/spacr
 .. |Python version| image:: https://img.shields.io/pypi/pyversions/spacr