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

spacr/gui_core.py

@@ -1083,81 +1083,6 @@ def process_console_queue():
     # **Continue processing if no error was detected**
     after_id = console_output.after(uppdate_frequency, process_console_queue)
     parent_frame.after_tasks.append(after_id)
-    
-def process_console_queue_v2():
-    global q, console_output, parent_frame, progress_bar, process_console_queue
-
-    # Initialize function attribute if it doesn't exist
-    if not hasattr(process_console_queue, "completed_tasks"):
-        process_console_queue.completed_tasks = []
-    if not hasattr(process_console_queue, "current_maximum"):
-        process_console_queue.current_maximum = None
-
-    ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
-
-    while not q.empty():
-        message = q.get_nowait()
-        clean_message = ansi_escape_pattern.sub('', message)
-
-        # **Abort Execution if an Error Message is Detected**
-        if clean_message.startswith("Error:"):
-            console_output.insert(tk.END, clean_message + "\n", "error")
-            console_output.see(tk.END)
-            print("Run aborted due to error:", clean_message)  # Debug message
-            return  # **Exit immediately to stop further execution**
-
-        # Check if the message contains progress information
-        if clean_message.startswith("Progress:"):
-            try:
-                # Extract the progress information
-                match = re.search(r'Progress: (\d+)/(\d+), operation_type: ([\w\s]*),(.*)', clean_message)
-
-                if match:
-                    current_progress = int(match.group(1))
-                    total_progress = int(match.group(2))
-                    operation_type = match.group(3).strip()
-                    additional_info = match.group(4).strip()  # Capture everything after operation_type
-                    
-                    # Check if the maximum value has changed
-                    if process_console_queue.current_maximum != total_progress:
-                        process_console_queue.current_maximum = total_progress
-                        process_console_queue.completed_tasks = []
-
-                    # Add the task to the completed set
-                    process_console_queue.completed_tasks.append(current_progress)
-                    
-                    # Calculate the unique progress count
-                    unique_progress_count = len(np.unique(process_console_queue.completed_tasks))
-
-                    # Update the progress bar
-                    if progress_bar:
-                        progress_bar['maximum'] = total_progress
-                        progress_bar['value'] = unique_progress_count
-
-                    # Store operation type and additional info
-                    if operation_type:
-                        progress_bar.operation_type = operation_type
-                        progress_bar.additional_info = additional_info
-
-                    # Update the progress label
-                    if progress_bar.progress_label:
-                        progress_bar.update_label()
-
-                    # Clear completed tasks when progress is complete
-                    if unique_progress_count >= total_progress:
-                        process_console_queue.completed_tasks.clear()
-
-            except Exception as e:
-                print(f"Error parsing progress message: {e}")
-
-        else:
-            # Insert non-progress messages into the console
-            console_output.insert(tk.END, clean_message + "\n")
-            console_output.see(tk.END)
-
-    # **Continue processing if no error was detected**
-    after_id = console_output.after(uppdate_frequency, process_console_queue)
-    parent_frame.after_tasks.append(after_id)
 
 def main_thread_update_function(root, q, fig_queue, canvas_widget):
     global uppdate_frequency

spacr/measure.py

@@ -2,12 +2,11 @@ import os, cv2, time, sqlite3, traceback, shutil
 import numpy as np
 import pandas as pd
 from collections import defaultdict
-from scipy.stats import pearsonr
+from scipy.stats import pearsonr, skew, kurtosis, mode
 import multiprocessing as mp
-from scipy.ndimage import distance_transform_edt, generate_binary_structure
+from scipy.ndimage import distance_transform_edt, generate_binary_structure, binary_dilation, gaussian_filter, center_of_mass
 from skimage.measure import regionprops, regionprops_table, shannon_entropy
 from skimage.exposure import rescale_intensity
-from scipy.ndimage import binary_dilation
 from skimage.segmentation import find_boundaries
 from skimage.feature import graycomatrix, graycoprops
 from mahotas.features import zernike_moments
@@ -16,7 +15,6 @@ from skimage.util import img_as_bool
 import matplotlib.pyplot as plt
 from math import ceil, sqrt
 
-
 def get_components(cell_mask, nucleus_mask, pathogen_mask):
     """
     Get the components (nucleus and pathogens) for each cell in the given masks.
@@ -250,6 +248,148 @@ def _create_dataframe(radial_distributions, object_type):
         return df
 
 def _extended_regionprops_table(labels, image, intensity_props):
+    """
+    Calculate extended region properties table, adding a suite of advanced quantitative features.
+    """
+    
+    def _gini(array):
+        # Compute Gini coefficient (nan safe)
+        array = np.abs(array[~np.isnan(array)])
+        n = array.size
+        if n == 0:
+            return np.nan
+        array = np.sort(array)
+        index = np.arange(1, n + 1)
+        return (np.sum((2 * index - n - 1) * array)) / (n * np.sum(array)) if np.sum(array) else np.nan
+    
+    props = regionprops_table(labels, image, properties=intensity_props)
+    df = pd.DataFrame(props)
+
+    regions = regionprops(labels, intensity_image=image)
+    integrated_intensity = []
+    std_intensity = []
+    median_intensity = []
+    skew_intensity = []
+    kurtosis_intensity = []
+    mode_intensity = []
+    range_intensity = []
+    iqr_intensity = []
+    cv_intensity = []
+    gini_intensity = []
+    frac_high90 = []
+    frac_low10 = []
+    entropy_intensity = []
+
+    for region in regions:
+        intens = region.intensity_image[region.image]
+        intens = intens[~np.isnan(intens)]
+        if intens.size == 0:
+            integrated_intensity.append(np.nan)
+            std_intensity.append(np.nan)
+            median_intensity.append(np.nan)
+            skew_intensity.append(np.nan)
+            kurtosis_intensity.append(np.nan)
+            mode_intensity.append(np.nan)
+            range_intensity.append(np.nan)
+            iqr_intensity.append(np.nan)
+            cv_intensity.append(np.nan)
+            gini_intensity.append(np.nan)
+            frac_high90.append(np.nan)
+            frac_low10.append(np.nan)
+            entropy_intensity.append(np.nan)
+        else:
+            integrated_intensity.append(np.sum(intens))
+            std_intensity.append(np.std(intens))
+            median_intensity.append(np.median(intens))
+            skew_intensity.append(skew(intens) if intens.size > 2 else np.nan)
+            kurtosis_intensity.append(kurtosis(intens) if intens.size > 3 else np.nan)
+            # Mode (use first mode value if multimodal)
+            try:
+                mode_val = mode(intens, nan_policy='omit').mode
+                mode_intensity.append(mode_val[0] if len(mode_val) > 0 else np.nan)
+            except Exception:
+                mode_intensity.append(np.nan)
+            range_intensity.append(np.ptp(intens))
+            iqr_intensity.append(np.percentile(intens, 75) - np.percentile(intens, 25))
+            cv_intensity.append(np.std(intens) / np.mean(intens) if np.mean(intens) != 0 else np.nan)
+            gini_intensity.append(_gini(intens))
+            frac_high90.append(np.mean(intens > np.percentile(intens, 90)))
+            frac_low10.append(np.mean(intens < np.percentile(intens, 10)))
+            entropy_intensity.append(shannon_entropy(intens) if intens.size > 1 else 0.0)
+
+    df['integrated_intensity'] = integrated_intensity
+    df['std_intensity'] = std_intensity
+    df['median_intensity'] = median_intensity
+    df['skew_intensity'] = skew_intensity
+    df['kurtosis_intensity'] = kurtosis_intensity
+    df['mode_intensity'] = mode_intensity
+    df['range_intensity'] = range_intensity
+    df['iqr_intensity'] = iqr_intensity
+    df['cv_intensity'] = cv_intensity
+    df['gini_intensity'] = gini_intensity
+    df['frac_high90'] = frac_high90
+    df['frac_low10'] = frac_low10
+    df['entropy_intensity'] = entropy_intensity
+
+    percentiles = [5, 10, 25, 50, 75, 85, 95]
+    for p in percentiles:
+        df[f'percentile_{p}'] = [
+            np.percentile(region.intensity_image[region.image], p)
+            for region in regions
+        ]
+    return df
+
+def _extended_regionprops_table_v2(labels, image, intensity_props):
+    """
+    Calculate extended region properties table, adding integrated intensity,
+    skewness, kurtosis, std, and median intensity per region.
+    """
+    # regionprops_table gives you vectorized props, but not everything you want
+    props = regionprops_table(labels, image, properties=intensity_props)
+    df = pd.DataFrame(props)
+
+    # Compute extra features region-by-region
+    regions = regionprops(labels, intensity_image=image)
+    integrated_intensity = []
+    std_intensity = []
+    median_intensity = []
+    skew_intensity = []
+    kurtosis_intensity = []
+    for region in regions:
+        intens = region.intensity_image[region.image]
+        # Handle empty region edge-case (shouldn't happen)
+        if intens.size == 0:
+            integrated_intensity.append(np.nan)
+            std_intensity.append(np.nan)
+            median_intensity.append(np.nan)
+            skew_intensity.append(np.nan)
+            kurtosis_intensity.append(np.nan)
+        else:
+            integrated_intensity.append(np.sum(intens))
+            std_intensity.append(np.std(intens))
+            median_intensity.append(np.median(intens))
+            # Only valid for >2 pixels
+            skew_intensity.append(skew(intens) if intens.size > 2 else np.nan)
+            kurtosis_intensity.append(kurtosis(intens) if intens.size > 3 else np.nan)
+
+    df['integrated_intensity'] = integrated_intensity
+    df['std_intensity'] = std_intensity
+    df['median_intensity'] = median_intensity
+    df['skew_intensity'] = skew_intensity
+    df['kurtosis_intensity'] = kurtosis_intensity
+
+    # You can add other features here if desired
+
+    # Percentiles (your existing code—optional if you want to keep)
+    percentiles = [5, 10, 25, 50, 75, 85, 95]
+    for p in percentiles:
+        df[f'percentile_{p}'] = [
+            np.percentile(region.intensity_image[region.image], p)
+            for region in regions
+        ]
+    return df
+
+def _extended_regionprops_table_v1(labels, image, intensity_props):
     """
     Calculate extended region properties table.
 
@@ -495,8 +635,75 @@ def _estimate_blur(image):
     # Compute and return the variance of the Laplacian
     return lap.var()
 
+def _measure_intensity_distance(cell_mask, nucleus_mask, pathogen_mask, channel_arrays, settings):
+    """
+    Compute Gaussian-smoothed intensity-weighted centroid distances for each cell object.
+    """
+
+    sigma = settings.get('distance_gaussian_sigma', 1.0)
+    cell_labels = np.unique(cell_mask)
+    cell_labels = cell_labels[cell_labels > 0]
+
+    dfs = []
+    nucleus_dt = distance_transform_edt(nucleus_mask == 0)
+    pathogen_dt = distance_transform_edt(pathogen_mask == 0)
+
+    for ch in range(channel_arrays.shape[-1]):
+        channel_img = channel_arrays[:, :, ch]
+        blurred_img = gaussian_filter(channel_img, sigma=sigma)
+
+        data = []
+        for label in cell_labels:
+            cell_coords = np.argwhere(cell_mask == label)
+            if cell_coords.size == 0:
+                data.append([label, np.nan, np.nan])
+                continue
+
+            minr, minc = np.min(cell_coords, axis=0)
+            maxr, maxc = np.max(cell_coords, axis=0) + 1
+
+            cell_submask = (cell_mask[minr:maxr, minc:maxc] == label)
+            blurred_subimg = blurred_img[minr:maxr, minc:maxc]
+
+            if np.sum(cell_submask) == 0:
+                data.append([label, np.nan, np.nan])
+                continue
+
+            masked_intensity = blurred_subimg * cell_submask
+            com_local = center_of_mass(masked_intensity)
+            if np.isnan(com_local[0]):
+                data.append([label, np.nan, np.nan])
+                continue
+
+            com_global = (com_local[0] + minr, com_local[1] + minc)
+            com_global_int = tuple(np.round(com_global).astype(int))
+
+            x, y = com_global_int
+            if not (0 <= x < cell_mask.shape[0] and 0 <= y < cell_mask.shape[1]):
+                data.append([label, np.nan, np.nan])
+                continue
+
+            nucleus_dist = nucleus_dt[x, y]
+            pathogen_dist = pathogen_dt[x, y]
+
+            data.append([label, nucleus_dist, pathogen_dist])
+
+        df = pd.DataFrame(data, columns=['label',
+                                         f'cell_channel_{ch}_distance_to_nucleus',
+                                         f'cell_channel_{ch}_distance_to_pathogen'])
+        dfs.append(df)
+
+    # Merge all channel dataframes on label
+    merged_df = dfs[0]
+    for df in dfs[1:]:
+        merged_df = merged_df.merge(df, on='label', how='outer')
+
+    return merged_df
+
+
 #@log_function_call
 def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, channel_arrays, settings, sizes=[3, 6, 12, 24], periphery=True, outside=True):
+    
     """
     Calculate various intensity measurements for different regions in the image.
 
@@ -536,8 +743,8 @@ def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_ma
                 df.append(empty_df)
                 continue
                 
-            mask_intensity_df = _extended_regionprops_table(label, channel, intensity_props) 
-            mask_intensity_df['shannon_entropy'] = shannon_entropy(channel, base=2)
+            mask_intensity_df = _extended_regionprops_table(label, channel, intensity_props)
+            #mask_intensity_df['shannon_entropy'] = shannon_entropy(channel, base=2)
 
             if homogeneity:
                 homogeneity_df = _calculate_homogeneity(label, channel, distances)
@@ -558,6 +765,10 @@ def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_ma
 
             mask_intensity_df.columns = [f'{ls[j]}_channel_{i}_{col}' if col != 'label' else col for col in mask_intensity_df.columns]
             df.append(mask_intensity_df)
+            
+    if isinstance(settings['distance_gaussian_sigma'], int):
+        intensity_distance_df = _measure_intensity_distance(cell_mask, nucleus_mask, pathogen_mask, channel_arrays, settings)
+        cell_dfs.append(intensity_distance_df)
     
     if radial_dist:
         if np.max(nucleus_mask) != 0:
@@ -565,7 +776,7 @@ def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_ma
             nucleus_df = _create_dataframe(nucleus_radial_distributions, 'nucleus')
             dfs[1].append(nucleus_df)
             
-        if np.max(nucleus_mask) != 0:
+        if np.max(pathogen_mask) != 0:
             pathogen_radial_distributions = _calculate_radial_distribution(cell_mask, pathogen_mask, channel_arrays, num_bins=6)
             pathogen_df = _create_dataframe(pathogen_radial_distributions, 'pathogen')
             dfs[2].append(pathogen_df)
@@ -785,6 +996,7 @@ def _measure_crop_core(index, time_ls, file, settings):
                 #merge skeleton_df with cell_df here
 
             cell_intensity_df, nucleus_intensity_df, pathogen_intensity_df, cytoplasm_intensity_df = _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, channel_arrays, settings, sizes=[1, 2, 3, 4, 5], periphery=True, outside=True)
+                        
             if settings['cell_mask_dim'] is not None:
                 cell_merged_df = _merge_and_save_to_database(cell_df, cell_intensity_df, 'cell', source_folder, file_name, settings['experiment'], settings['timelapse'])
             if settings['nucleus_mask_dim'] is not None:

spacr/plot.py

@@ -1241,103 +1241,6 @@ def _display_gif(path):
     """
     with open(path, 'rb') as file:
         display(ipyimage(file.read()))
-
-def _plot_recruitment_v2(df, df_type, channel_of_interest, columns=[], figuresize=10):
-    """
-    Plot recruitment data for different conditions and pathogens.
-
-    Args:
-        df (DataFrame): The input DataFrame containing the recruitment data.
-        df_type (str): The type of DataFrame (e.g., 'train', 'test').
-        channel_of_interest (str): The channel of interest for plotting.
-        target (str): The target variable for plotting.
-        columns (list, optional): Additional columns to plot. Defaults to an empty list.
-        figuresize (int, optional): The size of the figure. Defaults to 50.
-
-    Returns:
-        None
-    """
-
-    color_list = [(55/255, 155/255, 155/255), 
-                  (155/255, 55/255, 155/255), 
-                  (55/255, 155/255, 255/255), 
-                  (255/255, 55/255, 155/255)]
-
-    sns.set_palette(sns.color_palette(color_list))
-    font = figuresize/2
-    width=figuresize
-    height=figuresize/4
-
-    # Create the subplots
-    fig, axes = plt.subplots(nrows=1, ncols=4, figsize=(width, height))
-
-    # Plot for 'cell_channel' on axes[0]
-    plotter_cell = spacrGraph(df,grouping_column='condition', data_column=f'cell_channel_{channel_of_interest}_mean_intensity')
-    plotter_cell.create_plot(ax=axes[0])
-    axes[0].set_xlabel(f'pathogen {df_type}', fontsize=font)
-    axes[0].set_ylabel(f'cell_channel_{channel_of_interest}_mean_intensity', fontsize=font)
-
-    # Plot for 'nucleus_channel' on axes[1]
-    plotter_nucleus = spacrGraph(df,grouping_column='condition', data_column=f'nucleus_channel_{channel_of_interest}_mean_intensity')
-    plotter_nucleus.create_plot(ax=axes[1])
-    axes[1].set_xlabel(f'pathogen {df_type}', fontsize=font)
-    axes[1].set_ylabel(f'nucleus_channel_{channel_of_interest}_mean_intensity', fontsize=font)
-
-    # Plot for 'cytoplasm_channel' on axes[2]
-    plotter_cytoplasm = spacrGraph(df, grouping_column='condition', data_column=f'cytoplasm_channel_{channel_of_interest}_mean_intensity')
-    plotter_cytoplasm.create_plot(ax=axes[2])
-    axes[2].set_xlabel(f'pathogen {df_type}', fontsize=font)
-    axes[2].set_ylabel(f'cytoplasm_channel_{channel_of_interest}_mean_intensity', fontsize=font)
-
-    # Plot for 'pathogen_channel' on axes[3]
-    plotter_pathogen = spacrGraph(df, grouping_column='condition', data_column=f'pathogen_channel_{channel_of_interest}_mean_intensity')
-    plotter_pathogen.create_plot(ax=axes[3])
-    axes[3].set_xlabel(f'pathogen {df_type}', fontsize=font)
-    axes[3].set_ylabel(f'pathogen_channel_{channel_of_interest}_mean_intensity', fontsize=font)
-
-    #axes[0].legend_.remove()
-    #axes[1].legend_.remove()
-    #axes[2].legend_.remove()
-    #axes[3].legend_.remove()
-
-    handles, labels = axes[3].get_legend_handles_labels()
-    axes[3].legend(handles, labels, bbox_to_anchor=(1.05, 0.5), loc='center left')
-    for i in [0,1,2,3]:
-        axes[i].tick_params(axis='both', which='major', labelsize=font)
-        axes[i].set_xticklabels(axes[i].get_xticklabels(), rotation=45)
-
-    plt.tight_layout()
-    plt.show()
-
-    columns = columns + ['pathogen_cytoplasm_mean_mean', 'pathogen_cytoplasm_q75_mean', 'pathogen_periphery_cytoplasm_mean_mean', 'pathogen_outside_cytoplasm_mean_mean', 'pathogen_outside_cytoplasm_q75_mean']
-    #columns = columns + [f'pathogen_slope_channel_{channel_of_interest}', f'pathogen_cell_distance_channel_{channel_of_interest}', f'nucleus_cell_distance_channel_{channel_of_interest}']
-
-    width = figuresize*2
-    columns_per_row = math.ceil(len(columns) / 2)
-    height = (figuresize*2)/columns_per_row
-
-    fig, axes = plt.subplots(nrows=2, ncols=columns_per_row, figsize=(width, height * 2))
-    axes = axes.flatten()
-
-    print(f'{columns}')
-    for i, col in enumerate(columns):
-        ax = axes[i]
-        plotter_col = spacrGraph(df, grouping_column='condition', data_column=col)
-        plotter_col.create_plot(ax=ax)
-        ax.set_xlabel(f'pathogen {df_type}', fontsize=font)
-        ax.set_ylabel(f'{col}', fontsize=int(font * 2))
-        #ax.legend_.remove()
-        ax.tick_params(axis='both', which='major', labelsize=font)
-        ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
-        if i <= 5:
-            ax.set_ylim(1, None)
-
-    # Turn off any unused axes
-    for i in range(len(columns), len(axes)):
-        axes[i].axis('off')
-
-    plt.tight_layout()
-    plt.show()
         
 def _plot_recruitment(df, df_type, channel_of_interest, columns=[], figuresize=10):
     """
@@ -1843,31 +1746,6 @@ def print_mask_and_flows(stack, mask, flows, overlay=True, max_size=1000, thickn
     fig.tight_layout()
     plt.show()
     
-def plot_resize_v1(images, resized_images, labels, resized_labels):
-    # Display an example image and label before and after resizing
-    fig, ax = plt.subplots(2, 2, figsize=(20, 20))
-    
-    # Check if the image is grayscale; if so, add a colormap and keep dimensions correct
-    if images[0].ndim == 2:  # Grayscale image
-        ax[0, 0].imshow(images[0], cmap='gray')
-    else:  # RGB or RGBA image
-        ax[0, 0].imshow(images[0])
-    ax[0, 0].set_title('Original Image')
-
-    if resized_images[0].ndim == 2:  # Grayscale image
-        ax[0, 1].imshow(resized_images[0], cmap='gray')
-    else:  # RGB or RGBA image
-        ax[0, 1].imshow(resized_images[0])
-    ax[0, 1].set_title('Resized Image')
-
-    # Assuming labels are always grayscale (most common scenario)
-    ax[1, 0].imshow(labels[0], cmap='gray')
-    ax[1, 0].set_title('Original Label')
-    ax[1, 1].imshow(resized_labels[0], cmap='gray')
-    ax[1, 1].set_title('Resized Label')
-    plt.show()
-    
-
 def plot_resize(images, resized_images, labels, resized_labels):
     def prepare_image(img):
         if img.ndim == 2:

spacr/settings.py

@@ -124,33 +124,6 @@ def set_default_plot_data_from_db(settings):
     settings.setdefault('uninfected', False)
     return settings
 
-
-
-def set_default_settings_preprocess_img_data_v1(settings):
-
-    metadata_type = settings.setdefault('metadata_type', 'cellvoyager')
-    custom_regex = settings.setdefault('custom_regex', None)
-    nr = settings.setdefault('nr', 1)
-    plot = settings.setdefault('plot', True)
-    batch_size = settings.setdefault('batch_size', 50)
-    timelapse = settings.setdefault('timelapse', False)
-    lower_percentile = settings.setdefault('lower_percentile', 2)
-    randomize = settings.setdefault('randomize', True)
-    all_to_mip = settings.setdefault('all_to_mip', False)
-    pick_slice = settings.setdefault('pick_slice', False)
-    skip_mode = settings.setdefault('skip_mode', False)
-
-    cmap = settings.setdefault('cmap', 'inferno')
-    figuresize = settings.setdefault('figuresize', 10)
-    normalize = settings.setdefault('normalize', True)
-    save_dtype = settings.setdefault('save_dtype', 'uint16')
-    
-    test_mode = settings.setdefault('test_mode', False)
-    test_images = settings.setdefault('test_images', 10)
-    random_test = settings.setdefault('random_test', True)
-
-    return 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
-
 def set_default_settings_preprocess_img_data(settings):
 
     settings.setdefault('metadata_type', 'cellvoyager')
@@ -340,7 +313,9 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('pathogen_min_size',0)
     settings.setdefault('cytoplasm_min_size',0)
     settings.setdefault('merge_edge_pathogen_cells', True)
-
+    
+    settings.setdefault('distance_gaussian_sigma', 1)
+    
     if settings['test_mode']:
         settings['verbose'] = True
         settings['plot'] = True
@@ -1027,7 +1002,8 @@ expected_types = {
     "cell_diamiter":int,
     "nucleus_diamiter":int,
     "pathogen_diamiter":int,
-    "consolidate":bool
+    "consolidate":bool,
+    "distance_gaussian_sigma":int
 }
 
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv", "metadata_files", "score_data","count_data"],
@@ -1049,7 +1025,7 @@ categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset
              "Plot": ["split_axis_lims", "x_lim","log_x","log_y", "plot_control", "plot_nr", "examples_to_plot", "normalize_plots", "cmap", "figuresize", "plot_cluster_grids", "img_zoom", "row_limit", "color_by", "plot_images", "smooth_lines", "plot_points", "plot_outlines", "black_background", "plot_by_cluster", "heatmap_feature","grouping","min_max","cmap","save_figure"],
              "Timelapse": ["timelapse", "fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
              "Advanced": ["merge_edge_pathogen_cells", "test_images", "random_test", "test_nr", "test", "test_split", "normalize", "target_unique_count","threshold_multiplier", "threshold_method", "min_n","shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "background", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
-             "Beta": ["all_to_mip", "upscale", "upscale_factor", "consolidate"]
+             "Beta": ["all_to_mip", "upscale", "upscale_factor", "consolidate", "distance_gaussian_sigma"]
              }
 
 

spacr/timelapse.py

@@ -255,56 +255,6 @@ def _relabel_masks_based_on_tracks(masks, tracks, mode='btrack'):
 
     return relabeled_masks
 
-def _prepare_for_tracking_v1(mask_array):
-    """
-    Prepare the mask array for object tracking.
-
-    Args:
-        mask_array (ndarray): Array of binary masks representing objects.
-
-    Returns:
-        DataFrame: DataFrame containing information about each object in the mask array.
-            The DataFrame has the following columns:
-            - frame: The frame number.
-            - y: The y-coordinate of the object's centroid.
-            - x: The x-coordinate of the object's centroid.
-            - mass: The area of the object.
-            - original_label: The original label of the object.
-
-    """
-    frames = []
-    for t, frame in enumerate(mask_array):
-        props = regionprops(frame)
-        for obj in props:
-            # Include 'label' in the dictionary to capture the original label of the object
-            frames.append({
-                'frame': t, 
-                'y': obj.centroid[0], 
-                'x': obj.centroid[1], 
-                'mass': obj.area,
-                'original_label': obj.label  # Capture the original label
-            })
-    return pd.DataFrame(frames)
-
-def _prepare_for_tracking_v1(mask_array):
-    frames = []
-    for t, frame in enumerate(mask_array):
-        props = regionprops_table(
-            frame,
-            properties=('label', 'centroid-0', 'centroid-1', 'area',
-                        'bbox-0', 'bbox-1', 'bbox-2', 'bbox-3',
-                        'eccentricity')
-        )
-        df = pd.DataFrame(props)
-        df = df.rename(columns={
-            'centroid-0': 'y', 'centroid-1': 'x', 'area': 'mass',
-            'label': 'original_label'
-        })
-        df['frame'] = t
-        frames.append(df[['frame','y','x','mass','original_label',
-                          'bbox-0','bbox-1','bbox-2','bbox-3','eccentricity']])
-    return pd.concat(frames, ignore_index=True)
-
 def _prepare_for_tracking(mask_array):
     frames = []
     for t, frame in enumerate(mask_array):
@@ -522,46 +472,6 @@ def _facilitate_trackin_with_adaptive_removal(masks, search_range=None, max_atte
         f"Failed to track after {max_attempts} attempts; last search_range={search_range}"
     )
 
-def _facilitate_trackin_with_adaptive_removal_v1(masks, search_range=500, max_attempts=100, memory=3):
-    """
-    Facilitates object tracking with adaptive removal.
-
-    Args:
-        masks (numpy.ndarray): Array of binary masks representing objects in each frame.
-        search_range (int, optional): Maximum distance objects can move between frames. Defaults to 500.
-        max_attempts (int, optional): Maximum number of attempts to track objects. Defaults to 100.
-        memory (int, optional): Number of frames to remember when linking tracks. Defaults to 3.
-
-    Returns:
-        tuple: A tuple containing the updated masks, features, and tracks_df.
-            masks (numpy.ndarray): Updated array of binary masks.
-            features (pandas.DataFrame): DataFrame containing features for object tracking.
-            tracks_df (pandas.DataFrame): DataFrame containing the tracked object trajectories.
-
-    Raises:
-        Exception: If tracking fails after the maximum number of attempts.
-
-    """
-    attempts = 0
-    first_frame = masks[0]
-    starting_objects = np.unique(first_frame[first_frame != 0])
-    while attempts < max_attempts:
-        try:
-            masks = _remove_objects_from_first_frame(masks, 10)
-            first_frame = masks[0]
-            objects = np.unique(first_frame[first_frame != 0])
-            print(len(objects))
-            features = _prepare_for_tracking(masks)
-            tracks_df = tp.link(features, search_range=search_range, memory=memory)
-            print(f"Success with {len(objects)} objects, started with {len(starting_objects)} objects")
-            return masks, features, tracks_df
-        except Exception as e:  # Consider catching a more specific exception if possible
-            print(f"Retrying with fewer objects. Exception: {e}", flush=True)
-        finally:
-            attempts += 1
-    print(f"Failed to track objects after {max_attempts} attempts. Consider adjusting parameters.")
-    return None, None, None
-
 def _trackpy_track_cells(src, name, batch_filenames, object_type, masks, timelapse_displacement, timelapse_memory, timelapse_remove_transient, plot, save, mode, track_by_iou):
         """
         Track cells using the Trackpy library.

spacr/utils.py

@@ -4602,7 +4602,10 @@ def adjust_cell_masks(parasite_folder, cell_folder, nuclei_folder, overlap_thres
         raise ValueError("The number of files in the folders do not match.")
     
     # Match files by name
-    for file_name in parasite_files:
+    time_ls = []
+    files_to_process = len(parasite_files)
+    for files_processed, file_name in enumerate(parasite_files):
+        start = time.time()
         parasite_path = os.path.join(parasite_folder, file_name)
         cell_path = os.path.join(cell_folder, file_name)
         nuclei_path = os.path.join(nuclei_folder, file_name)
@@ -4621,6 +4624,12 @@ def adjust_cell_masks(parasite_folder, cell_folder, nuclei_folder, overlap_thres
     
         # Overwrite the original cell mask file with the merged result
         np.save(cell_path, merged_cell_mask)
+        
+        stop = time.time()
+        duration = (stop - start)
+        time_ls.append(duration)
+        files_processed += 1
+        print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type=f'adjust_cell_masks')
 
 def process_masks(mask_folder, image_folder, channel, batch_size=50, n_clusters=2, plot=False):
     
@@ -5210,54 +5219,6 @@ def rename_columns_in_db(db_path):
 
     con.commit()
     con.close()    
-
-def rename_columns_in_db_v1(db_path):
-    with sqlite3.connect(db_path) as conn:
-        cursor = conn.cursor()
-        
-        # Retrieve all table names in the database
-        cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
-        tables = [table[0] for table in cursor.fetchall()]
-
-        for table in tables:
-            # Retrieve column names for each table
-            cursor.execute(f"PRAGMA table_info({table});")
-            columns_info = cursor.fetchall()
-            column_names = [col[1] for col in columns_info]
-
-            # Check if columns 'rowID' or 'columnID' exist
-            columns_to_rename = {}
-            if 'row' in column_names:
-                columns_to_rename['row'] = 'rowID'
-            if 'col' in column_names:
-                columns_to_rename['col'] = 'columnID'
-            
-            # Rename columns if necessary
-            if columns_to_rename:
-                # Rename existing table to a temporary name
-                temp_table = f"{table}_old"
-                cursor.execute(f"ALTER TABLE `{table}` RENAME TO `{temp_table}`")
-
-                # Define new columns with updated names
-                column_definitions = ", ".join(
-                    [f"`{columns_to_rename.get(col[1], col[1])}` {col[2]}" for col in columns_info]
-                )
-                cursor.execute(f"CREATE TABLE `{table}` ({column_definitions})")
-                
-                # Copy data to the new table
-                old_columns = ", ".join([f"`{col}`" for col in column_names])
-                new_columns = ", ".join(
-                    [f"`{columns_to_rename.get(col, col)}`" for col in column_names]
-                )
-                cursor.execute(f"INSERT INTO `{table}` ({new_columns}) SELECT {old_columns} FROM `{temp_table}`")
-                try:
-                    cursor.execute(f"DROP TABLE `{temp_table}`")
-                except sqlite3.Error as e:
-                    print(f"Error while dropping temporary table '{temp_table}': {e}")
-
-    # After closing the 'with' block, run VACUUM outside of any transaction
-    with sqlite3.connect(db_path) as conn:
-        conn.execute("VACUUM;")
         
 def group_feature_class(df, feature_groups=['cell', 'cytoplasm', 'nucleus', 'pathogen'], name='compartment'):
 

{spacr-0.9.0.dist-info → spacr-0.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.9.0
+Version: 0.9.2
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -80,8 +80,8 @@ Requires-Dist: opencv-python ; extra == 'full'
 Provides-Extra: headless
 Requires-Dist: opencv-python-headless ; extra == 'headless'
 
-.. |Documentation Status| image:: https://readthedocs.org/projects/spacr/badge/?version=latest
-   :target: https://einarolafsson.github.io/spacr
+.. |Docs| image:: https://github.com/EinarOlafsson/spacr/actions/workflows/pages/pages-build-deployment/badge.svg
+   :target: https://einarolafsson.github.io/spacr/index.html
 .. |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
@@ -91,54 +91,103 @@ Requires-Dist: opencv-python-headless ; extra == 'headless'
 .. |repo size| image:: https://img.shields.io/github/repo-size/EinarOlafsson/spacr
    :target: https://github.com/EinarOlafsson/spacr/
 
-|Documentation Status| |PyPI version| |Python version| |Licence: GPL v3| |repo size|
+.. _docs: https://einarolafsson.github.io/spacr/index.html
+
+Badges
+------
+|Docs| |PyPI version| |Python version| |Licence: GPL v3| |repo size|
 
 SpaCr
 =====
 
-Spatial phenotype analysis of CRISPR-Cas9 screens (SpaCr). The spatial organization of organelles and proteins within cells constitutes a key level of functional regulation. In the context of infectious disease, the spatial relationships between host cell structures and intracellular pathogens are critical to understanding host clearance mechanisms and how pathogens evade them. SpaCr is a Python-based software package for generating single-cell image data for deep-learning sub-cellular/cellular phenotypic classification from pooled genetic CRISPR-Cas9 screens. SpaCr provides a flexible toolset to extract single-cell images and measurements from high-content cell painting experiments, train deep-learning models to classify cellular/subcellular phenotypes, simulate, and analyze pooled CRISPR-Cas9 imaging screens.
+**Spatial phenotype analysis of CRISPR-Cas9 screens (SpaCr).**
+
+The spatial organization of organelles and proteins within cells constitutes a key level of functional regulation. In the context of infectious disease, the spatial relationships between host cell structures and intracellular pathogens are critical to understanding host clearance mechanisms and how pathogens evade them. SpaCr is a Python-based software package for generating single-cell image data for deep-learning sub-cellular/cellular phenotypic classification from pooled genetic CRISPR-Cas9 screens. SpaCr provides a flexible toolset to extract single-cell images and measurements from high-content cell painting experiments, train deep-learning models to classify cellular/subcellular phenotypes, simulate, and analyze pooled CRISPR-Cas9 imaging screens.
 
 Features
 --------
 
 -  **Generate Masks:** Generate cellpose masks of cell, nuclei, and pathogen objects.
-
--  **Object Measurements:** Measurements for each object including scikit-image-regionprops, intensity percentiles, shannon-entropy, pearsons and manders correlations, homogeneity, and radial distribution. Measurements are saved to a SQL database in object-level tables.
-
+-  **Object Measurements:** Measurements for each object including scikit-image regionprops, intensity percentiles, shannon-entropy, Pearson’s and Manders’ correlations, homogeneity, and radial distribution. Measurements are saved to a SQL database in object-level tables.
 -  **Crop Images:** Save objects (cells, nuclei, pathogen, cytoplasm) as images. Object image paths are saved in a SQL database.
-
 -  **Train CNNs or Transformers:** Train Torch models to classify single object images.
-
 -  **Manual Annotation:** Supports manual annotation of single-cell images and segmentation to refine training datasets for training CNNs/Transformers or cellpose, respectively.
-
 -  **Finetune Cellpose Models:** Adjust pre-existing Cellpose models to your specific dataset for improved performance.
-
 -  **Timelapse Data Support:** Track objects in timelapse image data.
-
 -  **Simulations:** Simulate spatial phenotype screens.
-
 -  **Sequencing:** Map FASTQ reads to barcode and gRNA barcode metadata.
-
 -  **Misc:** Analyze Ca oscillation, recruitment, infection rate, plaque size/count.
 
+.. image:: https://github.com/EinarOlafsson/spacr/raw/main/spacr/resources/icons/flow_chart_v2.png
+   :alt: SpaCr workflow
+   :align: center
+
+
+**Overview and data organization of spaCR.**
+
+**a.** Schematic workflow of the spaCR pipeline for pooled image-based CRISPR screens. Microscopy images (TIFF, LIF, CZI, NDI) and sequencing reads (FASTQ) are used as inputs (black). The main modules (teal) are: (1) Mask: generates object masks for cells, nuclei, pathogens, and cytoplasm; (2) Measure: extracts object-level features and crops object images, storing quantitative data in an SQL database; (3) Classify—applies machine learning (ML, e.g., XGBoost) or deep learning (DL, e.g., PyTorch) models to classify objects, summarizing results as well-level classification scores; (4) Map Barcodes: extracts and maps row, column, and gRNA barcodes from sequencing data to corresponding wells; (5) Regression: estimates gRNA effect sizes and gene scores via multiple linear regression using well-level summary statistics.
+**b.** Downstream submodules available for extended analyses at each stage.
+**c.** Output folder structure for each module, including locations for raw and processed images, masks, object-level measurements, datasets, and results.
+**d.** List of all spaCR package modules.
+
 Installation
 ------------
 
+**Linux recommended.**  
 If using Windows, switch to Linux—it's free, open-source, and better.
 
-Before installing SpaCr on OSX ensure OpenMP is installed::
+**macOS prerequisites (before install):**
+
+::
 
    brew install libomp
    brew install hdf5
 
-SpaCr GUI requires Tkinter. On Linux, ensure Tkinter is installed. (Tkinter is included with the standard Python installation on macOS and Windows)::
+**Linux GUI requirement:**  
+SpaCr GUI requires Tkinter.  
+
+::
 
    sudo apt-get install python3-tk
 
-Install SpaCr with pip::
+**Installation:**
+
+::
 
    pip install spacr
 
-Run SpaCr GUI::
+**Run SpaCr GUI:**
+
+::
 
    spacr
+
+Data Availability
+-----------------
+
+- **Raw sequencing data** are available from NCBI BioProject `PRJNA1261935 <https://www.ncbi.nlm.nih.gov/bioproject/PRJNA1261935>`_ and SRA accessions: `SRR33531217 <https://www.ncbi.nlm.nih.gov/sra/SRR33531217>`_, `SRR33531218 <https://www.ncbi.nlm.nih.gov/sra/SRR33531218>`_, `SRR33531219 <https://www.ncbi.nlm.nih.gov/sra/SRR33531219>`_, `SRR33531220 <https://www.ncbi.nlm.nih.gov/sra/SRR33531220>`_
+
+- **Image data** is deposited at EBI BioStudies under accession: `S-BIAD2076 <https://www.ebi.ac.uk/biostudies/studies/S-BIAD2076>`_
+
+Example Notebooks
+-----------------
+
+The following example Jupyter notebooks illustrate common workflows using spaCR.
+
+- `1_spacr_generate_masks.ipynb <Notebooks/1_spacr_generate_masks.ipynb>`_  
+  *Generate cell, nuclei, and pathogen segmentation masks from microscopy images using Cellpose.*
+
+- `2_spacr_generate_mesurments_crop_images.ipynb <Notebooks/2_spacr_generate_mesurments_crop_images.ipynb>`_  
+  *Extract object-level measurements and crop single-cell images for downstream analysis.*
+
+- `3a_spacr_machine_learning.ipynb <Notebooks/3a_spacr_machine_learning.ipynb>`_  
+  *Train traditional machine learning models (e.g., XGBoost) to classify cell phenotypes based on extracted features.*
+
+- `3b_spacr_computer_vision.ipynb <Notebooks/3b_spacr_computer_vision.ipynb>`_  
+  *Train and evaluate deep learning models (PyTorch CNNs/Transformers) on cropped object images.*
+
+- `4_spacr_map_barecodes.ipynb <Notebooks/4_spacr_map_barecodes.ipynb>`_  
+  *Map sequencing reads to row, column, and gRNA barcodes for CRISPR screen genotype-phenotype mapping.*
+
+- `5_spacr_train_cellpose.ipynb <Notebooks/5_spacr_train_cellpose.ipynb>`_  
+  *Finetune Cellpose models using your own annotated training data for improved segmentation accuracy.*

{spacr-0.9.0.dist-info → spacr-0.9.2.dist-info}/RECORD

@@ -11,25 +11,25 @@ spacr/chat_bot.py,sha256=n3Fhqg3qofVXHmh3H9sUcmfYy9MmgRnr48663MVdY9E,1244
 spacr/core.py,sha256=w4E3Pg-ZnA8BOK0iUMTjiNO0GeR5YCEs8fUTbESzqjY,47392
 spacr/deep_spacr.py,sha256=055tIo3WP3elGFiIuSZaLURgu2XyUDxAdbw5ezASEqM,54526
 spacr/gui.py,sha256=NhMh96KoArrSAaJBV6PhDQpIC1cQpxgb6SclhRbYG8s,8122
-spacr/gui_core.py,sha256=jQPDQVP43YL_AW7Sm8cIQgdZVaB9Yig8U6ov9clCYOc,56180
+spacr/gui_core.py,sha256=m-AYUmaSXqsGFj9EzPf4fp1irZGN-X-21S4FBO8PoXc,52727
 spacr/gui_elements.py,sha256=5a3BOpctBPklsT1NungqS72h1Bg1FArUndE0OfvWD8Y,152646
 spacr/gui_utils.py,sha256=vv_uBOA0n-04KCCicYHhNt3sRbm0IPLM5r8QX5EkJ1Q,40867
 spacr/io.py,sha256=SYLhupKnOJJscNSGE4N67E32-ywhwrjRccIfZrL38Uk,157966
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
-spacr/measure.py,sha256=Z3u4BU5RzcY82IZuboQ0OsxuXaPVwOlH65Rw6FrL5z4,55045
+spacr/measure.py,sha256=XmOCKriS-kuRy-EPhQ_z7CRNg6DukyTpwQCiuSPNd_c,63414
 spacr/mediar.py,sha256=p0F515eFbm6_rePSnChsgqrgH-H5Sr_3zWrghtOnAUg,14863
 spacr/ml.py,sha256=XCRZeX7UkbMctQICIoskeWVx8CCmmCoHNauUOAkfFq0,91692
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
-spacr/plot.py,sha256=DGQulM2425DFVRMT9ZVvZW8EMxnc3hzjXhcL7fTMrGA,172668
+spacr/plot.py,sha256=M2w9ytR8iMFtsVPhmQ5tzIWTQDmbtCzs1-7hALUIQtg,167339
 spacr/sequencing.py,sha256=EY12RdW5QRKpHDRQCw1QoAlxCq8FK2v6WoVa5uuDBXQ,26745
-spacr/settings.py,sha256=LzJbebCRkDVYJxbojZKQE88MJ8Fg8iR6HZNHjN_np28,88687
+spacr/settings.py,sha256=tEFKYqMYQoObrNuKL3XdinRebQxJcuA3Gn9wK44vqhs,87505
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
 spacr/sp_stats.py,sha256=mbhwsyIqt5upsSD346qGjdCw7CFBa0tIS7zHU9e0jNI,9536
 spacr/spacr_cellpose.py,sha256=RBHMs2vwXcfkj0xqAULpALyzJYXddSRycgZSzmwI7v0,14755
 spacr/submodules.py,sha256=Z2i4kv_rWdxqoXsOKCF7BaSXtvaCZB69Ow8_FQBnZsY,83093
-spacr/timelapse.py,sha256=YJciEQS15eVC9R9adcen62xx7uttGAr_Gaz1vGX2Ke8,46824
+spacr/timelapse.py,sha256=-5ZupTsCCpbenIQ2zsUmnwXh45B82fO-gPrSXOxu2s8,42980
 spacr/toxo.py,sha256=GoNfgyH-NJx3WOzNQPgzODir7Jp65fs7UM46XpzcrUo,26056
-spacr/utils.py,sha256=ddeLh_KWA1bQsB9R3OtljFmsoWrriWjIJDq7x61J_XI,236185
+spacr/utils.py,sha256=cw5zM6zpFWWUZQKwtYvXc_rNfBMW2ldbnlw8s6f6bFQ,234397
 spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/resources/data/lopit.csv,sha256=ERI5f9W8RdJGiSx_khoaylD374f8kmvLia1xjhD_mII,4421709
 spacr/resources/data/toxoplasma_metadata.csv,sha256=9TXx0VlClDHAxQmaLhoklE8NuETduXaGHZjhR_6lZfs,2969409
@@ -82,6 +82,7 @@ spacr/resources/icons/convert.png,sha256=vLyTkQeUZ9q-pirhtZeXDq3-DzfjoPMjLlgKl5W
 spacr/resources/icons/default.png,sha256=KoNhaSHukO4wDyivyYEgSbb5mGj-sAxmhKikLLtNpWs,20341
 spacr/resources/icons/dna_matrix.mp4,sha256=NegOQkn4q4kHhFgqcIX2dd58wVytBtnkmbgg0ZegL8U,23462876
 spacr/resources/icons/download.png,sha256=1nUoWRaTc4vIsK6gompdeqk0cIv2GdH-gCNHaEBX6Mc,20467
+spacr/resources/icons/flow_chart_v2.png,sha256=4U4uzJlyQ8L-exWIXIhyqtkoO-KIiubO23kA7eLZYYE,640609
 spacr/resources/icons/logo.pdf,sha256=VB4cS41V3VV_QxD7l6CwdQKQiYLErugLBxWoCoxjQU0,377925
 spacr/resources/icons/logo_spacr.png,sha256=qG3e3bdrAefhl1281rfo0R2XP0qA-c-oaBCXjxMGXkw,42587
 spacr/resources/icons/logo_spacr_1.png,sha256=g9y2ZmnV3hab8r1idDfytm8AaHbBiQdu_93Jd7YKzwA,610892
@@ -101,9 +102,9 @@ spacr/resources/icons/umap.png,sha256=dOLF3DeLYy9k0nkUybiZMe1wzHQwLJFRmgccppw-8b
 spacr/resources/images/plate1_E01_T0001F001L01A01Z01C02.tif,sha256=Tl0ZUfZ_AYAbu0up_nO0tPRtF1BxXhWQ3T3pURBCCRo,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A02Z01C01.tif,sha256=m8N-V71rA1TT4dFlENNg8s0Q0YEXXs8slIn7yObmZJQ,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A03Z01C03.tif,sha256=Pbhk7xn-KUP6RSIhJsxQcrHFImBm3GEpLkzx7WOc-5M,7958528
-spacr-0.9.0.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.9.0.dist-info/METADATA,sha256=mk6s6xqwjy95ZgAc3fxWVNAoK_XsAceqHtB6e2PaRwE,6208
-spacr-0.9.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-spacr-0.9.0.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.9.0.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.9.0.dist-info/RECORD,,
+spacr-0.9.2.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.9.2.dist-info/METADATA,sha256=vfXoB5rq-qP1Yq4Hj4noXrPKrI-Fs1Q09RN_WTRkQLw,9336
+spacr-0.9.2.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+spacr-0.9.2.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.9.2.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.9.2.dist-info/RECORD,,