spacr 0.1.1__py3-none-any.whl → 0.1.7__py3-none-any.whl

spacr/measure.py

@@ -16,12 +16,6 @@ from skimage.util import img_as_bool
 
 from .logger import log_function_call
 
-#from .io import create_database, _save_settings_to_db
-#from .timelapse import _timelapse_masks_to_gif, _scmovie
-#from .plot import _plot_cropped_arrays, _save_scimg_plot
-#from .utils import _merge_overlapping_objects, _filter_object, _relabel_parent_with_child_labels, _exclude_objects
-#from .utils import _merge_and_save_to_database, _crop_center, _find_bounding_box, _generate_names, _get_percentiles, normalize_to_dtype, _map_wells_png, _list_endpoint_subdirectories, _generate_representative_images
-
 def get_components(cell_mask, nucleus_mask, pathogen_mask):
     """
     Get the components (nucleus and pathogens) for each cell in the given masks.
@@ -617,10 +611,23 @@ def _measure_crop_core(index, time_ls, file, settings):
     start = time.time() 
     try:
         source_folder = os.path.dirname(settings['input_folder'])
+        #if not os.path.basename(source_folder).endswith('merged'):
+        #    source_folder = os.path.join(source_folder, 'merged')
+        #    print(f'changed source_folder to {source_folder}')
+
+        #if not os.path.exists(source_folder):
+        #    return
+
         file_name = os.path.splitext(file)[0]
         data = np.load(os.path.join(settings['input_folder'], file))
-
         data_type = data.dtype
+        if data_type not in ['uint8','uint16']:
+            data_type_before = data_type
+            data = data.astype(np.uint16)
+            data_type = data.dtype
+            if settings['verbose']:
+                print(f'Converted data from {data_type_before} to {data_type}')
+
         if settings['save_measurements']:
             os.makedirs(source_folder+'/measurements', exist_ok=True)
             _create_database(source_folder+'/measurements/measurements.db')    
@@ -750,6 +757,15 @@ def _measure_crop_core(index, time_ls, file, settings):
             if isinstance(settings['crop_mode'], list):
                 crop_ls = settings['crop_mode']
                 size_ls = settings['png_size']
+                
+                if isinstance(size_ls[0], int):
+                    size_ls = [size_ls]
+                if len(crop_ls) > 1 and len(size_ls) == 1:
+                    size_ls = size_ls * len(crop_ls)
+                    
+                if len(crop_ls) != len(size_ls):
+                    print(f"Setting: size_ls: {settings['png_size']} should be a list of integers, or a list of lists of integers if crop_ls: {settings['crop_mode']} has multiple elements")
+                    
                 for crop_idx, crop_mode in enumerate(crop_ls):
                     width, height = size_ls[crop_idx]
                     if crop_mode == 'cell':
@@ -816,7 +832,6 @@ def _measure_crop_core(index, time_ls, file, settings):
                                     png_channels = normalize_to_dtype(png_channels, settings['normalize'][0], settings['normalize'][1], percentile_list=percentile_list)
                             else:
                                 png_channels = normalize_to_dtype(png_channels, 0, 100)
-
                             os.makedirs(png_folder, exist_ok=True)
 
                             if png_channels.shape[2] == 2:
@@ -926,9 +941,14 @@ def measure_crop(settings):
     settings = get_measure_crop_settings(settings)
     settings = measure_test_mode(settings)
 
-    if not os.path.exists(settings['input_folder']):
-        print(f"Error: {settings['input_folder']} does not exist")
-        return
+    #src_fldr = settings['input_folder']
+    #if not os.path.basename(src_fldr).endswith('merged'):
+    #    settings['input_folder'] = os.path.join(src_fldr, 'merged')
+    #    print(f"changed input_folder to {src_fldr}")
+
+    #if not os.path.exists(settings['input_folder']):
+    #    print(f'input_folder: {settings["input_folder"]} does not exist')
+    #    return
     
     if settings['cell_mask_dim'] is None:
         settings['include_uninfected'] = True
@@ -978,12 +998,12 @@ def measure_crop(settings):
     _save_settings_to_db(settings)
 
     files = [f for f in os.listdir(settings['input_folder']) if f.endswith('.npy')]
-    max_workers = settings['max_workers'] or mp.cpu_count()-4
-    print(f'using {max_workers} cpu cores')
+    n_job = settings['n_job'] or mp.cpu_count()-4
+    print(f'using {n_job} cpu cores')
 
     with mp.Manager() as manager:
         time_ls = manager.list()
-        with mp.Pool(max_workers) as pool:
+        with mp.Pool(n_job) as pool:
             result = pool.starmap_async(_measure_crop_core, [(index, time_ls, file, settings) for index, file in enumerate(files)])
 
             # Track progress in the main process
@@ -992,7 +1012,7 @@ def measure_crop(settings):
                 files_processed = len(time_ls)
                 files_to_process = len(files)
                 average_time = np.mean(time_ls) if len(time_ls) > 0 else 0
-                time_left = (((files_to_process-files_processed)*average_time)/max_workers)/60
+                time_left = (((files_to_process-files_processed)*average_time)/n_job)/60
                 print(f'Progress: {files_processed}/{files_to_process} Time/img {average_time:.3f}sec, Time Remaining {time_left:.3f} min.', end='\r', flush=True)
             result.get()
 

spacr/measure_app.py

@@ -0,0 +1,246 @@
+import sys, traceback, matplotlib, ctypes
+import tkinter as tk
+from tkinter import ttk, scrolledtext
+from matplotlib.figure import Figure
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+matplotlib.use('Agg')  # Use the non-GUI Agg backend
+from multiprocessing import Process, Queue, Value
+from tkinter import filedialog
+
+try:
+    ctypes.windll.shcore.SetProcessDpiAwareness(True)
+except AttributeError:
+    pass
+
+from .logger import log_function_call
+from .gui_utils import ScrollableFrame, StdoutRedirector, CustomButton, ToggleSwitch, ToolTip
+from .gui_utils import process_stdout_stderr, set_dark_style, set_default_font, generate_fields, main_thread_update_function, create_menu_bar
+from .gui_utils import measure_variables, measure_crop_wrapper, clear_canvas, check_measure_gui_settings, read_settings_from_csv, update_settings_from_csv, style_text_boxes
+
+thread_control = {"run_thread": None, "stop_requested": False}
+
+def import_settings(scrollable_frame):
+    global vars_dict
+
+    csv_file_path = filedialog.askopenfilename(filetypes=[("CSV files", "*.csv")])
+    csv_settings = read_settings_from_csv(csv_file_path)
+    variables = measure_variables()
+    new_settings = update_settings_from_csv(variables, csv_settings)
+    vars_dict = generate_fields(new_settings, scrollable_frame)
+
+def toggle_test_mode():
+    global vars_dict
+    current_state = vars_dict['test_mode'][2].get()
+    new_state = not current_state
+    vars_dict['test_mode'][2].set(new_state)
+    if new_state:
+        test_mode_button.config(bg="blue")
+    else:
+        test_mode_button.config(bg="gray")
+
+def toggle_advanced_settings():
+    global vars_dict
+
+    timelapse_settings = ['timelapse', 'timelapse_objects']
+    misc_settings = ['representative_images', 'plot', 'plot_filtration', 'include_uninfected', 'dialate_pngs', 'dialate_png_ratios']
+    opperational_settings = ['max_workers','experiment','cells','cell_loc','pathogens','pathogen_loc','treatments','treatment_loc','channel_of_interest','compartments','measurement','nr_imgs', 'um_per_pixel']
+    
+    advanced_settings = timelapse_settings+misc_settings+opperational_settings
+
+    # Toggle visibility of advanced settings
+    for setting in advanced_settings:
+        label, widget, var = vars_dict[setting]
+        if advanced_var.get() is False:
+            label.grid_remove()  # Hide the label
+            widget.grid_remove()  # Hide the widget
+        else:
+            label.grid()  # Show the label
+            widget.grid()  # Show the widget
+
+#@log_function_call
+def run_measure_gui(q, fig_queue, stop_requested):
+    global vars_dict
+    process_stdout_stderr(q)
+    try:
+        print('hello')
+        settings = check_measure_gui_settings(vars_dict)
+        measure_crop_wrapper(settings=settings, q=q, fig_queue=fig_queue)
+    except Exception as e:
+        q.put(f"Error during processing: {e}")
+        traceback.print_exc()
+    finally:
+        stop_requested.value = 1
+
+#@log_function_call
+def start_process(q, fig_queue):
+    global thread_control
+    if thread_control.get("run_thread") is not None:
+        initiate_abort()
+
+    stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
+    thread_control["stop_requested"] = stop_requested
+    thread_control["run_thread"] = Process(target=run_measure_gui, args=(q, fig_queue, stop_requested))
+    thread_control["run_thread"].start()
+
+#@log_function_call
+def initiate_abort():
+    global thread_control
+    if thread_control.get("stop_requested") is not None:
+        thread_control["stop_requested"].value = 1
+
+    if thread_control.get("run_thread") is not None:
+        thread_control["run_thread"].join(timeout=5)
+        if thread_control["run_thread"].is_alive():
+            thread_control["run_thread"].terminate()
+        thread_control["run_thread"] = None
+
+#@log_function_call
+def initiate_measure_root(parent_frame):
+    global vars_dict, q, canvas, fig_queue, canvas_widget, thread_control, variables, advanced_var, scrollable_frame
+    
+    style = ttk.Style(parent_frame)
+    set_dark_style(style)
+    style_text_boxes(style)
+    set_default_font(parent_frame, font_name="Helvetica", size=8)
+
+    parent_frame.configure(bg='black')
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
+
+    fig_queue = Queue()
+    
+    # Initialize after_tasks if not already done
+    if not hasattr(parent_frame, 'after_tasks'):
+        parent_frame.after_tasks = []
+
+    def _process_fig_queue():
+        global canvas
+        try:
+            while not fig_queue.empty():
+                clear_canvas(canvas)
+                fig = fig_queue.get_nowait()
+                for ax in fig.get_axes():
+                    ax.set_xticks([])  # Remove x-axis ticks
+                    ax.set_yticks([])  # Remove y-axis ticks
+                    ax.xaxis.set_visible(False)  # Hide the x-axis
+                    ax.yaxis.set_visible(False)  # Hide the y-axis
+                fig.tight_layout()
+                fig.set_facecolor('black')
+                canvas.figure = fig
+                fig_width, fig_height = canvas_widget.winfo_width(), canvas_widget.winfo_height()
+                fig.set_size_inches(fig_width / fig.dpi, fig_height / fig.dpi, forward=True)
+                canvas.draw_idle()
+        except Exception as e:
+            traceback.print_exc()
+        finally:
+            after_id = canvas_widget.after(100, _process_fig_queue)
+            parent_frame.after_tasks.append(after_id)
+
+    def _process_console_queue():
+        while not q.empty():
+            message = q.get_nowait()
+            console_output.insert(tk.END, message)
+            console_output.see(tk.END)
+        after_id = console_output.after(100, _process_console_queue)
+        parent_frame.after_tasks.append(after_id)
+
+    # Clear previous content if any
+    for widget in parent_frame.winfo_children():
+        widget.destroy()
+
+    vertical_container = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL)
+    vertical_container.grid(row=0, column=0, sticky=tk.NSEW)
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
+
+    # Settings Section
+    settings_frame = tk.Frame(vertical_container, bg='black')
+    vertical_container.add(settings_frame, stretch="always")
+    settings_label = ttk.Label(settings_frame, text="Settings", background="black", foreground="white")
+    settings_label.grid(row=0, column=0, pady=10, padx=10)
+    scrollable_frame = ScrollableFrame(settings_frame, width=500)
+    scrollable_frame.grid(row=1, column=0, sticky="nsew")
+    settings_frame.grid_rowconfigure(1, weight=1)
+    settings_frame.grid_columnconfigure(0, weight=1)
+    
+    # Create advanced settings checkbox
+    advanced_var = tk.BooleanVar(value=False)
+    advanced_Toggle = ToggleSwitch(scrollable_frame.scrollable_frame, text="Advanced Settings", variable=advanced_var, command=toggle_advanced_settings)
+    advanced_Toggle.grid(row=48, column=0, pady=10, padx=10)
+    variables = measure_variables()
+    vars_dict = generate_fields(variables, scrollable_frame)
+    toggle_advanced_settings()
+    vars_dict['Test mode'] = (None, None, tk.BooleanVar(value=False))
+    
+    # Button section
+    test_mode_button = CustomButton(scrollable_frame.scrollable_frame, text="Test Mode", command=toggle_test_mode)
+    test_mode_button.grid(row=47, column=1, pady=10, padx=10)
+    import_btn = CustomButton(scrollable_frame.scrollable_frame, text="Import", command=lambda: import_settings(scrollable_frame), font=('Helvetica', 10))
+    import_btn.grid(row=47, column=0, pady=20, padx=20)
+    run_button = CustomButton(scrollable_frame.scrollable_frame, text="Run", command=lambda: start_process(q, fig_queue), font=('Helvetica', 10))
+    run_button.grid(row=45, column=0, pady=20, padx=20)
+    abort_button = CustomButton(scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort, font=('Helvetica', 10))
+    abort_button.grid(row=45, column=1, pady=20, padx=20)
+    progress_label = ttk.Label(scrollable_frame.scrollable_frame, text="Processing: 0%", background="black", foreground="white") # Create progress field
+    progress_label.grid(row=50, column=0, columnspan=2, sticky="ew", pady=(5, 0), padx=10)
+
+    # Plot Canvas Section
+    plot_frame = tk.PanedWindow(vertical_container, orient=tk.VERTICAL)
+    vertical_container.add(plot_frame, stretch="always")
+    figure = Figure(figsize=(30, 4), dpi=100, facecolor='black')
+    plot = figure.add_subplot(111)
+    plot.plot([], [])
+    plot.axis('off')
+    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
+    canvas.get_tk_widget().configure(cursor='arrow', background='black', highlightthickness=0)
+    canvas_widget = canvas.get_tk_widget()
+    plot_frame.add(canvas_widget, stretch="always")
+    canvas.draw()
+    canvas.figure = figure
+
+    # Console Section
+    console_frame = tk.Frame(vertical_container, bg='black')
+    vertical_container.add(console_frame, stretch="always")
+    console_label = ttk.Label(console_frame, text="Console", background="black", foreground="white")
+    console_label.grid(row=0, column=0, pady=10, padx=10)
+    console_output = scrolledtext.ScrolledText(console_frame, height=10, bg='black', fg='white', insertbackground='white')
+    console_output.grid(row=1, column=0, sticky="nsew")
+    console_frame.grid_rowconfigure(1, weight=1)
+    console_frame.grid_columnconfigure(0, weight=1)
+
+    q = Queue()
+    sys.stdout = StdoutRedirector(console_output)
+    sys.stderr = StdoutRedirector(console_output)
+    
+    _process_console_queue()
+    _process_fig_queue()
+    
+    after_id = parent_frame.after(100, lambda: main_thread_update_function(parent_frame, q, fig_queue, canvas_widget, progress_label))
+    parent_frame.after_tasks.append(after_id)
+    
+    return parent_frame, vars_dict
+
+def gui_measure():
+    root = tk.Tk()
+    width = root.winfo_screenwidth()
+    height = root.winfo_screenheight()
+    root.geometry(f"{width}x{height}") 
+    root.title("SpaCr: measure objects")
+    
+    # Clear previous content if any
+    if hasattr(root, 'content_frame'):
+        for widget in root.content_frame.winfo_children():
+            widget.destroy()
+        root.content_frame.grid_forget()
+    else:
+        root.content_frame = tk.Frame(root)
+        root.content_frame.grid(row=1, column=0, sticky="nsew")
+        root.grid_rowconfigure(1, weight=1)
+        root.grid_columnconfigure(0, weight=1)
+    
+    initiate_measure_root(root.content_frame)
+    create_menu_bar(root)
+    root.mainloop()
+
+if __name__ == "__main__":
+    gui_measure()

spacr/plot.py

@@ -1565,4 +1565,56 @@ def plot_feature_importance(feature_importance_df):
     ax.set_xlabel('Feature Importance', fontsize=font_size)
     ax.tick_params(axis='both', which='major', labelsize=font_size)
     plt.tight_layout()
-    return fig
+    return fig
+
+def read_and_plot__vision_results(base_dir, y_axis='accuracy', name_split='_time', y_lim=[0.8, 0.9]):
+    # List to store data from all CSV files
+    data_frames = []
+
+    dst = os.path.join(base_dir, 'result')
+    os.mkdir(dst,exists=True)
+
+    # Walk through the directory
+    for root, dirs, files in os.walk(base_dir):
+        for file in files:
+            if file.endswith("_test_result.csv"):
+                file_path = os.path.join(root, file)
+                # Extract model information from the file name
+                file_name = os.path.basename(file_path)
+                model = file_name.split(f'{name_split}')[0]
+                
+                # Extract epoch information from the file name
+                epoch_info = file_name.split('_time')[1]
+                base_folder = os.path.dirname(file_path)
+                epoch = os.path.basename(base_folder)
+                
+                # Read the CSV file
+                df = pd.read_csv(file_path)
+                df['model'] = model
+                df['epoch'] = epoch
+                
+                # Append the data frame to the list
+                data_frames.append(df)
+    
+    # Concatenate all data frames
+    if data_frames:
+        result_df = pd.concat(data_frames, ignore_index=True)
+        
+        # Calculate average y_axis per model
+        avg_metric = result_df.groupby('model')[y_axis].mean().reset_index()
+        avg_metric = avg_metric.sort_values(by=y_axis)
+        print(avg_metric)
+        
+        # Plotting the results
+        plt.figure(figsize=(10, 6))
+        plt.bar(avg_metric['model'], avg_metric[y_axis])
+        plt.xlabel('Model')
+        plt.ylabel(f'{y_axis}')
+        plt.title(f'Average {y_axis.capitalize()} per Model')
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        if y_lim is not None:
+            plt.ylim(y_lim)
+        plt.show()
+    else:
+        print("No CSV files found in the specified directory.")

spacr/sequencing.py

@@ -37,22 +37,6 @@ def analyze_reads(settings):
         None
     """
     
-    def save_chunk_to_hdf5_v1(output_file_path, data_chunk, chunk_counter):
-        """
-        Save a data chunk to an HDF5 file.
-
-        Parameters:
-        - output_file_path (str): The path to the output HDF5 file.
-        - data_chunk (list): The data chunk to be saved.
-        - chunk_counter (int): The counter for the current chunk.
-
-        Returns:
-        None
-        """
-        df = pd.DataFrame(data_chunk, columns=['combined_read', 'grna', 'plate_row', 'column', 'sample'])
-        with pd.HDFStore(output_file_path, mode='a', complevel=5, complib='blosc') as store:
-            store.put(f'reads/chunk_{chunk_counter}', df, format='table', append=True)
-
     def save_chunk_to_hdf5(output_file_path, data_chunk, chunk_counter):
         """
         Save a data chunk to an HDF5 file.
@@ -306,7 +290,7 @@ def analyze_reads(settings):
                 qc_df = pd.DataFrame([qc])
                 qc_df.to_csv(qc_file_path, index=False)
                 
-    from .utils import get_analyze_reads_default_settings
+    from .settings import get_analyze_reads_default_settings
 
     settings = get_analyze_reads_default_settings(settings)