spacr 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

spacr/logger.py

@@ -1,20 +1,39 @@
 import logging
 import functools
+import os
 
+# Automatically configure logging
+def configure_logger(log_file_name='spacr.log'):
+    # Determine a safe location for the log file
+    home_dir = os.path.expanduser("~")  # Get the user's home directory
+    log_file_path = os.path.join(home_dir, log_file_name)  # Save log file in home directory
+
+    # Setup logging configuration
+    logging.basicConfig(
+        filename=log_file_path,
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+
+# Call the function to configure the logger
+configure_logger()
+
+# Create a logger instance for this module
 logger = logging.getLogger(__name__)
 
+# Decorator to log function calls
 def log_function_call(func):
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        args_repr = [repr(a) for a in args]
-        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
-        signature = ", ".join(args_repr + kwargs_repr)
-        logger.info(f"Calling {func.__name__}({signature})")
+        args_repr = [repr(a) for a in args]  # Arguments passed to the function
+        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]  # Keyword arguments
+        signature = ", ".join(args_repr + kwargs_repr)  # Construct the signature for logging
+        logger.info(f"Calling {func.__name__}({signature})")  # Log function call
         try:
-            result = func(*args, **kwargs)
-            logger.info(f"{func.__name__} returned {result!r}")
+            result = func(*args, **kwargs)  # Execute the function
+            logger.info(f"{func.__name__} returned {result!r}")  # Log the result
             return result
         except Exception as e:
-            logger.exception(f"Exception occurred in {func.__name__}")
-            raise
-    return wrapper
+            logger.exception(f"Exception occurred in {func.__name__}")  # Log any exceptions
+            raise  # Re-raise the exception after logging it
+    return wrapper

spacr/measure.py

@@ -16,8 +16,6 @@ from skimage.util import img_as_bool
 import matplotlib.pyplot as plt
 from math import ceil, sqrt
 
-from .logger import log_function_call
-
 def get_components(cell_mask, nucleus_mask, pathogen_mask):
     """
     Get the components (nucleus and pathogens) for each cell in the given masks.
@@ -654,43 +652,6 @@ def img_list_to_grid(grid, titles=None):
     plt.tight_layout(pad=0.1)
     return fig
 
-def filepaths_to_database(img_paths, settings, source_folder, crop_mode):
-    from. utils import _map_wells_png
-    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=settings['timelapse'])))
-
-    columns = ['plate', 'row', 'col', 'field']
-
-    if settings['timelapse']:
-        columns = columns + ['time_id']
-
-    columns = columns + ['prcfo']
-
-    if crop_mode == 'cell':
-        columns = columns + ['cell_id']
-
-    if crop_mode == 'nucleus':
-        columns = columns + ['nucleus_id']
-
-    if crop_mode == 'pathogen':
-        columns = columns + ['pathogen_id']
-
-    if crop_mode == 'cytoplasm':
-        columns = columns + ['cytoplasm_id']
-
-    png_df[columns] = parts
-
-    try:
-        conn = sqlite3.connect(f'{source_folder}/measurements/measurements.db', timeout=5)
-        png_df.to_sql('png_list', conn, if_exists='append', index=False)
-        conn.commit()
-    except sqlite3.OperationalError as e:
-        print(f"SQLite error: {e}", flush=True)
-        traceback.print_exc()
-
 #@log_function_call
 def _measure_crop_core(index, time_ls, file, settings):
 
@@ -713,7 +674,7 @@ def _measure_crop_core(index, time_ls, file, settings):
     """
     
     from .plot import _plot_cropped_arrays
-    from .utils import _merge_overlapping_objects, _filter_object, _relabel_parent_with_child_labels, _exclude_objects, normalize_to_dtype
+    from .utils import _merge_overlapping_objects, _filter_object, _relabel_parent_with_child_labels, _exclude_objects, normalize_to_dtype, filepaths_to_database
     from .utils import _merge_and_save_to_database, _crop_center, _find_bounding_box, _generate_names, _get_percentiles
 
     figs = {}
@@ -984,112 +945,126 @@ def measure_crop(settings):
         None
     """
 
-    from .io import _save_settings_to_db, _create_database
+    from .io import _save_settings_to_db
     from .timelapse import _timelapse_masks_to_gif
     from .utils import measure_test_mode, print_progress
     from .settings import get_measure_crop_settings
 
-    settings = get_measure_crop_settings(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')
-        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 not isinstance(settings['src'], (str, list)):
+        ValueError(f'src must be a string or a list of strings')
+        return
     
-    if settings['cell_mask_dim'] is None:
-        settings['include_uninfected'] = True
-    if settings['pathogen_mask_dim'] is None:
-        settings['include_uninfected'] = True
-    if settings['cell_mask_dim'] is not None and settings['pathogen_min_size'] is not None:
-        settings['cytoplasm'] = True
-    elif settings['cell_mask_dim'] is not None and settings['nucleus_min_size'] is not None:
-        settings['cytoplasm'] = True
-    else:
-        settings['cytoplasm'] = False
-
-    spacr_cores = int(mp.cpu_count() - 6)
-    if spacr_cores <= 2:
-        spacr_cores = 1
-
-    if settings['n_jobs'] > spacr_cores:
-        print(f'Warning reserving 6 CPU cores for other processes, setting n_jobs to {spacr_cores}')
-        settings['n_jobs'] = spacr_cores
+    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}')
+            settings['src'] = source_folder
+            src = source_folder
+
+            settings = get_measure_crop_settings(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')
+                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['include_uninfected'] = True
+            if settings['pathogen_mask_dim'] is None:
+                settings['include_uninfected'] = True
+            if settings['cell_mask_dim'] is not None and settings['pathogen_min_size'] is not None:
+                settings['cytoplasm'] = True
+            elif settings['cell_mask_dim'] is not None and settings['nucleus_min_size'] is not None:
+                settings['cytoplasm'] = True
+            else:
+                settings['cytoplasm'] = False
 
-    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)
+            spacr_cores = int(mp.cpu_count() - 6)
+            if spacr_cores <= 2:
+                spacr_cores = 1
 
-    if settings['timelapse_objects'] == 'nucleus':
-        if not settings['cell_mask_dim'] is None:
-            tlo = settings['timelapse_objects']
-            print(f'timelapse object:{tlo}, cells will be relabeled to nucleus labels to track cells.')
+            if settings['n_jobs'] > spacr_cores:
+                print(f'Warning reserving 6 CPU cores for other processes, setting n_jobs to {spacr_cores}')
+                settings['n_jobs'] = spacr_cores
 
-    int_setting_keys = ['cell_mask_dim', 'nucleus_mask_dim', 'pathogen_mask_dim', 'cell_min_size', 'nucleus_min_size', 'pathogen_min_size', 'cytoplasm_min_size']
-    
-    if isinstance(settings['normalize'], bool) and settings['normalize']:
-        print(f'WARNING: to notmalize single object pngs set normalize to a list of 2 integers, e.g. [1,99] (lower and upper percentiles)')
-        return
-    
-    if isinstance(settings['normalize'], list) or isinstance(settings['normalize'], bool) and settings['normalize']:
-        if settings['normalize_by'] not in ['png', 'fov']:
-            print("Warning: normalize_by should be either 'png' to notmalize each png to its own percentiles or 'fov' to normalize each png to the fov percentiles ")
-            return
-
-    if not all(isinstance(settings[key], int) or settings[key] is None for key in int_setting_keys):
-        print(f"WARNING: {int_setting_keys} must all be integers")
-        return
+            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)
 
-    if not isinstance(settings['channels'], list):
-        print(f"WARNING: channels should be a list of integers representing channels e.g. [0,1,2,3]")
-        return
+            if settings['timelapse_objects'] == 'nucleus':
+                if not settings['cell_mask_dim'] is None:
+                    tlo = settings['timelapse_objects']
+                    print(f'timelapse object:{tlo}, cells will be relabeled to nucleus labels to track cells.')
 
-    if not isinstance(settings['crop_mode'], list):
-        print(f"WARNING: crop_mode should be a list with at least one element e.g. ['cell'] or ['cell','nucleus'] or [None]")
-        return
-    
-    _save_settings_to_db(settings)
-    files = [f for f in os.listdir(settings['src']) if f.endswith('.npy')]
-    n_jobs = settings['n_jobs']
-    print(f'using {n_jobs} cpu cores')
-    print_progress(files_processed=0, files_to_process=len(files), n_jobs=n_jobs, time_ls=[], operation_type='Measure and Crop')
-
-    def job_callback(result):
-        completed_jobs.add(result[0])
-        process_meassure_crop_results([result], settings)
-        files_processed = len(completed_jobs)
-        files_to_process = len(files)
-        print_progress(files_processed, files_to_process, n_jobs, time_ls=time_ls, operation_type='Measure and Crop')
-        if files_processed >= files_to_process:
-            pool.terminate()
-
-    with mp.Manager() as manager:
-        time_ls = manager.list()
-        completed_jobs = set()  # Set to keep track of completed jobs
-        
-        with mp.Pool(n_jobs) as pool:
-            for index, file in enumerate(files):
-                pool.apply_async(_measure_crop_core, args=(index, time_ls, file, settings), callback=job_callback)
+            int_setting_keys = ['cell_mask_dim', 'nucleus_mask_dim', 'pathogen_mask_dim', 'cell_min_size', 'nucleus_min_size', 'pathogen_min_size', 'cytoplasm_min_size']
             
-            pool.close()
-            pool.join()
+            if isinstance(settings['normalize'], bool) and settings['normalize']:
+                print(f'WARNING: to notmalize single object pngs set normalize to a list of 2 integers, e.g. [1,99] (lower and upper percentiles)')
+                return
+            
+            if isinstance(settings['normalize'], list) or isinstance(settings['normalize'], bool) and settings['normalize']:
+                if settings['normalize_by'] not in ['png', 'fov']:
+                    print("Warning: normalize_by should be either 'png' to notmalize each png to its own percentiles or 'fov' to normalize each png to the fov percentiles ")
+                    return
+
+            if not all(isinstance(settings[key], int) or settings[key] is None for key in int_setting_keys):
+                print(f"WARNING: {int_setting_keys} must all be integers")
+                return
+
+            if not isinstance(settings['channels'], list):
+                print(f"WARNING: channels should be a list of integers representing channels e.g. [0,1,2,3]")
+                return
+
+            if not isinstance(settings['crop_mode'], list):
+                print(f"WARNING: crop_mode should be a list with at least one element e.g. ['cell'] or ['cell','nucleus'] or [None]")
+                return
+            
+            _save_settings_to_db(settings)
+            files = [f for f in os.listdir(settings['src']) if f.endswith('.npy')]
+            n_jobs = settings['n_jobs']
+            print(f'using {n_jobs} cpu cores')
+            print_progress(files_processed=0, files_to_process=len(files), n_jobs=n_jobs, time_ls=[], operation_type='Measure and Crop')
+
+            def job_callback(result):
+                completed_jobs.add(result[0])
+                process_meassure_crop_results([result], settings)
+                files_processed = len(completed_jobs)
+                files_to_process = len(files)
+                print_progress(files_processed, files_to_process, n_jobs, time_ls=time_ls, operation_type='Measure and Crop')
+                if files_processed >= files_to_process:
+                    pool.terminate()
+
+            with mp.Manager() as manager:
+                time_ls = manager.list()
+                completed_jobs = set()  # Set to keep track of completed jobs
+                
+                with mp.Pool(n_jobs) as pool:
+                    for index, file in enumerate(files):
+                        pool.apply_async(_measure_crop_core, args=(index, time_ls, file, settings), callback=job_callback)
+                    
+                    pool.close()
+                    pool.join()
 
-    if settings['timelapse']:
-        if settings['timelapse_objects'] == 'nucleus':
-            folder_path = settings['src']
-            mask_channels = [settings['nucleus_mask_dim'], settings['pathogen_mask_dim'], settings['cell_mask_dim']]
-            object_types = ['nucleus', 'pathogen', 'cell']
-            _timelapse_masks_to_gif(folder_path, mask_channels, object_types)
+            if settings['timelapse']:
+                if settings['timelapse_objects'] == 'nucleus':
+                    folder_path = settings['src']
+                    mask_channels = [settings['nucleus_mask_dim'], settings['pathogen_mask_dim'], settings['cell_mask_dim']]
+                    object_types = ['nucleus', 'pathogen', 'cell']
+                    _timelapse_masks_to_gif(folder_path, mask_channels, object_types)
 
-    print("Successfully completed run")
+            print("Successfully completed run")
 
 def process_meassure_crop_results(partial_results, settings):
     """

spacr/mediar.py

@@ -1,14 +1,11 @@
 import os, sys, gdown, cv2, torch
 import numpy as np
 import matplotlib.pyplot as plt
-from monai.inferers import sliding_window_inference
 import skimage.io as io
 
 # Path to the MEDIAR directory
 mediar_path = os.path.join(os.path.dirname(__file__), 'resources', 'MEDIAR')
 
-print('mediar path', mediar_path)
-
 # Temporarily create __init__.py to make MEDIAR a package
 init_file = os.path.join(mediar_path, '__init__.py')
 if not os.path.exists(init_file):