celldetective 1.5.0b0__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

celldetective/napari/utils.py

@@ -27,6 +27,7 @@ from celldetective.utils.experiment import (
 )
 from celldetective.utils.parsing import config_section_to_dict
 from celldetective import get_logger
+from celldetective.gui.base.styles import Styles
 
 logger = get_logger()
 
@@ -87,10 +88,16 @@ def control_tracks(
         position += os.sep
 
     position = position.replace("\\", "/")
+    if progress_callback:
+        progress_callback(0)
+
     stack, labels = locate_stack_and_labels(
         position, prefix=prefix, population=population
     )
 
+    if progress_callback:
+        progress_callback(25)
+
     return view_tracks_in_napari(
         position,
         population,
@@ -130,7 +137,13 @@ def view_tracks_in_napari(
     Updated
     """
 
+    print(f"DEBUG: view_tracks_in_napari called with pos={position}, pop={population}")
     df, df_path = get_position_table(position, population=population, return_path=True)
+    print(f"DEBUG: get_position_table returned df={df is not None}")
+
+    if progress_callback:
+        progress_callback(50)
+
     if df is None:
         print("Please compute trajectories first... Abort...")
         return None
@@ -144,12 +157,18 @@ def view_tracks_in_napari(
 
     if (labels is not None) * relabel:
         print("Replacing the cell mask labels with the track ID...")
+
+        def wrapped_callback(p):
+            if progress_callback:
+                return progress_callback(50 + int(p * 0.5))
+            return True
+
         labels = relabel_segmentation(
             labels,
             df,
             exclude_nans=True,
             threads=threads,
-            progress_callback=progress_callback,
+            progress_callback=wrapped_callback,
         )
         if labels is None:
             return None
@@ -186,9 +205,12 @@ def launch_napari_viewer(
     shared_data,
     contrast_limits,
     flush_memory=True,
+    block=True,
+    progress_callback=None,
 ):
 
     viewer = napari.Viewer()
+
     if stack is not None:
         viewer.add_image(
             stack,
@@ -196,6 +218,7 @@ def launch_napari_viewer(
             colormap=["gray"] * stack.shape[-1],
             contrast_limits=contrast_limits,
         )
+
     if labels is not None:
         labels_layer = viewer.add_labels(
             labels.astype(int), name="segmentation", opacity=0.4
@@ -274,8 +297,6 @@ def launch_napari_viewer(
     def export_table_widget():
         return export_modifications()
 
-    from celldetective.gui.base.styles import Styles
-
     export_table_widget.native.setStyleSheet(Styles().button_style_sheet)
 
     def label_changed(event):
@@ -426,9 +447,9 @@ def launch_napari_viewer(
 
         shared_data["df"] = df
 
-    viewer.show(block=True)
+    viewer.show(block=block)
 
-    if flush_memory:
+    if flush_memory and block:
 
         # temporary fix for slight napari memory leak
         for i in range(10000):
@@ -781,8 +802,6 @@ def control_segmentation_napari(
     def export_widget():
         return export_annotation()
 
-    from celldetective.gui.base.styles import Styles
-
     stack, labels = locate_stack_and_labels(
         position, prefix=prefix, population=population
     )
@@ -889,22 +908,13 @@ def correct_annotation(filename):
         stack,
         channel_axis=-1,
         colormap=["gray"] * stack.shape[-1],
-        constrast_limits=contrast_limits,
+        contrast_limits=contrast_limits,
     )
     viewer.add_labels(labels, name="segmentation", opacity=0.4)
     viewer.window.add_dock_widget(save_widget, area="right")
-    viewer.show(block=True)
+    save_widget.native.setStyleSheet(Styles().button_style_sheet)
 
-    # temporary fix for slight napari memory leak
-    for i in range(100):
-        try:
-            viewer.layers.pop()
-        except:
-            pass
-    del viewer
-    del stack
-    del labels
-    gc.collect()
+    viewer.show(block=False)
 
 
 def _view_on_napari(tracks=None, stack=None, labels=None):

celldetective/processes/downloader.py

@@ -11,101 +11,127 @@ import time
 from pathlib import Path
 import json
 
+
 class DownloadProcess(Process):
 
-	def __init__(self, queue=None, process_args=None, *args, **kwargs):
-		
-		super().__init__(*args, **kwargs)
-		
-		if process_args is not None:
-			for key, value in process_args.items():
-				setattr(self, key, value)
-
-		self.queue = queue
-		self.progress = True
-
-		file_path = Path(os.path.dirname(os.path.realpath(__file__)))
-		zenodo_json = os.sep.join([str(file_path.parents[2]),"celldetective", "links", "zenodo.json"])
-		print(f"{zenodo_json=}")
-		
-		with open(zenodo_json,"r") as f:
-			zenodo_json = json.load(f)
-		all_files = list(zenodo_json['files']['entries'].keys())
-		all_files_short = [f.replace(".zip","") for f in all_files]
-		zenodo_url = zenodo_json['links']['files'].replace('api/','')
-		full_links = ["/".join([zenodo_url, f]) for f in all_files]
-		index = all_files_short.index(self.file)
-		
-		self.zip_url = full_links[index]
-		self.path_to_zip_file = os.sep.join([self.output_dir, 'temp.zip'])
-
-		self.sum_done = 0
-		self.t0 = time.time()
-
-	def download_url_to_file(self, url, dst):
-		try:
-			file_size = None
-			ssl._create_default_https_context = ssl._create_unverified_context
-			u = urlopen(url)
-			meta = u.info()
-			if hasattr(meta, 'getheaders'):
-				content_length = meta.getheaders("Content-Length")
-			else:
-				content_length = meta.get_all("Content-Length")
-			if content_length is not None and len(content_length) > 0:
-				file_size = int(content_length[0])
-			# We deliberately save it in a temp file and move it after
-			dst = os.path.expanduser(dst)
-			dst_dir = os.path.dirname(dst)
-			f = tempfile.NamedTemporaryFile(delete=False, dir=dst_dir)
-
-			try:
-				with tqdm(total=file_size, disable=not self.progress,
-						  unit='B', unit_scale=True, unit_divisor=1024) as pbar:
-					while True:
-						buffer = u.read(8192) #8192
-						if len(buffer) == 0:
-							break
-						f.write(buffer)
-						pbar.update(len(buffer))
-						self.sum_done+=len(buffer) / file_size * 100
-						mean_exec_per_step = (time.time() - self.t0) / (self.sum_done*file_size / 100 + 1)
-						pred_time = (file_size - (self.sum_done*file_size / 100 + 1)) * mean_exec_per_step
-						self.queue.put([self.sum_done, pred_time])
-				f.close()
-				shutil.move(f.name, dst)
-			finally:
-				f.close()
-				if os.path.exists(f.name):
-					os.remove(f.name)
-		except Exception as e:
-			print("No internet connection: ", e)
-			return None
-
-	def run(self):
-		
-		self.download_url_to_file(fr"{self.zip_url}",self.path_to_zip_file)
-		with zipfile.ZipFile(self.path_to_zip_file, 'r') as zip_ref:
-			zip_ref.extractall(self.output_dir)
-		
-		file_to_rename = glob(os.sep.join([self.output_dir,self.file,"*[!.json][!.png][!.h5][!.csv][!.npy][!.tif][!.ini]"]))
-		if len(file_to_rename)>0 and not file_to_rename[0].endswith(os.sep) and not self.file.startswith('demo'):
-			os.rename(file_to_rename[0], os.sep.join([self.output_dir,self.file,self.file]))
-
-		os.remove(self.path_to_zip_file)
-		self.queue.put([100,0])
-		time.sleep(0.5)
-
-		# Send end signal
-		self.queue.put("finished")
-		self.queue.close()
-
-	def end_process(self):
-
-		self.terminate()
-		self.queue.put("finished")
-
-	def abort_process(self):
-		
-		self.terminate()
-		self.queue.put("error")
+    def __init__(self, queue=None, process_args=None, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+
+        if process_args is not None:
+            for key, value in process_args.items():
+                setattr(self, key, value)
+
+        self.queue = queue
+        self.progress = True
+
+        # Get celldetective package root
+        current_dir = os.path.dirname(os.path.realpath(__file__))
+        package_root = os.path.dirname(current_dir)
+        zenodo_json = os.path.join(package_root, "links", "zenodo.json")
+        # print(f"{zenodo_json=}")
+
+        with open(zenodo_json, "r") as f:
+            zenodo_json = json.load(f)
+        all_files = list(zenodo_json["files"]["entries"].keys())
+        all_files_short = [f.replace(".zip", "") for f in all_files]
+        zenodo_url = zenodo_json["links"]["files"].replace("api/", "")
+        full_links = ["/".join([zenodo_url, f]) for f in all_files]
+        index = all_files_short.index(self.file)
+
+        self.zip_url = full_links[index]
+        self.path_to_zip_file = os.sep.join([self.output_dir, "temp.zip"])
+
+        self.sum_done = 0
+        self.t0 = time.time()
+
+    def download_url_to_file(self, url, dst):
+        try:
+            file_size = None
+            ssl._create_default_https_context = ssl._create_unverified_context
+            u = urlopen(url)
+            meta = u.info()
+            if hasattr(meta, "getheaders"):
+                content_length = meta.getheaders("Content-Length")
+            else:
+                content_length = meta.get_all("Content-Length")
+            if content_length is not None and len(content_length) > 0:
+                file_size = int(content_length[0])
+            # We deliberately save it in a temp file and move it after
+            dst = os.path.expanduser(dst)
+            dst_dir = os.path.dirname(dst)
+            f = tempfile.NamedTemporaryFile(delete=False, dir=dst_dir)
+
+            try:
+                with tqdm(
+                    total=file_size,
+                    disable=not self.progress,
+                    unit="B",
+                    unit_scale=True,
+                    unit_divisor=1024,
+                ) as pbar:
+                    while True:
+                        buffer = u.read(8192)  # 8192
+                        if len(buffer) == 0:
+                            break
+                        f.write(buffer)
+                        pbar.update(len(buffer))
+                        self.sum_done += len(buffer) / file_size * 100
+                        mean_exec_per_step = (time.time() - self.t0) / (
+                            self.sum_done * file_size / 100 + 1
+                        )
+                        pred_time = (
+                            file_size - (self.sum_done * file_size / 100 + 1)
+                        ) * mean_exec_per_step
+                        self.queue.put([self.sum_done, pred_time])
+                f.close()
+                shutil.move(f.name, dst)
+            finally:
+                f.close()
+                if os.path.exists(f.name):
+                    os.remove(f.name)
+        except Exception as e:
+            print("No internet connection: ", e)
+            return None
+
+    def run(self):
+
+        self.download_url_to_file(rf"{self.zip_url}", self.path_to_zip_file)
+        with zipfile.ZipFile(self.path_to_zip_file, "r") as zip_ref:
+            zip_ref.extractall(self.output_dir)
+
+        file_to_rename = glob(
+            os.sep.join(
+                [
+                    self.output_dir,
+                    self.file,
+                    "*[!.json][!.png][!.h5][!.csv][!.npy][!.tif][!.ini]",
+                ]
+            )
+        )
+        if (
+            len(file_to_rename) > 0
+            and not file_to_rename[0].endswith(os.sep)
+            and not self.file.startswith("demo")
+        ):
+            os.rename(
+                file_to_rename[0], os.sep.join([self.output_dir, self.file, self.file])
+            )
+
+        os.remove(self.path_to_zip_file)
+        self.queue.put([100, 0])
+        time.sleep(0.5)
+
+        # Send end signal
+        self.queue.put("finished")
+        self.queue.close()
+
+    def end_process(self):
+
+        self.terminate()
+        self.queue.put("finished")
+
+    def abort_process(self):
+
+        self.terminate()
+        self.queue.put("error")

celldetective/processes/load_table.py

@@ -0,0 +1,55 @@
+import time
+from multiprocessing import Process
+from celldetective.utils.data_loaders import load_experiment_tables
+from celldetective import get_logger
+
+logger = get_logger()
+
+
+class TableLoaderProcess(Process):
+
+    def __init__(self, queue=None, process_args=None, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+
+        if process_args is not None:
+            for key, value in process_args.items():
+                setattr(self, key, value)
+
+        self.queue = queue
+
+    def run(self):
+
+        def progress(well_progress, pos_progress):
+            # Check for cancellation if needed?
+            # The runner checks queue for instructions? No, runner closes queue.
+            # But here we can just push updates.
+            self.queue.put(
+                {
+                    "well_progress": well_progress,
+                    "pos_progress": pos_progress,
+                    "status": f"Loading tables... Well {well_progress}%, Position {pos_progress}%",
+                }
+            )
+            return True  # continue
+
+        try:
+            self.queue.put({"status": "Started loading..."})
+
+            df = load_experiment_tables(
+                experiment=self.experiment,
+                population=self.population,
+                well_option=self.well_option,
+                position_option=self.position_option,
+                return_pos_info=False,
+                progress_callback=progress,
+            )
+
+            self.queue.put({"status": "finished", "result": df})
+
+        except Exception as e:
+            logger.error(f"Table loading failed: {e}")
+            self.queue.put({"status": "error", "message": str(e)})
+
+    def end_process(self):
+        self.terminate()

celldetective/processes/measure_cells.py

@@ -310,6 +310,9 @@ class MeasurementProcess(Process):
 
         for t in tqdm(indices, desc="frame"):
 
+            measurements_at_t = None
+            perform_measurement = True
+
             if self.file is not None:
                 img = load_frames(
                     self.img_num_channels[:, t],
@@ -321,92 +324,115 @@ class MeasurementProcess(Process):
             if self.label_path is not None:
                 lbl = locate_labels(self.pos, population=self.mode, frames=t)
                 if lbl is None:
-                    continue
-
-            if self.trajectories is not None:
-                # Optimized access
-                if self.frame_slices is not None:
-                    # Check if frame t is in our precomputed slices
-                    if t in self.frame_slices:
-                        start, end = self.frame_slices[t]
-                        positions_at_t = self.trajectories.iloc[start:end].copy()
+                    perform_measurement = False
+
+            if perform_measurement:
+
+                if self.trajectories is not None:
+                    # Optimized access
+                    if self.frame_slices is not None:
+                        # Check if frame t is in our precomputed slices
+                        if t in self.frame_slices:
+                            start, end = self.frame_slices[t]
+                            positions_at_t = self.trajectories.iloc[start:end].copy()
+                        else:
+                            # Empty frame for trajectories
+                            positions_at_t = pd.DataFrame(
+                                columns=self.trajectories.columns
+                            )
                     else:
-                        # Empty frame for trajectories
-                        positions_at_t = pd.DataFrame(columns=self.trajectories.columns)
-                else:
-                    # Fallback or original method (should not be reached if optimized)
-                    positions_at_t = self.trajectories.loc[
-                        self.trajectories[self.column_labels["time"]] == t
-                    ].copy()
-
-            if self.do_features:
-                feature_table = measure_features(
-                    img,
-                    lbl,
-                    features=self.features,
-                    border_dist=self.border_distances,
-                    channels=self.channel_names,
-                    haralick_options=self.haralick_options,
-                    verbose=False,
-                    normalisation_list=self.background_correction,
-                    spot_detection=self.spot_detection,
-                )
-                if self.trajectories is None:
-                    positions_at_t = _extract_coordinates_from_features(
-                        feature_table, timepoint=t
+                        # Fallback or original method (should not be reached if optimized)
+                        positions_at_t = self.trajectories.loc[
+                            self.trajectories[self.column_labels["time"]] == t
+                        ].copy()
+
+                if self.do_features:
+                    feature_table = measure_features(
+                        img,
+                        lbl,
+                        features=self.features,
+                        border_dist=self.border_distances,
+                        channels=self.channel_names,
+                        haralick_options=self.haralick_options,
+                        verbose=False,
+                        normalisation_list=self.background_correction,
+                        spot_detection=self.spot_detection,
+                    )
+                    if self.trajectories is None:
+                        positions_at_t = _extract_coordinates_from_features(
+                            feature_table, timepoint=t
+                        )
+                        column_labels = {
+                            "track": "ID",
+                            "time": self.column_labels["time"],
+                            "x": self.column_labels["x"],
+                            "y": self.column_labels["y"],
+                        }
+                    feature_table.rename(
+                        columns={
+                            "centroid-1": "POSITION_X",
+                            "centroid-0": "POSITION_Y",
+                        },
+                        inplace=True,
                     )
-                    column_labels = {
-                        "track": "ID",
-                        "time": self.column_labels["time"],
-                        "x": self.column_labels["x"],
-                        "y": self.column_labels["y"],
-                    }
-                feature_table.rename(
-                    columns={"centroid-1": "POSITION_X", "centroid-0": "POSITION_Y"},
-                    inplace=True,
-                )
 
-            if self.do_iso_intensities and not self.trajectories is None:
-                iso_table = measure_isotropic_intensity(
-                    positions_at_t,
-                    img,
-                    channels=self.channel_names,
-                    intensity_measurement_radii=self.intensity_measurement_radii,
-                    column_labels=self.column_labels,
-                    operations=self.isotropic_operations,
-                    verbose=False,
-                )
+                if self.do_iso_intensities and not self.trajectories is None:
+                    iso_table = measure_isotropic_intensity(
+                        positions_at_t,
+                        img,
+                        channels=self.channel_names,
+                        intensity_measurement_radii=self.intensity_measurement_radii,
+                        column_labels=self.column_labels,
+                        operations=self.isotropic_operations,
+                        verbose=False,
+                    )
 
-            if (
-                self.do_iso_intensities
-                and self.do_features
-                and not self.trajectories is None
-            ):
-                measurements_at_t = iso_table.merge(
-                    feature_table, how="outer", on="class_id", suffixes=("_delme", "")
-                )
-                measurements_at_t = measurements_at_t[
-                    [c for c in measurements_at_t.columns if not c.endswith("_delme")]
-                ]
-            elif (
-                self.do_iso_intensities
-                * (not self.do_features)
-                * (not self.trajectories is None)
-            ):
-                measurements_at_t = iso_table
-            elif self.do_features:
-                measurements_at_t = positions_at_t.merge(
-                    feature_table, how="outer", on="class_id", suffixes=("_delme", "")
+                if (
+                    self.do_iso_intensities
+                    and self.do_features
+                    and not self.trajectories is None
+                ):
+                    measurements_at_t = iso_table.merge(
+                        feature_table,
+                        how="outer",
+                        on="class_id",
+                        suffixes=("_delme", ""),
+                    )
+                    measurements_at_t = measurements_at_t[
+                        [
+                            c
+                            for c in measurements_at_t.columns
+                            if not c.endswith("_delme")
+                        ]
+                    ]
+                elif (
+                    self.do_iso_intensities
+                    * (not self.do_features)
+                    * (not self.trajectories is None)
+                ):
+                    measurements_at_t = iso_table
+                elif self.do_features:
+                    measurements_at_t = positions_at_t.merge(
+                        feature_table,
+                        how="outer",
+                        on="class_id",
+                        suffixes=("_delme", ""),
+                    )
+                    measurements_at_t = measurements_at_t[
+                        [
+                            c
+                            for c in measurements_at_t.columns
+                            if not c.endswith("_delme")
+                        ]
+                    ]
+
+                measurements_at_t = center_of_mass_to_abs_coordinates(measurements_at_t)
+
+                measurements_at_t = measure_radial_distance_to_center(
+                    measurements_at_t,
+                    volume=img.shape,
+                    column_labels=self.column_labels,
                 )
-                measurements_at_t = measurements_at_t[
-                    [c for c in measurements_at_t.columns if not c.endswith("_delme")]
-                ]
-
-            measurements_at_t = center_of_mass_to_abs_coordinates(measurements_at_t)
-
-            measurements_at_t = measure_radial_distance_to_center(
-                measurements_at_t, volume=img.shape, column_labels=self.column_labels
-            )
 
             self.sum_done += 1
             data = {}