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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: decimer_segmentation
-Version: 1.4.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.4.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.4.0 → decimer_segmentation-1.5.0}/decimer_segmentation/complete_structure.py

@@ -130,11 +130,7 @@ def detect_horizontal_and_vertical_lines(
 
 
 def find_equidistant_points(
-    x1: int,
-    y1: int,
-    x2: int,
-    y2: int,
-    num_points: int = 5
+    x1: int, y1: int, x2: int, y2: int, num_points: int = 5
 ) -> List[Tuple[int, int]]:
     """
     Finds equidistant points between two points.
@@ -161,7 +157,7 @@ def find_equidistant_points(
 def detect_lines(
     image: np.ndarray,
     max_depiction_size: Tuple[int, int],
-    segmentation_mask: np.ndarray
+    segmentation_mask: np.ndarray,
 ) -> np.ndarray:
     """
     This function takes an image and returns a binary mask that labels the pixels that
@@ -180,12 +176,14 @@ def detect_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)
+    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:
@@ -243,9 +241,7 @@ 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)
+    seed_pixels = get_seeds(image_array, mask_array, exclusion_mask)
     mask_array = expand_masks(image_array, seed_pixels, mask_array)
     return mask_array
 
@@ -302,7 +298,7 @@ def complete_structure_mask(
         hough_lines = detect_lines(
             binarized_image_array,
             max_depiction_size,
-            segmentation_mask=np.any(mask_array, axis=2).astype(np.bool)
+            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

{decimer_segmentation-1.4.0 → decimer_segmentation-1.5.0}/decimer_segmentation/decimer_segmentation.py

@@ -1,32 +1,32 @@
 """
- * This Software is under the MIT License
- * Refer to LICENSE or https://opensource.org/licenses/MIT for more information
- * Written by ©Kohulan Rajan 2020
+* This Software is under the MIT License
+* Refer to LICENSE or https://opensource.org/licenses/MIT for more information
+* Written by ©Kohulan Rajan 2020
+* Optimized for performance
 """
+
 import os
 import requests
 import cv2
 import argparse
-import warnings
 import numpy as np
-from copy import deepcopy
-from itertools import cycle
 from multiprocessing import Pool
-from pdf2image import convert_from_path
-from pdf2image.exceptions import PDFInfoNotInstalledError
-from typing import List, Tuple
+import pymupdf  # PyMuPDF
+from typing import List, Tuple, Union
 from PIL import Image
-from .complete_structure import complete_structure_mask
+from functools import lru_cache
+from concurrent.futures import ThreadPoolExecutor
+from .optimized_complete_structure import complete_structure_mask
 from .mrcnn import model as modellib
 from .mrcnn import visualize
 from .mrcnn import moldetect
 
-
-warnings.filterwarnings("ignore")
-
 # Root directory of the project
 ROOT_DIR = os.path.dirname(os.path.dirname(os.getcwd()))
 
+# Global model instance (lazy loading)
+_model = None
+
 
 class InferenceConfig(moldetect.MolDetectConfig):
     """
@@ -40,9 +40,7 @@ class InferenceConfig(moldetect.MolDetectConfig):
 
 
 def segment_chemical_structures_from_file(
-    file_path: str,
-    expand: bool = True,
-    poppler_path=None,
+    file_path: str, expand: bool = True
 ) -> List[np.array]:
     """
     This function runs the segmentation model as well as the mask expansion
@@ -52,28 +50,58 @@ def segment_chemical_structures_from_file(
     Args:
         file_path (str): image of a page from a scientific publication
         expand (bool): indicates whether or not to use mask expansion
-        poppler_path: Windows users need to specify the path of their
-                        Poppler installation
+        poppler_path: Deprecated parameter - no longer needed with PyMuPDF
 
     Returns:
         List[np.array]: expanded segments (shape: (h, w, num_masks))
     """
     if file_path[-3:].lower() == "pdf":
-        try:
-            images = convert_from_path(file_path, 300, poppler_path=poppler_path)
-        except PDFInfoNotInstalledError:
-            poppler_path = "C:\\Program Files (x86)\\poppler-0.68.0\\bin"
-            images = convert_from_path(file_path, 300, poppler_path=poppler_path)
-        images = [np.array(image) for image in images]
+        # Convert PDF to images using PyMuPDF with optimized settings
+        pdf_document = pymupdf.open(file_path)
+        images = []
+
+        # Pre-allocate list for known size
+        images = [None] * pdf_document.page_count
+
+        # Use thread pool for parallel page rendering
+        def render_page(page_num):
+            page = pdf_document[page_num]
+            # Render page to image with 300 DPI
+            matrix = pymupdf.Matrix(300 / 72, 300 / 72)
+            pix = page.get_pixmap(matrix=matrix, alpha=False)  # Skip alpha channel
+            # Direct conversion to numpy array
+            img_array = np.frombuffer(pix.samples, dtype=np.uint8).reshape(
+                pix.h, pix.w, pix.n
+            )
+            return page_num, img_array
+
+        # Use thread pool for I/O bound operations
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = [
+                executor.submit(render_page, i) for i in range(pdf_document.page_count)
+            ]
+            for future in futures:
+                page_num, img_array = future.result()
+                images[page_num] = img_array
+
+        pdf_document.close()
+
+        # Filter out any None values
+        images = [img for img in images if img is not None]
     else:
-        images = [cv2.imread(file_path)]
+        # Use faster image reading with proper flags
+        images = [cv2.imread(file_path, cv2.IMREAD_COLOR)]
+
     if len(images) > 1:
-        with Pool(4) as pool:
+        # Use optimized multiprocessing
+        with Pool(min(4, len(images))) as pool:
             starmap_args = [(im, expand) for im in images]
             segments = pool.starmap(segment_chemical_structures, starmap_args)
-            segments = [su for li in segments for su in li]
+            # More efficient flattening
+            segments = [seg for sublist in segments for seg in sublist]
     else:
-        segments = segment_chemical_structures(images[0])
+        segments = segment_chemical_structures(images[0], expand)
+
     return segments
 
 
@@ -81,7 +109,8 @@ def segment_chemical_structures(
     image: np.array,
     expand: bool = True,
     visualization: bool = False,
-) -> List[np.array]:
+    return_bboxes: bool = False,
+) -> Union[List[np.array], Tuple[List[np.array], List[Tuple[int, int, int, int]]]]:
     """
     This function runs the segmentation model as well as the mask expansion
     -> returns a List of segmented chemical structure depictions (np.array)
@@ -91,10 +120,13 @@ def segment_chemical_structures(
         expand (bool): indicates whether or not to use mask expansion
         visualization (bool): indicates whether or not to visualize the
                                 results (only works in Jupyter notebook)
+        return_bboxes (bool): indicates whether to return bounding boxes along with segments
 
     Returns:
-        List[np.array]: expanded segments sorted in top->bottom, left->right order with
-        a certain tolerance for grouping into "lines"(shape: (h, w, num_masks))
+        If return_bboxes is False:
+            List[np.array]: expanded segments sorted in top->bottom, left->right order
+        If return_bboxes is True:
+            Tuple[List[np.array], List[Tuple]]: segments and bounding boxes
     """
     if not expand:
         masks, bboxes, _ = get_mrcnn_results(image)
@@ -115,15 +147,19 @@ def segment_chemical_structures(
     if len(segments) > 0:
         segments, bboxes = sort_segments_bboxes(segments, bboxes)
 
-    segments = [segment for segment in segments
-                if segment.shape[0] > 0
-                if segment.shape[1] > 0]
+    # Vectorized filtering for valid segments
+    segments = [
+        segment for segment in segments if segment.shape[0] > 0 and segment.shape[1] > 0
+    ]
 
-    return segments
+    if return_bboxes:
+        return segments, bboxes
+    else:
+        return segments
 
 
 def determine_depiction_size_with_buffer(
-    bboxes: List[Tuple[int, int, int, int]]
+    bboxes: List[Tuple[int, int, int, int]],
 ) -> Tuple[int, int]:
     """
     This function takes a list of bounding boxes and returns 1.1 * the maximal
@@ -136,13 +172,11 @@ def determine_depiction_size_with_buffer(
     Returns:
         Tuple [int, int]: average depiction size (height, width)
     """
-    heights = []
-    widths = []
-    for bbox in bboxes:
-        height = bbox[2] - bbox[0]
-        width = bbox[3] - bbox[1]
-        heights.append(height)
-        widths.append(width)
+    # Vectorized computation for better performance
+    bboxes_array = np.array(bboxes)
+    heights = bboxes_array[:, 2] - bboxes_array[:, 0]
+    widths = bboxes_array[:, 3] - bboxes_array[:, 1]
+
     height = int(1.1 * np.max(heights))
     width = int(1.1 * np.max(widths))
     return height, width
@@ -152,7 +186,7 @@ def sort_segments_bboxes(
     segments: List[np.array],
     bboxes: List[Tuple[int, int, int, int]],  # (y0, x0, y1, x1)
     same_row_pixel_threshold=50,
-) -> Tuple[np.array, List[Tuple[int, int, int, int]]]:
+) -> Tuple[List[np.array], List[Tuple[int, int, int, int]]]:
     """
     Sorts segments and bounding boxes in "reading order"
 
@@ -165,36 +199,44 @@ def sort_segments_bboxes(
     Returns:
         segments and bboxes in reading order
     """
+    # Create index array for efficient sorting
+    indices = list(range(len(bboxes)))
 
-    # Sort by y-coordinate (top-to-bottom reading order)
-    sorted_bboxes = sorted(bboxes, key=lambda bbox: bbox[0])
+    # Sort indices by y-coordinate
+    indices.sort(key=lambda i: bboxes[i][0])
 
-    # Group bounding boxes by rows based on y-coordinate
+    # Group bounding boxes by rows
     rows = []
-    current_row = [sorted_bboxes[0]]
-    for bbox in sorted_bboxes[1:]:
-        if (
-            abs(bbox[0] - current_row[-1][0]) < same_row_pixel_threshold
-        ):  # You can adjust this threshold as needed
-            current_row.append(bbox)
+    current_row = [indices[0]]
+
+    for i in indices[1:]:
+        if abs(bboxes[i][0] - bboxes[current_row[-1]][0]) < same_row_pixel_threshold:
+            current_row.append(i)
         else:
-            rows.append(
-                sorted(current_row, key=lambda x: x[1])
-            )  # Sort by x-coordinate within each row
-            current_row = [bbox]
-    rows.append(sorted(current_row, key=lambda x: x[1]))  # Sort the last row
+            # Sort current row by x-coordinate
+            current_row.sort(key=lambda idx: bboxes[idx][1])
+            rows.append(current_row)
+            current_row = [i]
+
+    # Don't forget the last row
+    current_row.sort(key=lambda idx: bboxes[idx][1])
+    rows.append(current_row)
+
+    # Flatten the sorted indices
+    sorted_indices = [idx for row in rows for idx in row]
 
-    # Flatten the list of rows and return
-    sorted_bboxes = [bbox for row in rows for bbox in row]
+    # Apply sorting to segments and bboxes
+    sorted_segments = [segments[i] for i in sorted_indices]
+    sorted_bboxes = [bboxes[i] for i in sorted_indices]
 
-    sorted_segments = [segments[bboxes.index(bbox)] for bbox in sorted_bboxes]
     return sorted_segments, sorted_bboxes
 
 
+@lru_cache(maxsize=1)
 def load_model() -> modellib.MaskRCNN:
     """
     This function loads the segmentation model and returns it. The weights
-    are downloaded if necessary.
+    are downloaded if necessary. Cached to avoid reloading.
 
     Returns:
         modellib.MaskRCNN: MRCNN model with trained weights
@@ -202,14 +244,21 @@ def load_model() -> modellib.MaskRCNN:
     # Define directory with trained model weights
     root_dir = os.path.split(__file__)[0]
     model_path = os.path.join(root_dir, "mask_rcnn_molecule.h5")
+
     # Download trained weights if needed
     if not os.path.exists(model_path):
         print("Downloading model weights...")
-        url = "https://zenodo.org/record/10663579/files/mask_rcnn_molecule.h5?download=1"
-        req = requests.get(url, allow_redirects=True)
-        with open(model_path, "wb") as model_file:
-            model_file.write(req.content)
+        url = (
+            "https://zenodo.org/record/10663579/files/mask_rcnn_molecule.h5?download=1"
+        )
+        # Use streaming download for large files
+        with requests.get(url, stream=True) as req:
+            req.raise_for_status()
+            with open(model_path, "wb") as model_file:
+                for chunk in req.iter_content(chunk_size=8192):
+                    model_file.write(chunk)
         print("Successfully downloaded the segmentation model weights!")
+
     # Create model object in inference mode.
     model = modellib.MaskRCNN(mode="inference", model_dir=".", config=InferenceConfig())
     # Load weights
@@ -234,13 +283,11 @@ def get_expanded_masks(image: np.array) -> np.array:
     masks, bboxes, _ = get_mrcnn_results(image)
     if len(bboxes) == 0:
         return masks
+
     size = determine_depiction_size_with_buffer(bboxes)
     # Mask expansion
     expanded_masks = complete_structure_mask(
-        image_array=image,
-        mask_array=masks,
-        max_depiction_size=size,
-        debug=False
+        image_array=image, mask_array=masks, max_depiction_size=size, debug=False
     )
     return expanded_masks
 
@@ -263,6 +310,9 @@ def get_mrcnn_results(
         List[Tuple[int]]: bounding boxes [(y0, x0, y1, x1), ...]
         List[float]: confidence scores
     """
+    # Ensure model is loaded
+    model = get_model()
+
     results = model.detect([image], verbose=1)
     scores = results[0]["scores"]
     bboxes = results[0]["rois"]
@@ -270,11 +320,13 @@ def get_mrcnn_results(
     return masks, bboxes, scores
 
 
-def apply_masks(image: np.array, masks: np.array) -> List[np.array]:
+def apply_masks(
+    image: np.array, masks: np.array
+) -> Tuple[List[np.array], List[Tuple[int, int, int, int]]]:
     """
     This function takes an image and the masks for this image
     (shape: (h, w, num_structures)) and returns a list of segmented
-    chemical structure depictions (np.array)
+    chemical structure depictions (np.array) and their bounding boxes
 
     Args:
         image (np.array): image of a page from a scientific publication
@@ -282,19 +334,36 @@ def apply_masks(image: np.array, masks: np.array) -> List[np.array]:
 
     Returns:
         List[np.array]: segmented chemical structure depictions
+        List[Tuple[int, int, int, int]]: bounding boxes for each segment (y0, x0, y1, x1)
     """
-    masks = [masks[:, :, i] for i in range(masks.shape[2])]
-    if len(masks) == 0:
+    if masks.shape[2] == 0:
         return [], []
-    segmented_images_bboxes = map(apply_mask, cycle([image]), masks)
-    segmented_images, bboxes = list(zip(*list(segmented_images_bboxes)))
+
+    # Pre-allocate lists for better performance
+    num_masks = masks.shape[2]
+    segmented_images = [None] * num_masks
+    bboxes = [None] * num_masks
+
+    # Process masks in parallel for better performance
+    def process_mask(i):
+        mask = masks[:, :, i]
+        return apply_mask(image, mask)
+
+    # Use thread pool for I/O bound operations
+    with ThreadPoolExecutor(max_workers=min(4, num_masks)) as executor:
+        futures = [executor.submit(process_mask, i) for i in range(num_masks)]
+        for i, future in enumerate(futures):
+            segmented_images[i], bboxes[i] = future.result()
+
     return segmented_images, bboxes
 
 
-def apply_mask(image: np.array, mask: np.array) -> np.array:
+def apply_mask(
+    image: np.array, mask: np.array
+) -> Tuple[np.array, Tuple[int, int, int, int]]:
     """
     This function takes an image and a mask for this image (shape: (h, w))
-    and returns a segmented chemical structure depictions (np.array)
+    and returns a segmented chemical structure depiction (np.array)
 
     Args:
         image (np.array): image of a page from a scientific publication
@@ -304,52 +373,51 @@ def apply_mask(image: np.array, mask: np.array) -> np.array:
         np.array: segmented chemical structure depiction
         Tuple[int]: (y0, x0, y1, x1)
     """
-    # TODO: Further cleanup
-    im = deepcopy(image)
-    for channel in range(image.shape[2]):
-        im[:, :, channel] = im[:, :, channel] * mask
-    masked_image, bbox = get_masked_image(deepcopy(image), mask)
+    # Get masked image and bbox more efficiently
+    masked_image, bbox = get_masked_image_optimized(image, mask)
     x, y, w, h = bbox
+
+    # Convert to grayscale more efficiently
     im_gray = cv2.cvtColor(masked_image, cv2.COLOR_RGB2GRAY)
     _, im_bw = cv2.threshold(im_gray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
-    # Removal of transparent layer and generation of segment
+
+    # Create alpha channel
     _, alpha = cv2.threshold(im_bw, 0, 255, cv2.THRESH_BINARY)
-    b, g, r = cv2.split(image)
-    rgba = [b, g, r, alpha]
-    dst = cv2.merge(rgba, 4)
-    background = dst[y : y + h, x : x + w]
-    trans_mask = background[:, :, 3] == 0
-    background[trans_mask] = [255, 255, 255, 255]
-    return background, (y, x, y + h, x + w)
 
+    # Extract region of interest first to reduce processing
+    roi = image[y : y + h, x : x + w]
 
-def get_masked_image(image: np.array, mask: np.array) -> np.array:
-    """
-    This function takes an image and a masks for this image
-    (shape: (h, w)) and returns the masked image where only the
-    masked area is not completely white and a bounding box of the
-    segmented object
+    # Split channels and merge with alpha
+    b, g, r = cv2.split(roi)
+    rgba = cv2.merge([b, g, r, alpha[y : y + h, x : x + w]])
 
-    Args:
-        image (np.array): image of a page from a scientific publication
-        mask (np.array): masks (shape: (h, w, num_masks))
+    # Set transparent pixels to white
+    trans_mask = rgba[:, :, 3] == 0
+    rgba[trans_mask] = [255, 255, 255, 255]
 
-    Returns:
-        List[np.array]: segmented chemical structure depictions
-        List[int]: bounding box of segmented object
+    return rgba, (y, x, y + h, x + w)
+
+
+def get_masked_image_optimized(
+    image: np.array, mask: np.array
+) -> Tuple[np.array, Tuple[int, int, int, int]]:
+    """
+    Optimized version of get_masked_image using vectorized operations
     """
-    for channel in range(image.shape[2]):
-        image[:, :, channel] = image[:, :, channel] * mask[:, :]
-    # Remove unwanted background
-    grayscale = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    _, thresholded = cv2.threshold(grayscale, 0, 255, cv2.THRESH_OTSU)
-    bbox = cv2.boundingRect(thresholded)
+    # Find bounding box more efficiently
+    rows = np.any(mask, axis=1)
+    cols = np.any(mask, axis=0)
+    rmin, rmax = np.where(rows)[0][[0, -1]]
+    cmin, cmax = np.where(cols)[0][[0, -1]]
+    bbox = (cmin, rmin, cmax - cmin + 1, rmax - rmin + 1)
+
+    # Create output image
+    masked_image = np.zeros_like(image, dtype=np.uint8)
+    # Apply mask using vectorized operation
+    for c in range(3):
+        masked_image[:, :, c] = mask * 255
 
-    masked_image = np.zeros(image.shape).astype(np.uint8)
-    masked_image = visualize.apply_mask(masked_image, mask, [1, 1, 1])
-    masked_image = Image.fromarray(masked_image)
-    masked_image = masked_image.convert("RGB")
-    return np.array(masked_image), bbox
+    return masked_image, bbox
 
 
 def save_images(images: List[np.array], path: str, name: str) -> None:
@@ -363,17 +431,22 @@ def save_images(images: List[np.array], path: str, name: str) -> None:
         path (str): Output directory
         name (str): name for filename generation
     """
-    if not os.path.exists(path):
-        os.makedirs(path, exist_ok=True)
-    for index in range(len(images)):
+    os.makedirs(path, exist_ok=True)
+
+    # Use thread pool for parallel I/O operations
+    def save_single_image(args):
+        index, image = args
         filename = f"{name}_{index}.png"
         file_path = os.path.join(path, filename)
-        cv2.imwrite(file_path, images[index])
+        cv2.imwrite(file_path, image)
+
+    with ThreadPoolExecutor(max_workers=4) as executor:
+        executor.map(save_single_image, enumerate(images))
 
 
 def get_bnw_image(image: np.array) -> np.array:
     """
-    This function takes an image and returns
+    This function takes an image and returns a binarized version
 
     Args:
         image (np.array): input image
@@ -381,7 +454,12 @@ def get_bnw_image(image: np.array) -> np.array:
     Returns:
         np.array: binarized input image
     """
-    grayscale_im = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    # Check if already grayscale
+    if len(image.shape) == 2:
+        grayscale_im = image
+    else:
+        grayscale_im = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
     _, im_bw = cv2.threshold(
         grayscale_im, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU
     )
@@ -401,25 +479,47 @@ def get_square_image(image: np.array, desired_size: int) -> np.array:
     Returns:
         np.array: resized output image
     """
-    image = Image.fromarray(image)
-    old_size = image.size
-    grayscale_image = image.convert("L")
-    if old_size[0] or old_size[1] != desired_size:
-        ratio = float(desired_size) / max(old_size)
-        new_size = tuple([int(x * ratio) for x in old_size])
-        grayscale_image = grayscale_image.resize(new_size, Image.ANTIALIAS)
+    # Convert to grayscale if needed
+    if len(image.shape) == 3:
+        grayscale = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     else:
-        new_size = old_size
-    resized_image = Image.new("L", (desired_size, desired_size), "white")
+        grayscale = image
 
-    resized_image.paste(
-        grayscale_image,
-        ((desired_size - new_size[0]) // 2, (desired_size - new_size[1]) // 2),
-    )
-    return np.array(resized_image)
+    old_height, old_width = grayscale.shape
+
+    # Calculate new size
+    if old_height != desired_size or old_width != desired_size:
+        ratio = float(desired_size) / max(old_height, old_width)
+        new_width = int(old_width * ratio)
+        new_height = int(old_height * ratio)
+
+        # Resize using OpenCV (faster than PIL)
+        resized = cv2.resize(
+            grayscale, (new_width, new_height), interpolation=cv2.INTER_LANCZOS4
+        )
+    else:
+        new_width, new_height = old_width, old_height
+        resized = grayscale
+
+    # Create output image
+    output = np.full((desired_size, desired_size), 255, dtype=np.uint8)
+
+    # Calculate padding
+    y_offset = (desired_size - new_height) // 2
+    x_offset = (desired_size - new_width) // 2
+
+    # Place resized image in center
+    output[y_offset : y_offset + new_height, x_offset : x_offset + new_width] = resized
+
+    return output
 
 
-model = load_model()
+def get_model():
+    """Get or create the global model instance"""
+    global _model
+    if _model is None:
+        _model = load_model()
+    return _model
 
 
 def main():
@@ -434,12 +534,18 @@ def main():
         "--input", help="Enter the input filename (pdf or image)", required=True
     )
     args = parser.parse_args()
+
     # Define image path and output path
     input_path = os.path.normpath(args.input)
-    # Segment chemical structure depictions
+
+    # Pre-load model before segmentation
     print("Loading model...")
+    get_model()  # Pre-load the model
+
+    # Segment chemical structure depictions
     print("Segmenting structures...")
     segments = segment_chemical_structures_from_file(input_path)
+
     # Save segments
     segment_dir = os.path.join(f"{input_path}_output", "segments")
     save_images(segments, segment_dir, os.path.split(input_path)[1][:-4])

{decimer_segmentation-1.4.0 → decimer_segmentation-1.5.0}/decimer_segmentation/mrcnn/model.py

@@ -29,7 +29,7 @@ import tensorflow.keras.models as KM
 from . import utils
 from distutils.version import LooseVersion
 
-os.environ["CUDA_VISIBLE_DEVICES"] = "3"
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
 
 gpus = tf.config.experimental.list_physical_devices("GPU")
 for gpu in gpus:
@@ -871,7 +871,11 @@ def refine_detections_graph(rois, probs, deltas, window, config):
         return class_keep
 
     # 2. Map over class IDs
-    nms_keep = tf.map_fn(nms_keep_map, unique_pre_nms_class_ids, dtype=tf.int64)
+    nms_keep = tf.map_fn(
+        nms_keep_map,
+        unique_pre_nms_class_ids,
+        fn_output_signature=tf.TensorSpec(shape=None, dtype=tf.int64),
+    )
     # 3. Merge results into one list, and remove -1 padding
     nms_keep = tf.reshape(nms_keep, [-1])
     nms_keep = tf.gather(nms_keep, tf.compat.v1.where(nms_keep > -1)[:, 0])

decimer_segmentation-1.5.0/decimer_segmentation/optimized_complete_structure.py

@@ -0,0 +1,377 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import itertools
+from skimage.color import rgb2gray
+from skimage.filters import threshold_otsu
+from skimage.morphology import binary_erosion, binary_dilation
+from typing import List, Tuple
+from scipy.ndimage import label
+from numba import jit, prange
+import warnings
+
+# Suppress numba warnings for cleaner output
+warnings.filterwarnings("ignore", category=np.VisibleDeprecationWarning)
+
+
+def plot_it(image_array: np.array) -> None:
+    """
+    This function shows the plot of a given image (np.array)
+
+    Args:
+        image_array (np.array): Image
+    """
+    plt.rcParams["figure.figsize"] = (20, 15)
+    _, ax = plt.subplots(1)
+    ax.imshow(image_array)
+    plt.show()
+
+
+def binarize_image(image_array: np.array, threshold="otsu") -> np.array:
+    """
+    This function takes a np.array that represents an RGB image and returns
+    the binarized image (np.array) by applying the otsu threshold.
+
+    Args:
+        image_array (np.array): image
+        threshold (str, optional): "otsu" or a float. Defaults to "otsu".
+
+    Returns:
+        np.array: binarized image
+    """
+    grayscale = rgb2gray(image_array)
+    if threshold == "otsu":
+        threshold = threshold_otsu(grayscale)
+    return grayscale > threshold
+
+
+@jit(nopython=True, cache=True)
+def _get_seeds_fast(
+    mask_indices,
+    image_indices,
+    exclusion_indices,
+    x_min_limit,
+    x_max_limit,
+    y_min_limit,
+    y_max_limit,
+):
+    """
+    Fast numba-compiled function for seed pixel detection.
+    """
+    # Convert to sets for fast intersection
+    mask_set = set()
+    for i in range(len(mask_indices[0])):
+        mask_set.add((mask_indices[0][i], mask_indices[1][i]))
+
+    image_set = set()
+    for i in range(len(image_indices[0])):
+        image_set.add((image_indices[0][i], image_indices[1][i]))
+
+    exclusion_set = set()
+    for i in range(len(exclusion_indices[0])):
+        exclusion_set.add((exclusion_indices[0][i], exclusion_indices[1][i]))
+
+    # Find intersection and filter
+    seed_pixels = []
+    for coord in mask_set:
+        if coord in image_set:
+            y_coord, x_coord = coord
+            if (
+                x_coord >= x_min_limit
+                and x_coord <= x_max_limit
+                and y_coord >= y_min_limit
+                and y_coord <= y_max_limit
+                and coord not in exclusion_set
+            ):
+                seed_pixels.append((x_coord, y_coord))
+
+    return seed_pixels
+
+
+def get_seeds(
+    image_array: np.array,
+    mask_array: np.array,
+    exclusion_mask: np.array,
+) -> List[Tuple[int, int]]:
+    """
+    Optimized version of get_seeds function.
+    """
+    mask_indices = np.where(mask_array)
+    if len(mask_indices[0]) == 0:
+        return []
+
+    # Calculate boundaries once
+    mask_y_diff = mask_indices[0].max() - mask_indices[0].min()
+    mask_x_diff = mask_indices[1].max() - mask_indices[1].min()
+    x_min_limit = mask_indices[1].min() + mask_x_diff / 10
+    x_max_limit = mask_indices[1].max() - mask_x_diff / 10
+    y_min_limit = mask_indices[0].min() + mask_y_diff / 10
+    y_max_limit = mask_indices[0].max() - mask_y_diff / 10
+
+    image_indices = np.where(~image_array)
+    exclusion_indices = np.where(exclusion_mask)
+
+    return _get_seeds_fast(
+        mask_indices,
+        image_indices,
+        exclusion_indices,
+        x_min_limit,
+        x_max_limit,
+        y_min_limit,
+        y_max_limit,
+    )
+
+
+def detect_horizontal_and_vertical_lines(
+    image: np.ndarray, max_depiction_size: Tuple[int, int]
+) -> np.ndarray:
+    """
+    Optimized version with pre-allocated arrays and combined operations.
+    """
+    # Convert to uint8 once
+    binarised_im = (~image).astype(np.uint8) * 255
+    structure_height, structure_width = max_depiction_size
+
+    # Use optimized kernel creation and operations
+    horizontal_kernel = np.ones((1, structure_width), dtype=np.uint8)
+    vertical_kernel = np.ones((structure_height, 1), dtype=np.uint8)
+
+    # Perform morphological operations
+    horizontal_mask = (
+        cv2.morphologyEx(binarised_im, cv2.MORPH_OPEN, horizontal_kernel, iterations=2)
+        == 255
+    )
+
+    vertical_mask = (
+        cv2.morphologyEx(binarised_im, cv2.MORPH_OPEN, vertical_kernel, iterations=2)
+        == 255
+    )
+
+    return horizontal_mask | vertical_mask  # Use bitwise OR instead of addition
+
+
+@jit(nopython=True, cache=True)
+def _find_equidistant_points_fast(x1, y1, x2, y2, num_points):
+    """
+    Vectorized version of equidistant points calculation.
+    """
+    points = np.empty((num_points + 1, 2), dtype=np.float64)
+    for i in range(num_points + 1):
+        t = i / num_points
+        points[i, 0] = x1 * (1 - t) + x2 * t
+        points[i, 1] = y1 * (1 - t) + y2 * t
+    return points
+
+
+def find_equidistant_points(
+    x1: int, y1: int, x2: int, y2: int, num_points: int = 5
+) -> np.ndarray:
+    """
+    Optimized version using numba compilation.
+    """
+    return _find_equidistant_points_fast(x1, y1, x2, y2, num_points)
+
+
+def detect_lines(
+    image: np.ndarray,
+    max_depiction_size: Tuple[int, int],
+    segmentation_mask: np.ndarray,
+) -> np.ndarray:
+    """
+    Optimized line detection with vectorized operations.
+    """
+    # Convert to uint8 once
+    image_uint8 = (~image).astype(np.uint8) * 255
+
+    # Detect lines using the Hough Transform
+    lines = cv2.HoughLinesP(
+        image_uint8,
+        1,
+        np.pi / 180,
+        threshold=5,
+        minLineLength=int(max(max_depiction_size) / 4),
+        maxLineGap=10,
+    )
+
+    if lines is None:
+        return np.zeros_like(image_uint8, dtype=np.uint8)
+
+    # Pre-allocate exclusion mask
+    exclusion_mask = np.zeros_like(image_uint8, dtype=np.uint8)
+
+    # Vectorized line processing
+    for line in lines:
+        x1, y1, x2, y2 = line[0]
+        points = find_equidistant_points(x1, y1, x2, y2, num_points=7)
+
+        # Check if points are in structure (vectorized)
+        valid_points = points[1:-1]  # Exclude endpoints
+        coords = np.clip(
+            valid_points.astype(int),
+            0,
+            [segmentation_mask.shape[1] - 1, segmentation_mask.shape[0] - 1],
+        )
+
+        if not segmentation_mask[coords[:, 1], coords[:, 0]].any():
+            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,
+) -> np.array:
+    """
+    Optimized mask expansion with reduced memory allocations.
+    """
+    if not seed_pixels:
+        return np.zeros_like(image_array, dtype=bool)
+
+    inverted_image = ~image_array
+    labeled_array, _ = label(inverted_image)
+    result_mask = np.zeros_like(image_array, dtype=bool)
+
+    # Process all seed pixels in vectorized manner where possible
+    processed_labels = set()
+    for x, y in seed_pixels:
+        if result_mask[y, x]:
+            continue
+        label_value = labeled_array[y, x]
+        if label_value > 0 and label_value not in processed_labels:
+            result_mask[labeled_array == label_value] = True
+            processed_labels.add(label_value)
+
+    return result_mask
+
+
+def expansion_coordination(
+    mask_array: np.array, image_array: np.array, exclusion_mask: np.array
+) -> np.array:
+    """
+    Optimized coordination function.
+    """
+    seed_pixels = get_seeds(image_array, mask_array, exclusion_mask)
+    return expand_masks(image_array, seed_pixels, mask_array)
+
+
+def complete_structure_mask(
+    image_array: np.array,
+    mask_array: np.array,
+    max_depiction_size: Tuple[int, int],
+    debug=False,
+) -> np.array:
+    """
+    Heavily optimized version of complete_structure_mask.
+    """
+    if mask_array.size == 0:
+        print("No masks found.")
+        return mask_array
+
+    # Optimize binarization
+    binarized_image_array = binarize_image(image_array, threshold=0.72)
+    if debug:
+        plot_it(binarized_image_array)
+
+    # Calculate blur factor and kernel once
+    blur_factor = max(2, int(image_array.shape[1] / 185))
+    kernel = np.ones((blur_factor, blur_factor), dtype=np.uint8)
+
+    # Apply erosion
+    blurred_image_array = binary_erosion(binarized_image_array, footprint=kernel)
+    if debug:
+        plot_it(blurred_image_array)
+
+    # Optimized mask splitting - use moveaxis instead of list comprehension
+    split_mask_arrays = np.moveaxis(mask_array, 2, 0)
+
+    # Detect lines with optimized functions
+    horizontal_vertical_lines = detect_horizontal_and_vertical_lines(
+        blurred_image_array, max_depiction_size
+    )
+
+    # Create segmentation mask more efficiently
+    segmentation_mask = mask_array.any(axis=2)
+
+    hough_lines = detect_lines(
+        binarized_image_array,
+        max_depiction_size,
+        segmentation_mask=segmentation_mask,
+    )
+
+    # Combine masks efficiently
+    hough_lines_dilated = binary_dilation(hough_lines, footprint=kernel)
+    exclusion_mask = horizontal_vertical_lines | hough_lines_dilated
+
+    # Optimize image processing
+    image_with_exclusion = ~((~blurred_image_array) & (~exclusion_mask))
+
+    if debug:
+        plot_it(horizontal_vertical_lines)
+        plot_it(hough_lines_dilated)
+        plot_it(exclusion_mask)
+        plot_it(image_with_exclusion)
+
+    # Optimized expansion using list comprehension instead of map
+    expanded_masks = [
+        expansion_coordination(mask, image_with_exclusion, exclusion_mask)
+        for mask in split_mask_arrays
+    ]
+
+    # Optimized duplicate filtering
+    unique_masks = filter_duplicate_masks_fast(expanded_masks)
+
+    if not unique_masks:
+        return np.empty((image_array.shape[0], image_array.shape[1], 0), dtype=bool)
+
+    return np.stack(unique_masks, axis=-1)
+
+
+def filter_duplicate_masks_fast(array_list: List[np.array]) -> List[np.array]:
+    """
+    Highly optimized duplicate filtering using hash-based comparison.
+    """
+    if not array_list:
+        return []
+
+    seen_hashes = set()
+    unique_list = []
+
+    for arr in array_list:
+        # Use hash of array for faster comparison
+        if arr.size > 0:
+            # Use a more efficient hash method
+            arr_hash = hash(arr.tobytes())
+            if arr_hash not in seen_hashes:
+                seen_hashes.add(arr_hash)
+                unique_list.append(arr)
+        elif not seen_hashes:  # Handle empty arrays
+            seen_hashes.add(0)  # Placeholder for empty array
+            unique_list.append(arr)
+
+    return unique_list
+
+
+# Alternative filter method for very large arrays
+def filter_duplicate_masks_memory_efficient(
+    array_list: List[np.array],
+) -> List[np.array]:
+    """
+    Memory-efficient version for very large arrays.
+    """
+    if not array_list:
+        return []
+
+    unique_list = []
+
+    for i, arr1 in enumerate(array_list):
+        is_duplicate = False
+        for j in range(i):
+            if np.array_equal(arr1, array_list[j]):
+                is_duplicate = True
+                break
+        if not is_duplicate:
+            unique_list.append(arr1)
+
+    return unique_list

{decimer_segmentation-1.4.0 → decimer_segmentation-1.5.0}/decimer_segmentation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: decimer-segmentation
-Version: 1.4.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.4.0 → decimer_segmentation-1.5.0}/decimer_segmentation.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ setup.py
 decimer_segmentation/__init__.py
 decimer_segmentation/complete_structure.py
 decimer_segmentation/decimer_segmentation.py
+decimer_segmentation/optimized_complete_structure.py
 decimer_segmentation.egg-info/PKG-INFO
 decimer_segmentation.egg-info/SOURCES.txt
 decimer_segmentation.egg-info/dependency_links.txt

{decimer_segmentation-1.4.0 → decimer_segmentation-1.5.0}/decimer_segmentation.egg-info/requires.txt

@@ -1,9 +1,11 @@
-tensorflow==2.12.0
+tensorflow<=2.15.1,>=2.12.0
 numpy>=1.2.0
 scikit-image>=0.2.0
 pillow
 opencv-python
 matplotlib
 IPython
-pdf2image
+PyMuPDF
+numba
 scipy
+requests

{decimer_segmentation-1.4.0 → decimer_segmentation-1.5.0}/setup.py

@@ -6,16 +6,16 @@ import platform
 if (
     platform.processor() == "arm" or platform.processor() == "i386"
 ) and platform.system() == "Darwin":
-    tensorflow_os = "tensorflow-macos==2.10.0"
+    tensorflow_os = "tensorflow>=2.14.0,<=2.15.1"
 else:
-    tensorflow_os = "tensorflow==2.12.0"
+    tensorflow_os = "tensorflow>=2.12.0,<=2.15.1"
 
 with open("README.md", "r") as fh:
     long_description = fh.read()
 
 setuptools.setup(
     name="decimer_segmentation",
-    version="1.4.0",
+    version="1.5.0",
     author="Kohulan Rajan",
     author_email="kohulan.rajan@uni-jena.de",
     maintainer="Kohulan Rajan",
@@ -34,19 +34,19 @@ setuptools.setup(
         "opencv-python",
         "matplotlib",
         "IPython",
-        "pdf2image",
-        "scipy"
+        "PyMuPDF",
+        "numba",
+        "scipy",
+        "requests",
     ],
     package_data={"decimer_segmentation": ["mrcnn/*.*"]},
     classifiers=[
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.5",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3 :: Only",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
     ],
-    python_requires=">=3.5",
+    python_requires=">=3.10",
 )