dsa-helpers 1.1.5.dev9__tar.gz → 1.1.6.dev0__tar.gz

{dsa_helpers-1.1.5.dev9/dsa_helpers.egg-info → dsa_helpers-1.1.6.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dsa_helpers
-Version: 1.1.5.dev9
+Version: 1.1.6.dev0
 Summary: Utility functions for working with the DSA girder client.
 Author-email: "Juan C. Vizcarra" <jvizcar@emory.edu>
 Maintainer-email: "Juan C. Vizcarra" <jvizcar@emory.edu>

{dsa_helpers-1.1.5.dev9 → dsa_helpers-1.1.6.dev0}/dsa_helpers/__init__.py

@@ -3,7 +3,7 @@ from .imread import imread
 from .imwrite import imwrite
 
 # Version of the dsa-helpers package
-__version__ = "1.1.5.dev9"
+__version__ = "1.1.6.dev0"
 
 # To avoid slow downs, do not allow from dsa_helpers import * to import anything.
 __all__ = []

{dsa_helpers-1.1.5.dev9 → dsa_helpers-1.1.6.dev0}/dsa_helpers/girder_utils.py

@@ -9,8 +9,10 @@ Functions:
 - get_element_contours: Get the contours of an element, regardless of the type
 - get_roi_images: Get regions of interest (ROIs) as images from DSA annotations
 - post_annotation: Post a new annotation to the DSA
+- post_annotations_from_gdf: Post annotations from a GeoDataFrame
 - remove_overlapping_annotations: Remove overlapping regions from elements
 - upload_dir_to_dsa: Upload a local directory to a DSA item
+
 """
 
 from girder_client import GirderClient, HttpError
@@ -21,7 +23,7 @@ from pathlib import Path
 import cv2 as cv
 from copy import deepcopy
 import geopandas as gpd
-from shapely.geometry import Polygon, box
+from shapely.geometry import Polygon, box, LineString
 from .gpd_utils import remove_gdf_overlaps
 
 
@@ -515,8 +517,6 @@ def post_annotations_from_gdf(
     doc_name: str,
     gdf: gpd.GeoDataFrame,
     idx_config: dict,
-    tolerance: float = 0.5,
-    max_points: int = 1000,
 ) -> dict:
     """Post annotations from a GeoDataFrame to the DSA.
 
@@ -528,10 +528,6 @@ def post_annotations_from_gdf(
         idx_config (dict): For each label in the GeoDataFrame, the configuration
             for the DSA annotation. Include "label", "fillColor", "lineColor", and
             "group".
-        tolerance (float, optional): The tolerance to simplify the polygons.
-            Defaults to 0.5.
-        max_points (int, optional): If polygon has more than max_points,
-            simplify the polygon. Defaults to 1000.
 
     Returns:
         dict: The response from the DSA.
@@ -539,51 +535,44 @@ def post_annotations_from_gdf(
     """
     elements = []
 
+    # This step makes sure that each row contains a single polygon.
+    # Multi-polygons will be exploded into multiple rows.
+    gdf = gdf.explode(index_parts=False).reset_index(drop=True)
+
     # Process the dataframe.
-    for _, row in gdf.iterrows():
-        # Flatten multipolygon to list of polygons.
-        list_of_polygons = list(
-            row["geometry"].geoms
-        )  # assuming multipolygons
-        label = row["label"]
-
-        for poly in list_of_polygons:
-            exterior_poly = list(poly.exterior.coords)
-            interior_polys = [
-                list(interior.coords) for interior in poly.interiors
-            ]
+    for _, r in gdf.iterrows():
+        label = r["label"]
+        poly = r["geometry"]
 
-            if len(exterior_poly) > max_points:
-                poly = poly.simplify(tolerance, preserve_topology=True)
-                exterior_poly = list(poly.exterior.coords)
+        exterior_poly = list(poly.exterior.coords)
+        interior_polys = [list(interior.coords) for interior in poly.interiors]
 
-            points = [
-                [int(xy[0]) * 2, int(xy[1]) * 2, 0] for xy in exterior_poly
-            ]
+        points = [[int(xy[0]), int(xy[1]), 0] for xy in exterior_poly]
 
-            holes = []
+        if len(points) == 0:
+            continue
 
-            for interior_poly in interior_polys:
-                hole = [
-                    [int(xy[0]) * 2, int(xy[1]) * 2, 0] for xy in interior_poly
-                ]
-                holes.append(hole)
+        holes = []
 
-            element = {
-                "points": points,
-                "fillColor": idx_config[label]["fillColor"],
-                "lineColor": idx_config[label]["lineColor"],
-                "type": "polyline",
-                "lineWidth": 2,
-                "closed": True,
-                "label": {"value": idx_config[label]["label"]},
-                "group": idx_config[label]["group"],
-            }
+        for interior_poly in interior_polys:
+            hole = [[int(xy[0]), int(xy[1]), 0] for xy in interior_poly]
+            holes.append(hole)
 
-            if len(holes):
-                element["holes"] = holes
+        element = {
+            "points": points,
+            "fillColor": idx_config[label]["fillColor"],
+            "lineColor": idx_config[label]["lineColor"],
+            "type": "polyline",
+            "lineWidth": 2,
+            "closed": True,
+            "label": {"value": idx_config[label]["label"]},
+            "group": idx_config[label]["group"],
+        }
+
+        if len(holes):
+            element["holes"] = holes
 
-            elements.append(element)
+        elements.append(element)
 
     response = gc.post(
         "/annotation",
@@ -807,6 +796,10 @@ def remove_overlapping_annotations(
             del element["order"]
             geometry = element.pop("geometry")
 
+            # If the object ended up being a line, skipt it.
+            if isinstance(geometry, LineString):
+                continue
+
             exterior_poly = list(geometry.exterior.coords)
             interior_polys = [
                 list(interior.coords) for interior in geometry.interiors

{dsa_helpers-1.1.5.dev9 → dsa_helpers-1.1.6.dev0}/dsa_helpers/image_utils.py

@@ -103,7 +103,14 @@ def label_mask_to_polygons(
 
 
 def convert_label_mask_to_rgb(
-    mask: np.ndarray, int2rgb: dict, alpha: bool = False
+    mask: np.ndarray,
+    int2rgb: dict,
+    alpha: bool = False,
+    fill_color: tuple[int, int, int] | tuple[int, int, int, int] = (
+        255,
+        255,
+        255,
+    ),
 ) -> np.ndarray:
     """
     Convert a label mask to an RGB mask.
@@ -113,6 +120,7 @@ def convert_label_mask_to_rgb(
         int2rgb: Dictionary mapping integer labels to RGB colors. If
             passing alpha as True, then pass RGBA colors.
         alpha: Whether to include the alpha channel in the RGB mask.
+        fill_color: Color to fill the mask with.
 
     Returns:
         (np.ndarray): RGB(A) mask.
@@ -123,6 +131,8 @@ def convert_label_mask_to_rgb(
         (mask.shape[0], mask.shape[1], 4 if alpha else 3), dtype=np.uint8
     )
 
+    rgb_mask[:] = fill_color
+
     # Loop through the label mask.
     for label, rgb in int2rgb.items():
         rgb_mask[mask == label] = rgb

dsa_helpers-1.1.6.dev0/dsa_helpers/ml/segformer_semantic_segmentation/inference.py

@@ -0,0 +1,199 @@
+import torch
+from large_image_eager_iterator import LargeImagePrefetch
+from transformers import (
+    SegformerForSemanticSegmentation,
+    SegformerImageProcessor,
+)
+from PIL import Image
+from large_image import getTileSource
+import geopandas as gpd
+from shapely.affinity import scale
+import pandas as pd
+
+from dsa_helpers.image_utils import label_mask_to_polygons
+from dsa_helpers.gpd_utils import remove_gdf_overlaps
+
+
+def inference(
+    model: str | torch.nn.Module,
+    wsi_fp: str,
+    batch_size: int = 16,
+    tile_size: int = 512,
+    mag: float | None = None,
+    workers: int = 8,
+    chunk_mult: int = 2,
+    prefetch: int = 2,
+    device: str | None = None,
+    tolerance: float | None = 2.0,
+    min_area: float = 1000,
+) -> gpd.GeoDataFrame:
+    """Inference using SegFormer semantic segmentation model on a WSI.
+
+    Args:
+        model (str | torch.nn.Module): Path to the model checkpoint or
+            a pre-loaded model.
+        wsi_fp (str): File path to the WSI.
+        batch_size (int, optional): Batch size for inference. Defaults
+            to 16.
+        tile_size (int, optional): Tile size for inference. Defaults to
+            512.
+        mag (float, optional): Magnification for inference. Defaults to
+            None, which will use the scan magnification of WSI.
+        workers (int, optional): Number of workers for inference.
+            Defaults to 8.
+        chunk_mult (int, optional): Chunk multiplier for inference.
+            Defaults to 2.
+        prefetch (int, optional): Number of prefetch for inference.
+            Defaults to 2.
+        device (str, optional): Device for inference. Default is None,
+            will use "gpu" if available, otherwise "cpu".
+        tolerance (float | None, optional): Tolerance for simplification
+            of the predicted polygons. Guidelines: 0.5 for mild
+            simplification, 1.0 for moderate, 2.0 for more aggressive.
+            If set to None or 0.0, the polygons will not be simplified.
+        min_area (float, optional): Minimum area of a polygon to be
+            simplified. This is added to avoid simplifying small
+            polygons that would probably lose too much information.
+            Defaults to 1000.
+
+    Returns:
+        gpd.GeoDataFrame: A GeoDataFrame containing the predicted
+            polygons and labels.
+
+    """
+    # Initiate the tile iterator.
+    iterator = LargeImagePrefetch(
+        wsi_fp,
+        batch=batch_size,
+        tile_size=(tile_size, tile_size),
+        scale_mode="mag",
+        target_scale=mag,
+        workers=workers,
+        chunk_mult=chunk_mult,
+        prefetch=prefetch,
+        nchw=False,
+        icc=True,
+    )
+
+    if device is None:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {device}")
+
+    device = torch.device(device)
+
+    # Load the model.
+    if isinstance(model, str):
+        model = SegformerForSemanticSegmentation.from_pretrained(
+            model, local_files_only=True, device_map=device
+        )
+
+    model.eval()
+
+    # Iterate through batches.
+    batch_n = 0
+
+    # Image processor for images.
+    processor = SegformerImageProcessor()
+
+    # Track all predicted polygons.
+    wsi_polygons = []
+
+    # Scaling factor, multiply to go from scan magnification to desired mag.
+    ts_metadata = getTileSource(wsi_fp).getMetadata()
+    scan_mag = ts_metadata["magnification"]
+
+    if mag is None:
+        mag = scan_mag
+        sf = 1.0
+    else:
+        sf = mag / scan_mag
+
+    for batch in iterator:
+        # Get the batch of images.
+        imgs = batch[0].view()  # returns a numpy array of shape (N, H, W, C)
+        coordinates = batch[1]
+
+        # Convert the numpy arrays to PIL images.
+        imgs = [Image.fromarray(img) for img in imgs]
+
+        # Pass the images through the processor.
+        inputs = processor(imgs, return_tensors="pt")
+        inputs = inputs.to(model.device)
+
+        # Predict on the batch.
+        with torch.no_grad():
+            output = model(inputs["pixel_values"])
+            logits = output.logits
+
+            # Get the logits out, resizing them to the original tile size.
+            logits = torch.nn.functional.interpolate(
+                logits,
+                size=tile_size,
+                mode="bilinear",
+            )
+
+            # Get predicted class labels for each pixel.
+            masks = torch.argmax(logits, dim=1).detach().cpu().numpy()
+
+        # Loop through each mask to extract the contours as shapely polygons.
+        for i, mask in enumerate(masks):
+            img_metadata = coordinates[i]
+            x, y = img_metadata[6], img_metadata[4]
+            x = int(x * sf)
+            y = int(y * sf)
+
+            polygon_and_labels = label_mask_to_polygons(
+                mask,
+                x_offset=x,
+                y_offset=y,
+            )
+
+            for polygon_and_label in polygon_and_labels:
+                polygon, label = polygon_and_label
+                label = int(label)
+
+                # Do something with the polygon and label.
+                wsi_polygons.append([polygon, label])
+
+        batch_n += 1
+        print(f"\r    Processed batch {batch_n}.    ", end="")
+    print()
+
+    # Convert polygons and labels to a GeoDataFrame.
+    gdf = gpd.GeoDataFrame(wsi_polygons, columns=["geometry", "label"])
+    gdf["geometry"] = gdf["geometry"].buffer(1)
+    gdf = gdf.dissolve(by="label", as_index=False)
+    gdf = gdf.explode(index_parts=False).reset_index(drop=True)
+
+    if tolerance:
+        # Add the area column.
+        gdf["area"] = gdf["geometry"].area
+
+        # Split the dataframe into those polygons that need to be simplified and those that do not.
+        gdf_to_simplify = gdf[gdf["area"] > min_area].reset_index(drop=True)
+        gdf_not_to_simplify = gdf[gdf["area"] <= min_area].reset_index(
+            drop=True
+        )
+
+        # Simplify the polygons that need to be simplified.
+        gdf_to_simplify["geometry"] = gdf_to_simplify["geometry"].simplify(
+            tolerance=tolerance, preserve_topology=True
+        )
+
+        # Concatenate the simplified polygons with the polygons that do not need to be simplified.
+        gdf = pd.concat(
+            [gdf_to_simplify, gdf_not_to_simplify], ignore_index=True
+        )
+
+    # Remove overlapping polygons.
+    no_overlap_gdf = remove_gdf_overlaps(
+        gdf,
+        columns="label",
+    )
+
+    # Scale the polygon to scan magnification.
+    no_overlap_gdf["geometry"] = no_overlap_gdf["geometry"].apply(
+        lambda geom: scale(geom, xfact=1 / sf, yfact=1 / sf, origin=(0, 0))
+    )
+
+    return no_overlap_gdf

{dsa_helpers-1.1.5.dev9 → dsa_helpers-1.1.6.dev0}/dsa_helpers/ml/segformer_semantic_segmentation/train.py

@@ -128,14 +128,15 @@ def train_segformer_semantic_segmentation_model(
         train_data, transforms=train_transforms
     )
 
-    val_dataset = create_segformer_segmentation_dataset(
-        (
-            val_data
-            if max_val_size is None
-            else val_data.sample(n=max_val_size, random_state=random_state)
-        ),
-        transforms=val_transforms,
-    )
+    if val_data is not None and max_val_size < len(val_data):
+        val_dataset = create_segformer_segmentation_dataset(
+            val_data.sample(n=max_val_size, random_state=random_state),
+            transforms=val_transforms,
+        )
+    else:
+        val_dataset = create_segformer_segmentation_dataset(
+            val_data, transforms=val_transforms
+        )
 
     def compute_metrics(eval_pred):
         """Function for computing DICE coefficient metrics for each
@@ -183,11 +184,11 @@ def train_segformer_semantic_segmentation_model(
             denominator_value = denominator[label]
 
             if denominator_value:
-                metrics[label] = float(
+                metrics[f"{label}_dice"] = float(
                     2 * intersection[label] / denominator_value
                 )
             else:
-                metrics[label] = 1
+                metrics[f"{label}_dice"] = 1
 
         # Add the mean Dice.
         metrics["mean_dice"] = float(np.mean(list(metrics.values())))

{dsa_helpers-1.1.5.dev9 → dsa_helpers-1.1.6.dev0}/dsa_helpers/tiling.py

@@ -32,13 +32,13 @@ def _proccess_tile_with_masks_from_dsa_annotations(
     sf,
     img_dir,
     mask_dir,
-    background_value,
-    background_index,
+    edge_value,
+    background_id,
     edge_thr,
     ignore_existing,
-    ignore_labels,
-    ignore_index,
+    ignore_id,
     ignore_value,
+    ignore_ids,
 ):
     """Processing tiles with masks, used in multiprocessing only."""
     # Calcualte the x and y at magnification desired.
@@ -81,7 +81,7 @@ def _proccess_tile_with_masks_from_dsa_annotations(
             0,
             tile_size - w,
             cv.BORDER_CONSTANT,
-            value=background_value,
+            value=edge_value,
         )
 
         h, w = img.shape[:2]
@@ -96,12 +96,13 @@ def _proccess_tile_with_masks_from_dsa_annotations(
 
     # Draw the dataframe on the tile mask.
     mask = draw_gdf_on_array(
-        tile_gdf, (h, w), default_value=background_index
+        tile_gdf, (h, w), default_value=background_id
     ).copy()
 
-    if ignore_labels is not None:
-        img[np.isin(mask, ignore_labels)] = ignore_value
-        mask[np.isin(mask, ignore_labels)] = ignore_index
+    if ignore_ids is not None:
+        # Apply the ignore ids to the image and mask.
+        img[np.isin(mask, ignore_ids)] = ignore_value
+        mask[np.isin(mask, ignore_ids)] = ignore_id
 
     # Save the tile image and mask.
     imwrite(img_fp, img)
@@ -121,12 +122,12 @@ def tile_wsi_with_masks_from_dsa_annotations(
     mag: float | None = None,
     prepend_name: str = "",
     nproc: int = 1,
-    background_value: tuple[int, int, int] | int = (255, 255, 255),
-    background_index: int = 0,
+    edge_value: tuple[int, int, int] | int = (255, 255, 255),
+    background_id: int = 0,
     edge_thr: float = 0.25,
     ignore_existing: bool = False,
     ignore_labels: str | list[str] | None = None,
-    ignore_index: int = 255,
+    ignore_id: int = 255,
     ignore_value: tuple[int, int, int] = (255, 255, 255),
     notebook_tqdm: bool = False,
 ) -> list[str]:
@@ -187,11 +188,14 @@ def tile_wsi_with_masks_from_dsa_annotations(
     else:
         from tqdm import tqdm
 
+    # Should be a list of string labels.
     if isinstance(ignore_labels, str):
         ignore_labels = [ignore_labels]
 
     if ignore_labels is not None:
-        ignore_labels = [label2id[label] for label in ignore_labels]
+        ignore_ids = [label2id[label] for label in ignore_labels]
+    else:
+        ignore_ids = None
 
     # Read the tile source.
     ts = large_image.getTileSource(wsi_fp)
@@ -218,9 +222,8 @@ def tile_wsi_with_masks_from_dsa_annotations(
 
     gdf = gpd.GeoDataFrame.from_features(geojson_ann_doc.get("features", []))
 
-    if label_col == "label":
-        # Convert the label column, which is a dictionary, set it to its 'value' key.
-        gdf["label"] = gdf["label"].apply(lambda x: x.get("value", ""))
+    # Convert the label column, which is a dictionary, set it to its 'value' key.
+    gdf["label"] = gdf["label"].apply(lambda x: x.get("value", ""))
 
     # Filter to polygons in label2id.
     gdf = gdf[gdf[label_col].isin(label2id.keys())]
@@ -235,7 +238,7 @@ def tile_wsi_with_masks_from_dsa_annotations(
         )
     )
 
-    # Add and idx column, which is the map of the group to the label2id.
+    # Add an idx column, which is the map of the group to the label2id.
     gdf["idx"] = gdf[label_col].map(label2id)
 
     # Get the top left corner of every tile in the WSI, at scan mag.
@@ -268,13 +271,13 @@ def tile_wsi_with_masks_from_dsa_annotations(
                     scan_to_mag_sf,
                     img_dir,
                     mask_dir,
-                    background_value,
-                    background_index,
+                    edge_value,
+                    background_id,
                     edge_thr,
                     ignore_existing,
-                    ignore_labels,
-                    ignore_index,
+                    ignore_id,
                     ignore_value,
+                    ignore_ids,
                 ),
             )
             for xy in xys

{dsa_helpers-1.1.5.dev9 → dsa_helpers-1.1.6.dev0/dsa_helpers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dsa_helpers
-Version: 1.1.5.dev9
+Version: 1.1.6.dev0
 Summary: Utility functions for working with the DSA girder client.
 Author-email: "Juan C. Vizcarra" <jvizcar@emory.edu>
 Maintainer-email: "Juan C. Vizcarra" <jvizcar@emory.edu>

{dsa_helpers-1.1.5.dev9 → dsa_helpers-1.1.6.dev0}/pyproject.toml

@@ -38,7 +38,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 ]
 keywords = ["dsa", "girder", "girder_client"]
-version = "v1.1.5.dev9"
+version = "v1.1.6.dev0"
 
 [project.urls]
 Repository = "https://github.com/Gutman-Lab/dsa-python-utils"

dsa_helpers-1.1.5.dev9/dsa_helpers/ml/segformer_semantic_segmentation/inference.py

@@ -1,123 +0,0 @@
-import numpy as np
-from pathlib import Path
-import cv2 as cv
-import shutil
-
-import transformers
-from transformers import SegformerImageProcessor
-
-import torch
-import torch.nn as nn
-
-from ... import imread
-from ...tiling import tile_image
-
-
-def inference(
-    img: np.ndarray,
-    model: transformers.models.segformer.modeling_segformer.SegformerForSemanticSegmentation,
-    device: str | None = None,
-    tile_size: int = 512,
-    temp_dir: str = ".temp",
-    batch_size: int = 8,
-) -> tuple[np.ndarray, list[np.ndarray]]:
-    """Inference on an image using SegFormer model for semantic segmentation.
-
-    Args:
-        img (numpy.ndarray): Image to segment.
-        model (transformers.models.segformer.modeling_segformer.SegformerForSemanticSegmentation):
-            Pre-trained model.
-        device (str | None): Device to use. Defaults to None, in which case
-            it is inferred based on devices available.
-        tile_size (int): Size of the tiles. Defaults to 512.
-        temp_dir (str): Temporary directory to save tiles. Defaults to ".temp".
-        batch_size (int): Batch size. Defaults to 8.
-
-    Returns:
-        tuple[numpy.ndarray, list[numpy.ndarray]]: The predicted label mask and
-            the contours of the mask.
-
-    """
-    # Create location to save tile images.
-    tile_dir = Path(temp_dir)
-    tile_dir.mkdir(exist_ok=True, parents=True)
-
-    # Tile the image.
-    tiles_df = tile_image(
-        img,
-        str(tile_dir),
-        tile_size=tile_size,
-    )
-
-    # Create instance of the image processor.
-    img_processor = SegformerImageProcessor()
-
-    if device is None:
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-
-    print("Using device:", device)
-
-    # Set model to eval mode.
-    model.to(device)  # to device
-    model.eval()
-
-    # Create an empty mask the size of the image.
-    h, w = img.shape[:2]
-    predicted_mask = np.zeros((h + tile_size, w + tile_size), dtype=np.uint8)
-
-    # Loop through tile images in batch size.
-    for i in range(0, len(tiles_df), batch_size):
-        # Get batch of tile images.
-        batch = tiles_df.iloc[i : i + batch_size]
-
-        # Read all the images in the batch.
-        images = [imread(fp) for fp in batch["fp"]]
-
-        # Process all the images.
-        inputs = img_processor(
-            images=images,
-            return_tensors="pt",
-        )
-
-        # Send to the same device as model.
-        inputs = inputs.to(device)
-
-        with torch.no_grad():
-            # Sent inputs through the model.
-            outputs = model(**inputs)
-
-            # Get out the logits.
-            logits = outputs.logits
-
-            # Reshape the logits to the original image size.
-            upsampled_logits = nn.functional.interpolate(
-                logits,
-                size=(tile_size, tile_size),  # (height, width)
-                mode="bilinear",
-                align_corners=False,
-            )
-
-            # Take the max value of the class dimension.
-            pred_seg = upsampled_logits.argmax(dim=1)
-
-            # Place tile predictions into the overall predicted mask.
-            for j in range(len(batch)):
-                r = batch.iloc[j]
-                x, y = r["x"], r["y"]
-                predicted_mask[y : y + tile_size, x : x + tile_size] = (
-                    pred_seg[j].cpu().numpy()
-                ).astype(np.uint8)
-
-    # Remove the temp directory.
-    shutil.rmtree(temp_dir)
-
-    # Remove edges.
-    predicted_mask = predicted_mask[:h, :w]
-
-    # Extract the contours of the mask.
-    contours = cv.findContours(
-        predicted_mask, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE
-    )[0]
-
-    # Return the mask.
-    return predicted_mask, contours