cellects 0.2.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

cellects/gui/image_analysis_window.py

@@ -109,7 +109,6 @@ class ImageAnalysisWindow(MainTabsType):
         self.available_bio_names = np.arange(1, 1000, dtype=np.uint16)
         self.available_back_names = np.arange(1, 1000, dtype=np.uint16)
         self.parent().po.current_combination_id = 0
-        greyscale = len(self.parent().po.first_im.shape) == 2
 
         self.display_image = np.zeros((self.parent().im_max_width, self.parent().im_max_width, 3), np.uint8)
         self.display_image = InsertImage(self.display_image, self.parent().im_max_height, self.parent().im_max_width)
@@ -447,7 +446,8 @@ class ImageAnalysisWindow(MainTabsType):
         self.thread["GetFirstIm"] = GetFirstImThread(self.parent())
         self.reinitialize_image_and_masks(self.parent().po.first_im)
         self.thread["GetLastIm"] = GetLastImThread(self.parent())
-        self.thread["GetLastIm"].start()
+        if self.parent().po.all['im_or_vid'] == 0:
+            self.thread["GetLastIm"].start()
         self.parent().po.first_image = OneImageAnalysis(self.parent().po.first_im)
         self.thread["FirstImageAnalysis"] = FirstImageAnalysisThread(self.parent())
         self.thread["LastImageAnalysis"] = LastImageAnalysisThread(self.parent())
@@ -541,7 +541,6 @@ class ImageAnalysisWindow(MainTabsType):
             self.thread["GetFirstIm"].start()
             self.thread["GetFirstIm"].message_when_thread_finished.connect(self.reinitialize_image_and_masks)
             self.reinitialize_bio_and_back_legend()
-            self.reinitialize_image_and_masks(self.parent().po.first_im)
 
 
     def several_blob_per_arena_check(self):
@@ -1019,6 +1018,7 @@ class ImageAnalysisWindow(MainTabsType):
             self.parent().po.visualize = False
             self.parent().po.basic = False
             self.parent().po.network_shaped = True
+            self.select_option.clear()
             if self.is_first_image_flag:
                 self.run_first_image_analysis()
             else:
@@ -1298,11 +1298,13 @@ class ImageAnalysisWindow(MainTabsType):
                     self.message.setText("Make sure that scaling metric and spot size are correct")
             else:
                 self.parent().po.vars['convert_for_motion'] = im_combinations[self.parent().po.current_combination_id]["csc"]
-                if "filter_spec" in im_combinations[self.parent().po.current_combination_id]:
-                    self.parent().po.vars['filter_spec'] = im_combinations[self.parent().po.current_combination_id]["filter_spec"]
-                    self.parent().po.vars['rolling_window_segmentation']['do'] = im_combinations[self.parent().po.current_combination_id]["rolling_window"]
-                    self.update_filter_display()
                 self.decision_label.setText("Do colored contours correctly match cell(s) contours?")
+            if "rolling_window" in im_combinations[self.parent().po.current_combination_id]:
+                self.parent().po.vars['rolling_window_segmentation']['do'] = im_combinations[self.parent().po.current_combination_id]["rolling_window"]
+            if "filter_spec" in im_combinations[self.parent().po.current_combination_id]:
+                self.parent().po.vars['filter_spec'] = im_combinations[self.parent().po.current_combination_id][
+                    "filter_spec"]
+                self.update_filter_display()
 
     def generate_csc_editing(self):
         """
@@ -1593,10 +1595,13 @@ class ImageAnalysisWindow(MainTabsType):
     def update_filter_display(self):
         self.filter1.setCurrentText(self.parent().po.vars['filter_spec']['filter1_type'])
         self.filter1_param1.setValue(self.parent().po.vars['filter_spec']['filter1_param'][0])
-        self.filter1_param2.setValue(self.parent().po.vars['filter_spec']['filter1_param'][1])
-        self.filter2.setCurrentText(self.parent().po.vars['filter_spec']['filter2_type'])
-        self.filter2_param1.setValue(self.parent().po.vars['filter_spec']['filter2_param'][0])
-        self.filter2_param2.setValue(self.parent().po.vars['filter_spec']['filter2_param'][1])
+        if len(self.parent().po.vars['filter_spec']['filter1_param']) > 1:
+            self.filter1_param2.setValue(self.parent().po.vars['filter_spec']['filter1_param'][1])
+        if 'filter2_type' in self.parent().po.vars['filter_spec']:
+            self.filter2.setCurrentText(self.parent().po.vars['filter_spec']['filter2_type'])
+            self.filter2_param1.setValue(self.parent().po.vars['filter_spec']['filter2_param'][0])
+            if len(self.parent().po.vars['filter_spec']['filter2_param']) > 1:
+                self.filter2_param2.setValue(self.parent().po.vars['filter_spec']['filter2_param'][1])
 
     def filter1_changed(self):
         """
@@ -1952,7 +1957,7 @@ class ImageAnalysisWindow(MainTabsType):
              (self.row21[1].value(), self.row21[2].value(), self.row21[3].value()),
              (self.row22[1].value(), self.row22[2].value(), self.row22[3].value()),
              (self.row23[1].value(), self.row23[2].value(), self.row23[3].value())),
-            dtype=np.int8)
+            dtype=np.float64)
         if self.logical_operator_between_combination_result.currentText() != 'None':
             spaces = np.concatenate((spaces, np.array((
                         self.row21[0].currentText() + "2", self.row22[0].currentText() + "2",
@@ -1960,7 +1965,7 @@ class ImageAnalysisWindow(MainTabsType):
             channels = np.concatenate((channels, np.array(((self.row21[1].value(), self.row21[2].value(), self.row21[3].value()),
              (self.row22[1].value(), self.row22[2].value(), self.row22[3].value()),
              (self.row23[1].value(), self.row23[2].value(), self.row23[3].value())),
-             dtype=np.int8)))
+             dtype=np.float64)))
             self.csc_dict['logical'] = self.logical_operator_between_combination_result.currentText()
         else:
             self.csc_dict['logical'] = 'None'
@@ -2057,29 +2062,37 @@ class ImageAnalysisWindow(MainTabsType):
             self.select_option.setVisible(False)
             self.select_option_label.setVisible(False)
 
-    def delineate_is_done(self, message: str):
+    def delineate_is_done(self, analysis_status: dict):
         """
         Update GUI after delineation is complete.
         """
-        logging.info("Delineation is done, update GUI")
-        self.message.setText(message)
-        self.arena_shape_label.setVisible(False)
-        self.arena_shape.setVisible(False)
-        self.reinitialize_bio_and_back_legend()
-        self.reinitialize_image_and_masks(self.parent().po.first_image.bgr)
-        self.delineation_done = True
-        if self.thread["UpdateImage"].isRunning():
-            self.thread["UpdateImage"].wait()
-        self.thread["UpdateImage"].start()
-        self.thread["UpdateImage"].message_when_thread_finished.connect(self.automatic_delineation_display_done)
+        if analysis_status['continue']:
+            logging.info("Delineation is done, update GUI")
+            self.message.setText(analysis_status["message"])
+            self.arena_shape_label.setVisible(False)
+            self.arena_shape.setVisible(False)
+            self.reinitialize_bio_and_back_legend()
+            self.reinitialize_image_and_masks(self.parent().po.first_image.bgr)
+            self.delineation_done = True
+            if self.thread["UpdateImage"].isRunning():
+                self.thread["UpdateImage"].wait()
+            self.thread["UpdateImage"].start()
+            self.thread["UpdateImage"].message_when_thread_finished.connect(self.automatic_delineation_display_done)
 
-        try:
-            self.thread['CropScaleSubtractDelineate'].message_from_thread.disconnect()
-            self.thread['CropScaleSubtractDelineate'].message_when_thread_finished.disconnect()
-        except RuntimeError:
-            pass
-        if not self.slower_delineation_flag:
-            self.asking_delineation_flag = True
+            try:
+                self.thread['CropScaleSubtractDelineate'].message_from_thread.disconnect()
+                self.thread['CropScaleSubtractDelineate'].message_when_thread_finished.disconnect()
+            except RuntimeError:
+                pass
+            if not self.slower_delineation_flag:
+                self.asking_delineation_flag = True
+        else:
+            self.delineation_done = False
+            self.asking_delineation_flag = False
+            self.auto_delineation_flag = False
+            self.asking_slower_or_manual_delineation_flag = False
+            self.slower_delineation_flag = False
+            self.manual_delineation()
 
     def automatic_delineation_display_done(self, boole):
         """
@@ -2093,7 +2106,6 @@ class ImageAnalysisWindow(MainTabsType):
         self.auto_delineation_flag = False
         self.select_option_label.setVisible(False)
         self.select_option.setVisible(False)
-
         self.arena_shape_label.setVisible(True)
         self.arena_shape.setVisible(True)
 
@@ -2337,8 +2349,6 @@ class ImageAnalysisWindow(MainTabsType):
         self.yes.setVisible(True)
         self.cell.setVisible(False)
         self.background.setVisible(False)
-        self.arena_shape_label.setVisible(False)
-        self.arena_shape.setVisible(False)
         self.no.setVisible(False)
         self.one_blob_per_arena.setVisible(False)
         self.one_blob_per_arena_label.setVisible(False)

cellects/gui/ui_strings.py

@@ -657,8 +657,9 @@ AP["Specimens_have_same_direction"]["label"] = "All specimens have the same dire
 AP["Specimens_have_same_direction"]["tips"] = \
 f"""Select to optimize arena detection for specimens moving move in the same direction.
 - **Checked** → Uses motion pattern analysis for arena localization.
-- **Unchecked** → Employs standard centroid
--based algorithm.
+- **Unchecked** → Employs standard centroid based algorithm.
+NB:
+- Both options work equally when growth is roughly isotropic.
 """
 # END_TIP
 

cellects/image_analysis/image_segmentation.py

@@ -46,7 +46,7 @@ filter_dict = {"": {'': {}},
                           'Param2': {'Name': 'Sigma max:', 'Minimum': 0., 'Maximum': 1000., 'Default': 10.}},
                "Hessian": {'Param1': {'Name': 'Sigma min:', 'Minimum': 0., 'Maximum': 1000., 'Default': 1.},
                           'Param2': {'Name': 'Sigma max:', 'Minimum': 0., 'Maximum': 1000., 'Default': 10.}},
-               "Laplace": {'Param1': {'Name': 'Ksize:', 'Minimum': 0., 'Maximum': 100., 'Default': 3}},
+               "Laplace": {'Param1': {'Name': 'Ksize:', 'Minimum': 3, 'Maximum': 100, 'Default': 5}},
                "Sharpen": {'': {}},
                "Mexican hat": {'': {}},
                "Farid": {'': {}},
@@ -142,7 +142,7 @@ def apply_filter(image: NDArray, filter_type: str, param, rescale_to_uint8=False
     elif filter_type == "Hessian":
         image = hessian(image, sigmas=np.linspace(param[0], param[1], num=3))
     elif filter_type == "Laplace":
-        image = laplace(image, ksize=int(param[0]))
+        image = laplace(image, ksize=np.max((3, int(np.ceil(param[0])))))
     elif filter_type == "Sharpen":
         image = cv2.filter2D(image, -1, np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]]))
     elif filter_type == "Mexican hat":
@@ -339,65 +339,6 @@ def generate_color_space_combination(bgr_image: NDArray[np.uint8], c_spaces: lis
     return greyscale_image, greyscale_image2, all_c_spaces, first_pc_vector
 
 
-@njit()
-def get_window_allowed_for_segmentation(im_shape: Tuple, mask:NDArray[np.uint8]=None, padding: int=0) -> Tuple[int, int, int, int]:
-    """
-    Get the allowed window for segmentation within an image.
-
-    This function calculates a bounding box (min_y, max_y, min_x, max_x) around
-    a segmentation mask or the entire image if no mask is provided.
-
-    Parameters
-    ----------
-    im_shape : Tuple[int, int]
-        The shape of the image (height, width).
-    mask : NDArray[np.uint8], optional
-        The binary mask for segmentation. Default is `None`.
-    padding : int, optional
-        Additional padding around the bounding box. Default is 0.
-
-    Returns
-    -------
-    Tuple[int, int, int, int]
-        A tuple containing the bounding box coordinates (min_y, max_y,
-        min_x, max_x).
-
-    Notes
-    -----
-    This function uses NumPy operations to determine the bounding box.
-    If `mask` is `None`, the full image dimensions are used.
-
-    Examples
-    --------
-    >>> im_shape = (500, 400)
-    >>> mask = np.zeros((500, 400), dtype=np.uint8)
-    >>> mask[200:300, 200:300] = 1
-    >>> result = get_window_allowed_for_segmentation(im_shape, mask, padding=10)
-    >>> print(result)
-    (190, 310, 190, 310)
-
-    >>> result = get_window_allowed_for_segmentation(im_shape)
-    >>> print(result)
-    (0, 500, 0, 400)
-    """
-    if mask is None or mask.sum() == 0:
-        min_y = 0
-        min_x = 0
-        max_y = im_shape[0]
-        max_x = im_shape[1]
-    else:
-        y, x = np.nonzero(mask)
-        min_y = np.min(y)
-        min_y = np.max((min_y - padding, 0))
-        min_x = np.min(x)
-        min_x = np.max((min_x - padding, 0))
-        max_y = np.max(y)
-        max_y = np.min((max_y + padding + 1, mask.shape[0]))
-        max_x = np.max(x)
-        max_x = np.min((max_x + padding + 1, mask.shape[0]))
-    return min_y, max_y, min_x, max_x
-
-
 @njit()
 def get_otsu_threshold(image: NDArray):
     """
@@ -479,11 +420,10 @@ def otsu_thresholding(image: NDArray) -> NDArray[np.uint8]:
     """
     threshold = get_otsu_threshold(image)
     binary_image = (image > threshold)
-    binary_image2 = np.logical_not(binary_image)
-    if binary_image.sum() < binary_image2.sum():
+    if binary_image.sum() < binary_image.size / 2:
         return binary_image.astype(np.uint8)
     else:
-        return binary_image2.astype(np.uint8)
+        return np.logical_not(binary_image).astype(np.uint8)
 
 
 def segment_with_lum_value(converted_video: NDArray, basic_bckgrnd_values: NDArray, l_threshold, lighter_background: bool) -> Tuple[NDArray, NDArray]:
@@ -554,7 +494,7 @@ def segment_with_lum_value(converted_video: NDArray, basic_bckgrnd_values: NDArr
 
 
 def kmeans(greyscale: NDArray, greyscale2: NDArray=None, kmeans_clust_nb: int=2,
-           biomask: NDArray[np.uint8]=None, backmask: NDArray[np.uint8]=None, logical: str='None',
+           bio_mask: NDArray[np.uint8]=None, back_mask: NDArray[np.uint8]=None, logical: str='None',
            bio_label=None, bio_label2=None, previous_binary_image: NDArray[np.uint8]=None):
     """
 
@@ -572,9 +512,9 @@ def kmeans(greyscale: NDArray, greyscale2: NDArray=None, kmeans_clust_nb: int=2,
         A second greyscale image for logical operations. Default is `None`.
     kmeans_clust_nb : int, optional
         Number of clusters for K-means. Default is `2`.
-    biomask : NDArray[np.uint8], optional
+    bio_mask : NDArray[np.uint8], optional
         Mask for selecting biological objects. Default is `None`.
-    backmask : NDArray[np.uint8], optional
+    back_mask : NDArray[np.uint8], optional
         Mask for selecting background regions. Default is `None`.
     logical : str, optional
         Logical operation flag to enable processing of the second image. Default is `'None'`.
@@ -605,6 +545,10 @@ def kmeans(greyscale: NDArray, greyscale2: NDArray=None, kmeans_clust_nb: int=2,
     - Default clustering uses 2 clusters, modify `kmeans_clust_nb` for different needs.
 
     """
+    if isinstance(bio_mask, np.ndarray):
+        bio_mask = np.nonzero(bio_mask)
+    if isinstance(back_mask, np.ndarray):
+        back_mask = np.nonzero(back_mask)
     new_bio_label = None
     new_bio_label2 = None
     binary_image2 = None
@@ -628,13 +572,13 @@ def kmeans(greyscale: NDArray, greyscale2: NDArray=None, kmeans_clust_nb: int=2,
         binary_image[kmeans_image == bio_label] = 1
         new_bio_label = bio_label
     else:
-        if biomask is not None:
-            all_labels = kmeans_image[biomask[0], biomask[1]]
+        if bio_mask is not None:
+            all_labels = kmeans_image[bio_mask[0], bio_mask[1]]
             for i in range(kmeans_clust_nb):
                 sum_per_label[i] = (all_labels == i).sum()
             new_bio_label = np.argsort(sum_per_label)[1]
-        elif backmask is not None:
-            all_labels = kmeans_image[backmask[0], backmask[1]]
+        elif back_mask is not None:
+            all_labels = kmeans_image[back_mask[0], back_mask[1]]
             for i in range(kmeans_clust_nb):
                 sum_per_label[i] = (all_labels == i).sum()
             new_bio_label = np.argsort(sum_per_label)[-2]
@@ -642,9 +586,9 @@ def kmeans(greyscale: NDArray, greyscale2: NDArray=None, kmeans_clust_nb: int=2,
             for i in range(kmeans_clust_nb):
                 sum_per_label[i] = (kmeans_image == i).sum()
             new_bio_label = np.argsort(sum_per_label)[-2]
-        binary_image[np.nonzero(np.isin(kmeans_image, new_bio_label))] = 1
+        binary_image += np.isin(kmeans_image, new_bio_label)
 
-    if logical != 'None' and greyscale is not None:
+    if logical != 'None' and greyscale2 is not None:
         image = greyscale2.reshape((-1, 1))
         image = np.float32(image)
         criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
@@ -666,13 +610,13 @@ def kmeans(greyscale: NDArray, greyscale2: NDArray=None, kmeans_clust_nb: int=2,
             binary_image2[kmeans_image == bio_label2] = 1
             new_bio_label2 = bio_label2
         else:
-            if biomask is not None:
-                all_labels = kmeans_image[biomask[0], biomask[1]]
+            if bio_mask is not None:
+                all_labels = kmeans_image[bio_mask[0], bio_mask[1]]
                 for i in range(kmeans_clust_nb):
                     sum_per_label[i] = (all_labels == i).sum()
                 new_bio_label2 = np.argsort(sum_per_label)[1]
-            elif backmask is not None:
-                all_labels = kmeans_image[backmask[0], backmask[1]]
+            elif back_mask is not None:
+                all_labels = kmeans_image[back_mask[0], back_mask[1]]
                 for i in range(kmeans_clust_nb):
                     sum_per_label[i] = (all_labels == i).sum()
                 new_bio_label2 = np.argsort(sum_per_label)[-2]

cellects/image_analysis/morphological_operations.py

@@ -646,9 +646,9 @@ def get_line_points(start, end) -> NDArray[int]:
     Parameters
     ----------
     start : tuple of int
-        The starting point coordinates (x0, y0).
+        The starting point coordinates (y0, x0).
     end : tuple of int
-        The ending point coordinates (x1, y1).
+        The ending point coordinates (y1, x1).
 
     Returns
     -------
@@ -1457,7 +1457,7 @@ def dynamically_expand_to_fill_holes(binary_video: NDArray[np.uint8], holes: NDA
 
 
 @njit()
-def create_ellipse(vsize_in, hsize_in):
+def create_ellipse(vsize: int, hsize: int, min_size: int=0) -> NDArray[np.uint8]:
     """
     Create a 2D array representing an ellipse with given vertical and horizontal sizes.
 
@@ -1467,9 +1467,9 @@ def create_ellipse(vsize_in, hsize_in):
 
     Parameters
     ----------
-    vsize_in : int
+    vsize : int
         Vertical size (number of rows) in the output 2D array.
-    hsize_in : int
+    hsize : int
         Horizontal size (number of columns) in the output 2D array.
 
     Returns
@@ -1477,14 +1477,10 @@ def create_ellipse(vsize_in, hsize_in):
     NDArray[bool]
         A boolean NumPy array of shape `(vsize, hsize)` where `True` indicates that a pixel lies within or on
         the boundary of an ellipse centered at the image's center with radii determined by half of the dimensions.
-
-    Notes
-    -----
-    If either vertical or horizontal size is zero, it defaults to 3 as in the original class behavior.
     """
     # Use default values if input sizes are zero
-    vsize = 3 if vsize_in == 0 else vsize_in
-    hsize = 3 if hsize_in == 0 else hsize_in
+    vsize = min_size if vsize == 0 else vsize
+    hsize = min_size if hsize == 0 else hsize
 
     # Compute radii (half of each size)
     vr = hsize // 2
@@ -1499,7 +1495,7 @@ def create_ellipse(vsize_in, hsize_in):
                 lhs = ((x - hr) ** 2 / (hr ** 2)) + ((y - vr) ** 2 / (vr ** 2))
                 result[i, j] = lhs <= 1
     else:
-        result[0, 0] = True
+        result[hr, vr] = True
     return result
 
 rhombus_55 = create_ellipse(5, 5).astype(np.uint8)
@@ -1690,7 +1686,7 @@ def get_bb_with_moving_centers(motion_list: list, all_specimens_have_same_direct
     k_size = 3
     if original_shape_hsize is not None:
         k_size = int((np.ceil(original_shape_hsize / 5) * 2) + 1)
-    big_kernel = create_ellipse(k_size, k_size).astype(np.uint8)
+    big_kernel = create_ellipse(k_size, k_size, min_size=3).astype(np.uint8)
 
     ordered_stats, ordered_centroids, ordered_image = rank_from_top_to_bottom_from_left_to_right(
         binary_image, y_boundaries, get_ordered_image=True)