decimer-segmentation 1.3.0__tar.gz → 1.5.0__tar.gz

{decimer_segmentation-1.3.0 → decimer_segmentation-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: decimer_segmentation
-Version: 1.3.0
+Version: 1.5.0
 Summary: DECIMER Segmentation - Extraction of chemical structure depictions from scientific literature
 Home-page: https://github.com/Kohulan/DECIMER-Image-Segmentation
 Author: Kohulan Rajan
@@ -9,14 +9,12 @@ Maintainer: Kohulan Rajan
 Maintainer-email: kohulan.rajan@uni-jena.de
 License: MIT
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.5
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 

{decimer_segmentation-1.3.0 → decimer_segmentation-1.5.0}/decimer_segmentation/__init__.py

@@ -10,7 +10,7 @@ For comments, bug reports or feature requests,
 please raise an issue on our GitHub repository.
 """
 
-__version__ = "1.3.0"
+__version__ = "1.5.0"
 
 __all__ = [
     "decimer_segmentation",

{decimer_segmentation-1.3.0 → decimer_segmentation-1.5.0}/decimer_segmentation/complete_structure.py

@@ -4,7 +4,7 @@ import matplotlib.pyplot as plt
 import itertools
 from skimage.color import rgb2gray
 from skimage.filters import threshold_otsu
-from skimage.morphology import binary_erosion
+from skimage.morphology import binary_erosion, binary_dilation
 from typing import List, Tuple
 from scipy.ndimage import label
 
@@ -98,8 +98,7 @@ def detect_horizontal_and_vertical_lines(
 ) -> np.ndarray:
     """
     This function takes an image and returns a binary mask that labels the pixels that
-    are part of long horizontal or vertical lines. [Definition of long: 1/5 of the
-    width/height of the image].
+    are part of long horizontal or vertical lines.
 
     Args:
         image (np.ndarray): binarised image (np.array; type bool) as it is returned by
@@ -130,11 +129,84 @@ def detect_horizontal_and_vertical_lines(
     return horizontal_mask + vertical_mask
 
 
+def find_equidistant_points(
+    x1: int, y1: int, x2: int, y2: int, num_points: int = 5
+) -> List[Tuple[int, int]]:
+    """
+    Finds equidistant points between two points.
+
+    Args:
+        x1 (int): x coordinate of first point
+        y1 (int): y coordinate of first point
+        x2 (int): x coordinate of second point
+        y2 (int): y coordinate of second point
+        num_points (int, optional): Number of points to return. Defaults to 5.
+
+    Returns:
+        List[Tuple[int, int]]: Equidistant points on the given line
+    """
+    points = []
+    for i in range(num_points + 1):
+        t = i / num_points
+        x = x1 * (1 - t) + x2 * t
+        y = y1 * (1 - t) + y2 * t
+        points.append((x, y))
+    return points
+
+
+def detect_lines(
+    image: np.ndarray,
+    max_depiction_size: Tuple[int, int],
+    segmentation_mask: np.ndarray,
+) -> np.ndarray:
+    """
+    This function takes an image and returns a binary mask that labels the pixels that
+    are part of lines that are not part of chemical structures (like arrays, tables).
+
+    Args:
+        image (np.ndarray): binarised image (np.array; type bool) as it is returned by
+            binary_erosion() in complete_structure_mask()
+        max_depiction_size (Tuple[int, int]): height, width; used for thresholds
+        segmentation_mask (np.ndarray): Indicates whether or not a pixel is part of a
+            chemical structure depiction (shape: (height, width))
+    Returns:
+        np.ndarray: Exclusion mask that contains indices of pixels that are part of
+            horizontal or vertical lines
+    """
+    image = ~image * 255
+    image = image.astype("uint8")
+    # Detect lines using the Hough Transform
+    lines = cv2.HoughLinesP(
+        image,
+        1,
+        np.pi / 180,
+        threshold=5,
+        minLineLength=int(max(max_depiction_size) / 4),
+        maxLineGap=10,
+    )
+    # Generate exclusion mask based on detected lines
+    exclusion_mask = np.zeros_like(image)
+    if lines is None:
+        return exclusion_mask
+    for line in lines:
+        x1, y1, x2, y2 = line[0]
+        # Check if any of the lines is in a chemical structure depiction
+        points = find_equidistant_points(x1, y1, x2, y2, num_points=7)
+        points_in_structure = False
+        for x, y in points[1:-1]:
+            if segmentation_mask[int(y), int(x)]:
+                points_in_structure = True
+                break
+        if points_in_structure:
+            continue
+        cv2.line(exclusion_mask, (x1, y1), (x2, y2), 255, 2)
+    return exclusion_mask
+
+
 def expand_masks(
     image_array: np.array,
     seed_pixels: List[Tuple[int, int]],
     mask_array: np.array,
-    exclusion_mask: np.array,
 ) -> np.array:
     """
     This function generates a mask array where the given masks have been
@@ -144,20 +216,16 @@ def expand_masks(
         image_array (np.array): array that represents an image (float values)
         seed_pixels (List[Tuple[int, int]]): [(x, y), ...]
         mask_array (np.array): MRCNN output; shape: (y, x, mask_index)
-        exclusion_mask (np.array]: indicates whether or not a pixel is excluded from
-            expansion
-        contour_expansion (bool, optional): Indicates whether or not to expand
-                                            from contours. Defaults to False.
 
     Returns:
         np.array: Expanded masks
     """
-    image_with_exclusion = np.invert(image_array) * np.invert(exclusion_mask)
-    labeled_array, _ = label(image_with_exclusion)
+    image_array = np.invert(image_array)
+    labeled_array, _ = label(image_array)
     mask_array = np.zeros_like(image_array)
     for seed_pixel in seed_pixels:
         x, y = seed_pixel
-        if mask_array[y, x] or exclusion_mask[y, x]:
+        if mask_array[y, x]:
             continue
         label_value = labeled_array[y, x]
         if label_value > 0:
@@ -173,10 +241,8 @@ def expansion_coordination(
     the mask expansion. It returns the expanded mask. The purpose of this function is
     wrapping up the expansion procedure in a map function.
     """
-    seed_pixels = get_seeds(image_array,
-                            mask_array,
-                            exclusion_mask)
-    mask_array = expand_masks(image_array, seed_pixels, mask_array, exclusion_mask)
+    seed_pixels = get_seeds(image_array, mask_array, exclusion_mask)
+    mask_array = expand_masks(image_array, seed_pixels, mask_array)
     return mask_array
 
 
@@ -200,7 +266,8 @@ def complete_structure_mask(
         image_array (np.array): input image
         mask_array (np.array): shape: y, x, n where n is the amount of masks
         max_depiction_size (Tuple[int, int]): height, width
-        debug (bool, optional): More verbose if True. Defaults to False.
+        debug (bool, optional): You get visualisations in a Jupyter Notebook if True.
+            Defaults to False.
 
     Returns:
         np.array: expanded mask array
@@ -209,13 +276,12 @@ def complete_structure_mask(
     if mask_array.size != 0:
         # Binarization of input image
         binarized_image_array = binarize_image(image_array, threshold=0.72)
+        if debug:
+            plot_it(binarized_image_array)
         # Apply dilation with a resolution-dependent kernel to the image
         blur_factor = (
             int(image_array.shape[1] / 185) if image_array.shape[1] / 185 >= 2 else 2
         )
-        if debug:
-            plot_it(binarized_image_array)
-        # Define kernel and apply
         kernel = np.ones((blur_factor, blur_factor))
         blurred_image_array = binary_erosion(binarized_image_array, footprint=kernel)
         if debug:
@@ -224,22 +290,61 @@ def complete_structure_mask(
         split_mask_arrays = np.array(
             [mask_array[:, :, index] for index in range(mask_array.shape[2])]
         )
-        exclusion_mask = detect_horizontal_and_vertical_lines(
+        # Detect horizontal and vertical lines
+        horizontal_vertical_lines = detect_horizontal_and_vertical_lines(
             blurred_image_array, max_depiction_size
         )
-        # Run expansion the expansion
-        image_repeat = itertools.repeat(blurred_image_array, mask_array.shape[2])
-        exclusion_mask_repeat = itertools.repeat(exclusion_mask, mask_array.shape[2])
+
+        hough_lines = detect_lines(
+            binarized_image_array,
+            max_depiction_size,
+            segmentation_mask=np.any(mask_array, axis=2).astype(np.bool_),
+        )
+        hough_lines = binary_dilation(hough_lines, footprint=kernel)
+        exclusion_mask = horizontal_vertical_lines + hough_lines
+        image_with_exclusion = np.invert(
+            np.invert(blurred_image_array) * np.invert(exclusion_mask)
+        )
+        if debug:
+            plot_it(horizontal_vertical_lines)
+            plot_it(hough_lines)
+            plot_it(exclusion_mask)
+            plot_it(image_with_exclusion)
+        # Run expansion
+        image_repeat = itertools.repeat(image_with_exclusion, mask_array.shape[2])
+        exclusion_repeat = itertools.repeat(exclusion_mask, mask_array.shape[2])
         # Faster with map function
         expanded_split_mask_arrays = map(
             expansion_coordination,
             split_mask_arrays,
             image_repeat,
-            exclusion_mask_repeat,
+            exclusion_repeat,
         )
-        # Stack mask arrays to give the desired output format
+        # Filter duplicates and stack mask arrays to give the desired output format
+        expanded_split_mask_arrays = filter_duplicate_masks(expanded_split_mask_arrays)
         mask_array = np.stack(expanded_split_mask_arrays, -1)
         return mask_array
     else:
         print("No masks found.")
         return mask_array
+
+
+def filter_duplicate_masks(array_list: List[np.array]) -> List[np.array]:
+    """
+    This function takes a list of arrays and returns a list of unique arrays.
+
+    Args:
+        array_list (List[np.array]): Masks
+
+    Returns:
+        List[np.array]: Unique masks
+    """
+    seen = set()
+    unique_list = []
+    for arr in array_list:
+        # Convert the array to a hashable tuple
+        arr_tuple = tuple(arr.ravel())
+        if arr_tuple not in seen:
+            seen.add(arr_tuple)
+            unique_list.append(arr)
+    return unique_list