dsa-helpers 0.9.dev1__tar.gz → 1.dev0__tar.gz

dsa_helpers-1.dev0/.readthedocs.yaml

@@ -0,0 +1,16 @@
+version: 2
+
+build:
+  os: "ubuntu-24.04"
+  tools:
+    python: "3.12"
+  jobs:
+    pre_build:
+      - sphinx-apidoc -o docs/source dsa_helpers/
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+
+sphinx:
+  configuration: docs/source/conf.py

{dsa_helpers-0.9.dev1/dsa_helpers.egg-info → dsa_helpers-1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dsa_helpers
-Version: 0.9.dev1
+Version: 1.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.dev0/docs/requirements.txt

@@ -0,0 +1,16 @@
+girder-client
+numpy
+setuptools
+opencv-python
+pandas
+pymongo
+pillow
+dash
+dash-bootstrap-components
+shapely
+geopandas
+transformers[torch]
+datasets
+torchvision
+large-image
+sphinx_rtd_theme

dsa_helpers-1.dev0/docs/source/conf.py

@@ -0,0 +1,42 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("../.."))
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = "DSA Helpers"
+copyright = "2024, Juan Carlos Vizcarra"
+author = "Juan Carlos Vizcarra"
+release = "00.00.01"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.napoleon",
+]
+
+templates_path = ["_templates"]
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "sphinx_rtd_theme"
+html_static_path = ["_static"]

dsa_helpers-1.dev0/docs/source/index.rst

@@ -0,0 +1,18 @@
+.. DSA Helpers documentation master file, created by
+   sphinx-quickstart on Fri Dec  6 12:07:31 2024.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+DSA Helpers documentation
+=========================
+
+Add your content using ``reStructuredText`` syntax. See the
+`reStructuredText <https://www.sphinx-doc.org/en/master/usage/restructuredtext/index.html>`_
+documentation for details.
+
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   modules

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers/__init__.py

@@ -16,8 +16,6 @@ __all__ = [
     "girder_utils",
     "dash",
     "ml",
-    "imread",
-    "imwrite",
     "mongo_utils",
     "tiling",
     "utils",

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers/dash/header.py

@@ -15,13 +15,8 @@ def get_header(
     Args:
         dsa_api_url (str): The URL of the DSA API.
         title (str, optional): The title of the application. Defaults to "App".
-        config (dict, optional): The configuration of the component. Defaults to None.
-            If None the default configuration is:
-            {
-                "backgroundColor": "#012169",
-                "titleColor": "#d9d9d6",
-                "fontColor": "#f2a900",
-            }
+        config (dict, optional): The configuration of the component.
+            Defaults to None which uses default settings.
 
     Returns:
         html.Div: The header component.
@@ -38,7 +33,8 @@ def get_header(
             dbc.ModalBody(
                 [
                     html.Div(
-                        "Login or email", style={"margin": 5, "fontWeight": "bold"}
+                        "Login or email",
+                        style={"margin": 5, "fontWeight": "bold"},
                     ),
                     dbc.Input(
                         id=f"{store_id}=login",
@@ -48,7 +44,11 @@ def get_header(
                     ),
                     html.Div(
                         "Password",
-                        style={"margin": 5, "marginTop": 15, "fontWeight": "bold"},
+                        style={
+                            "margin": 5,
+                            "marginTop": 15,
+                            "fontWeight": "bold",
+                        },
                     ),
                     dbc.Input(
                         id=f"{store_id}=password",
@@ -60,7 +60,11 @@ def get_header(
                         "Login failed.",
                         hidden=True,
                         id=f"{store_id}=login-failed",
-                        style={"color": "red", "fontWeight": "bold", "margin": 10},
+                        style={
+                            "color": "red",
+                            "fontWeight": "bold",
+                            "margin": 10,
+                        },
                     ),
                 ],
             ),

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers/girder_utils.py

@@ -88,19 +88,19 @@ def get_region(
     height: int,
     mag: float | None = None,
 ) -> np.ndarray:
-    """Get a region of the image for an item. Note that the output image might
-    not be in the shape (width, height) if left + width or top + height exceeds
-    the image size. The outpuzerositem id.
+    """Get image region from DSA. Note that the output image might not
+    be in the shape (width, height) if left + width or top + height
+    exceeds the image size.
+
+    Args:
+        gc (girder_client.GirderClient): The authenticated girder client.
+        item_id (str): The item id.
         left (int): The left coordinate.
         top (int): The top coordinate.
         width (int): The width of the region.
         height (int): The height of the region.
-        mag (float, optional): The magnification. Defaults to None which returns
-            the image at scan magnification. Using a mag lower than the scan
-            magnification will result in an ouptut image smaller than the
-            width and height. Similarly, using a mag higher than the scan
-            magnification will result in an output image larger than the width
-            and height.
+        mag (float, optional): The magnification. Defaults to None which
+            returns the image at the scan magnification.
 
     Returns:
         np.ndarray: The region of the image.
@@ -258,17 +258,16 @@ def _rotate_point_list(point_list, rotation, center=(0, 0)):
     return point_list_rotated
 
 
-def get_rectangle_element_coords(element):
+def get_rectangle_element_coords(element: dict) -> np.ndarray:
     """Get the corner coordinate from a rectangle HistomicsUI element, can handle rotated elements.
     Adapted from: https://github.com/DigitalSlideArchive/HistomicsTK/blob/master/histomicstk/annotations_and_masks/annotation_and_mask_utils.py
-    INPUTS
-    ------
-    element : dict
-        rectangle element, in HistomicsUI format
-    RETURN
-    ------
-    corner_coords : array
-        array of shape [4, 2] for the four corners of the rectangle in (x, y) format
+
+    Args:
+        element (dict): rectangle element from HistomicsUI annotation.
+
+    Returns:
+    corner_coords (np.ndarray): 4x2 array of corner coordinates of rectangle.
+
     """
     # element is a dict so prevent referencing
     element = deepcopy(element)
@@ -401,7 +400,9 @@ def get_roi_with_yolo_labels_from_single_doc(
         if element.get("group") == roi_element_group:
             # Append the ROI element, there can't more than one.
             if roi_element is not None:
-                raise ValueError("Multiple ROI elements found in the document.")
+                raise ValueError(
+                    "Multiple ROI elements found in the document."
+                )
 
             roi_element = element
         elif element.get("group") in group_map:
@@ -460,7 +461,9 @@ def get_roi_with_yolo_labels_from_single_doc(
     for element in box_elements:
         if element.get("group") in group_map:
             if element.get("type") != "rectangle":
-                print(f"Skipping element: {element.get('type')} not supported.")
+                print(
+                    f"Skipping element: {element.get('type')} not supported."
+                )
                 continue
 
             group_id = group_map[element.get("group")]
@@ -523,7 +526,9 @@ def post_annotations_from_gdf(
     # Process the dataframe.
     for _, row in gdf.iterrows():
         # Flatten multipolygon to list of polygons.
-        list_of_polygons = list(row["geometry"].geoms)  # assuming multipolygons
+        list_of_polygons = list(
+            row["geometry"].geoms
+        )  # assuming multipolygons
         label = row["label"]
 
         for poly in list_of_polygons:

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers/ml/__init__.py

@@ -4,7 +4,7 @@ from . import (
     datasets,
     transforms,
     segformer_semantic_segmentation,
-    tiling,
+    callbacks,
 )
 
 # Modules that are imported from * notation.
@@ -14,5 +14,5 @@ __all__ = [
     "metrics",
     "transforms",
     "segformer_semantic_segmentation",
-    "tiling",
+    "callbacks",
 ]

dsa_helpers-1.dev0/dsa_helpers/ml/callbacks.py

@@ -0,0 +1,55 @@
+"""Provides custom callbacks for the Hugging Face Trainer class."""
+
+from transformers import TrainerCallback
+from pathlib import Path
+import pandas as pd
+
+
+class MetricsLoggerCallback(TrainerCallback):
+    def _load_current_file(self, output_dir):
+        output_dir = Path(output_dir)
+        metrics_file = output_dir / "metrics.csv"
+
+        return (
+            pd.read_csv(metrics_file)
+            if metrics_file.exists()
+            else pd.DataFrame()
+        )
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        """
+        Triggered during training logging (e.g., for training loss).
+        """
+        if "loss" in logs:  # Ensure training loss is available
+            metrics_df = self._load_current_file(args.output_dir)
+
+            # Append the epoch and the training loss.
+            loss = logs["loss"]
+            epoch = state.epoch
+
+            metrics_df = pd.concat(
+                [
+                    metrics_df,
+                    pd.DataFrame([{"epoch": epoch, "train_loss": loss}]),
+                ],
+                ignore_index=True,
+            )
+
+            # Save it back to file.
+            metrics_df.to_csv(
+                Path(args.output_dir) / "metrics.csv", index=False
+            )
+
+    def on_evaluate(self, args, state, control, metrics, **kwargs):
+        """
+        This is triggered at the end of evaluation (including at the end of each epoch).
+        """
+        # Get the current metrics file.
+        metrics_df = self._load_current_file(args.output_dir)
+
+        # Add metrics to the last row of the current metrics file.
+        for k, v in metrics.items():
+            metrics_df.at[metrics_df.index[-1], k] = v
+
+        # Save the updated metrics file.
+        metrics_df.to_csv(Path(args.output_dir) / "metrics.csv", index=False)

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers/ml/datasets/__init__.py

@@ -1,3 +1,3 @@
 from .SegFormerSegmentationDataset import SegFormerSegmentationDataset
 
-__all__ = ["SegFormerSegmentationDataset", "utils"]
+__all__ = ["utils"]

dsa_helpers-1.dev0/dsa_helpers/ml/metrics.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""Metric functions.
+
+This module contains functions used to evaluate the performance of 
+machine learning models.
+
+"""
+import torch
+from torch import nn
+import numpy as np
+
+
+def binary_dice_coefficient(eval_pred: tuple[np.ndarray, np.ndarray]) -> dict:
+    """Calculate the dice coefficient for binary masks. Developed for use
+    in compute_metrics parameters of transformers Trainer class, for
+    SegFormer senantic segmentation model of two classes.
+
+    Args:
+        eval_pred (tuple[np.ndarray, np.ndarray]): A tuple containing the
+            predicted and true masks.
+
+    Returns:
+        dict: A dictionary containing the dice coefficient.
+
+    """
+    with torch.no_grad():
+        logits, labels = eval_pred
+
+        # Convert to tensors.
+        logits = torch.from_numpy(logits).cpu()
+
+        # Resize the logits to be the same shape as the labels.
+        logits = nn.functional.interpolate(
+            logits,
+            size=labels.shape[-2:],
+            mode="bilinear",
+            align_corners=False,
+        ).argmax(dim=1)
+
+        preds = logits.detach().numpy()
+
+        # Convert the masks to binary.
+        preds = preds > 0
+        labels = labels > 0
+
+        # Calculate dice.
+        intersection = np.sum(preds * labels)
+        union = np.sum(preds) + np.sum(labels)
+
+        if union == 0:
+            dice = 1.0  # Both masks are empty
+        else:
+            dice = 2.0 * intersection / union
+
+        return {"dice_coefficient": dice}
+
+
+def mean_iou(label2idx: dict):
+    """Return the compute metric function for mean intersection over
+    union for a multi-class semantic segmentation task.
+
+    Args:
+        label2idx (dict): A dictionary mapping class labels to indices.
+
+    Returns:
+        function: The compute_metrics function.
+
+    """
+    idx2label = {v: k for k, v in label2idx.items()}
+
+    def compute_metrics(eval_pred):
+        """Compute the mean intersection over union (IoU) for semantic
+        segmentation. Also returns the IoU for each class."""
+        with torch.no_grad():
+            logits, labels = eval_pred
+
+            # Convert logits to tensor.
+            logits_tensor = torch.from_numpy(logits).cpu()
+            labels_tensor = torch.from_numpy(labels).cpu()
+
+            # From logits get the number of classes in the dataset.
+            num_classes = logits.shape[1]
+
+            # Scale the logits back to the shape of the labels.
+            logits_tensor = nn.functional.interpolate(
+                logits_tensor,
+                size=labels.shape[-2:],
+                mode="bilinear",
+                align_corners=False,
+            )
+
+            # Turn the logits to predictions.
+            pred = logits_tensor.argmax(dim=1)
+
+            # Calculate the IoU for each class.
+            ious = []
+
+            metrics = {}
+
+            for cls in range(num_classes):
+                pred_mask = pred == cls
+                labels_mask = labels_tensor == cls
+
+                intersection = (
+                    torch.logical_and(pred_mask, labels_mask).sum().item()
+                )
+                union = torch.logical_or(pred_mask, labels_mask).sum().item()
+
+                if union == 0:
+                    iou = float("nan")  # or 1.0
+                else:
+                    iou = intersection / union
+
+                metrics[f"{idx2label[cls]}_iou"] = iou
+
+                ious.append(iou)
+
+            mean_iou = np.nanmean(ious)  # Use NumPy for NaN handling
+            metrics["mean_iou"] = mean_iou
+
+            return metrics
+
+    return compute_metrics

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers/ml/object_detection/__init__.py

@@ -2,4 +2,4 @@
 from .get_pearce_roi_images import get_pearce_roi_images
 from .tile_image import tile_image
 
-__all__ = ["utils", "get_pearce_roi_images", "tile_image"]
+__all__ = ["utils"]

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers/ml/segformer_semantic_segmentation/__init__.py

@@ -1,3 +1,3 @@
 from .inference import inference
 
-__all__ = ["inference"]
+__all__ = []

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers/ml/segformer_semantic_segmentation/inference.py

@@ -10,7 +10,7 @@ import torch
 import torch.nn as nn
 
 from ... import imread
-from ...image_utils import tile_image
+from ...tiling import tile_image
 
 
 def inference(
@@ -115,7 +115,9 @@ def inference(
     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]
+    contours = cv.findContours(
+        predicted_mask, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE
+    )[0]
 
     # Return the mask.
     return predicted_mask, contours

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0/dsa_helpers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dsa_helpers
-Version: 0.9.dev1
+Version: 1.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-0.9.dev1 → dsa_helpers-1.dev0}/dsa_helpers.egg-info/SOURCES.txt

@@ -1,8 +1,12 @@
 .gitignore
+.readthedocs.yaml
 LICENSE
 README.md
 app.py
 pyproject.toml
+docs/requirements.txt
+docs/source/conf.py
+docs/source/index.rst
 dsa_helpers/__init__.py
 dsa_helpers/girder_utils.py
 dsa_helpers/imread.py
@@ -21,6 +25,7 @@ dsa_helpers/dash/dash_paperdragon_utils.py
 dsa_helpers/dash/header.py
 dsa_helpers/dash/header_callbacks.py
 dsa_helpers/ml/__init__.py
+dsa_helpers/ml/callbacks.py
 dsa_helpers/ml/metrics.py
 dsa_helpers/ml/datasets/SegFormerSegmentationDataset.py
 dsa_helpers/ml/datasets/__init__.py
@@ -31,8 +36,6 @@ dsa_helpers/ml/object_detection/tile_image.py
 dsa_helpers/ml/object_detection/utils.py
 dsa_helpers/ml/segformer_semantic_segmentation/__init__.py
 dsa_helpers/ml/segformer_semantic_segmentation/inference.py
-dsa_helpers/ml/tiling/__init__.py
-dsa_helpers/ml/tiling/semantic_seg_tile_wsi_with_dsa_annotations.py
 dsa_helpers/ml/transforms/__init__.py
 dsa_helpers/ml/transforms/segformer_transforms.py
 tests/docker-compose.yaml

{dsa_helpers-0.9.dev1 → dsa_helpers-1.dev0}/pyproject.toml

@@ -35,7 +35,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 ]
 keywords = ["dsa", "girder", "girder_client"]
-version = "v0.9dev1"
+version = "v1dev0"
 
 [project.urls]
 Repository = "https://github.com/Gutman-Lab/dsa-python-utils"

dsa_helpers-0.9.dev1/dsa_helpers/ml/metrics.py

@@ -1,117 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Metric functions.
-
-This module contains functions used to evaluate the performance of 
-machine learning models.
-
-"""
-import torch
-from torch import nn
-import numpy as np
-
-
-def binary_dice_coefficient(eval_pred: tuple[np.ndarray, np.ndarray]) -> dict:
-    """Calculate the dice coefficient for binary masks. Developed for use
-    in compute_metrics parameters of transformers Trainer class, for
-    SegFormer senantic segmentation model of two classes.
-
-    Args:
-        eval_pred (tuple[np.ndarray, np.ndarray]): A tuple containing the
-            predicted and true masks.
-
-    Returns:
-        dict: A dictionary containing the dice coefficient.
-
-    """
-    with torch.no_grad():
-        logits, labels = eval_pred
-
-        # Convert to tensors.
-        logits = torch.from_numpy(logits).cpu()
-
-        # Resize the logits to be the same shape as the labels.
-        logits = nn.functional.interpolate(
-            logits,
-            size=labels.shape[-2:],
-            mode="bilinear",
-            align_corners=False,
-        ).argmax(dim=1)
-
-        preds = logits.detach().numpy()
-
-        # Convert the masks to binary.
-        preds = preds > 0
-        labels = labels > 0
-
-        # Calculate dice.
-        intersection = np.sum(preds * labels)
-        union = np.sum(preds) + np.sum(labels)
-
-        if union == 0:
-            dice = 1.0  # Both masks are empty
-        else:
-            dice = 2.0 * intersection / union
-
-        return {"dice_coefficient": dice}
-
-
-def mean_iou(eval_pred: tuple[np.ndarray, np.ndarray]) -> dict:
-    """Compute the mean intersection over union (IoU) for semantic
-    segmentation. Also returns the IoU for each class.
-
-    Args:
-        eval_pred (tuple[numpy.ndarray, numpy.ndarray]): Tuple of
-            logits and labels.
-
-    Returns:
-        dict: Dictionary of metrics.
-
-    """
-    with torch.no_grad():
-        logits, labels = eval_pred
-
-        # Convert logits to tensor.
-        logits_tensor = torch.from_numpy(logits).cpu()
-        labels_tensor = torch.from_numpy(labels).cpu()
-
-        # From logits get the number of classes in the dataset.
-        num_classes = logits.shape[1]
-
-        # Scale the logits back to the shape of the labels.
-        logits_tensor = nn.functional.interpolate(
-            logits_tensor,
-            size=labels.shape[-2:],
-            mode="bilinear",
-            align_corners=False,
-        )
-
-        # Turn the logits to predictions.
-        pred = logits_tensor.argmax(dim=1)
-
-        # Calculate the IoU for each class.
-        ious = []
-
-        metrics = {}
-
-        for cls in range(num_classes):
-            pred_mask = pred == cls
-            labels_mask = labels_tensor == cls
-
-            intersection = (
-                torch.logical_and(pred_mask, labels_mask).sum().item()
-            )
-            union = torch.logical_or(pred_mask, labels_mask).sum().item()
-
-            if union == 0:
-                iou = float("nan")  # or 1.0
-            else:
-                iou = intersection / union
-
-            metrics[f"label {cls} IoU"] = iou
-
-            ious.append(iou)
-
-        mean_iou = np.nanmean(ious)  # Use NumPy for NaN handling
-        metrics["mean_iou"] = mean_iou
-
-        return metrics

dsa_helpers-0.9.dev1/dsa_helpers/ml/tiling/__init__.py

@@ -1,5 +0,0 @@
-from .semantic_seg_tile_wsi_with_dsa_annotations import (
-    semantic_seg_tile_wsi_with_dsa_annotations,
-)
-
-__all__ = ["semantic_seg_tile_wsi_with_dsa_annotations"]

dsa_helpers-0.9.dev1/dsa_helpers/ml/tiling/semantic_seg_tile_wsi_with_dsa_annotations.py

@@ -1,225 +0,0 @@
-import large_image
-import cv2 as cv
-import numpy as np
-from pathlib import Path
-from ...imwrite import imwrite
-from multiprocessing import Pool
-from tqdm import tqdm
-
-
-def _process_tile(
-    ts,
-    prepend_name,
-    x,
-    y,
-    scan_tile_size,
-    tile_size,
-    mag,
-    contours,
-    sf,
-    img_dir,
-    mask_dir,
-):
-    fn = f"{prepend_name}x{x}y{y}.png"
-
-    # Get the tile.
-    tile_img = ts.getRegion(
-        region={
-            "left": x,
-            "top": y,
-            "right": x + scan_tile_size,
-            "bottom": y + scan_tile_size,
-        },
-        format=large_image.constants.TILE_FORMAT_NUMPY,
-        scale={"magnification": mag},
-    )[0][:, :, :3]
-
-    if tile_img.shape[:2] != (tile_size, tile_size):
-        # Pad the image with zeroes to make it the desired size.
-        tile_img = cv.copyMakeBorder(
-            tile_img,
-            0,
-            tile_size - tile_img.shape[0],
-            0,
-            tile_size - tile_img.shape[1],
-            cv.BORDER_CONSTANT,
-            value=0,
-        )
-
-    # Create a blank tile mask.
-    tile_mask = np.zeros(tile_img.shape[:2], dtype=np.uint8)
-
-    # Loop through contours to draw on tile mask.
-    for idx, contour_dict in contours.items():
-        # Create a mask for the specific label.
-        label_mask = np.zeros(tile_mask.shape, dtype=np.uint8)
-
-        points = contour_dict["points"].copy()
-        holes = contour_dict["holes"].copy()
-
-        # For points and hole:
-        # (1) Shift by top left of the current tile.
-        # (2) Scale by be desired magnification.
-        points = [((point - [x, y]) * sf).astype(int) for point in points]
-
-        corrected_holes = []
-
-        for hole in holes:
-            if len(hole):
-                corrected_holes.append(((hole - [x, y]) * sf).astype(int))
-
-        # Use points to draw contours as positive.
-        label_mask = cv.drawContours(label_mask, points, -1, 1, cv.FILLED)
-
-        # Draw in the holes as background class zero.
-        label_mask = cv.drawContours(label_mask, holes, -1, 0, cv.FILLED)
-
-        # Apply the label to tile mask where label mask is positive.
-        tile_mask[label_mask == 1] = idx
-
-    # Save the image and mask.
-    img_fp = img_dir / fn
-    imwrite(img_fp, tile_img)
-    imwrite(mask_dir / fn, tile_mask, grayscale=True)
-
-    return str(img_fp), x, y
-
-
-def semantic_seg_tile_wsi_with_dsa_annotations(
-    wsi_fp: str,
-    annotation_docs: list[dict],
-    label2idx: dict,
-    save_dir: str,
-    tile_size: int,
-    mag: float | None = None,
-    prepend_name: str = "",
-    nproc: int = 1,
-) -> list[str]:
-    """Tile a WSI with semantic segmentation label masks created from
-    DSA annotations.
-
-    Args:
-        wsi_fp (str): file path to WSI.
-        annotation_docs (list[dict]): list of annotation documents.
-        label2idx (dict): mapping of label names to integer indices.
-        save_dir (str): directory to save the tiled images.
-        tile_size (int): size of the tile images at desired magnificaiton.
-        mag (float | None, optional): magnification level of the WSI.
-            If None, the function will use the default magnification
-            level. Defaults to None.
-        prepend_name (str, optional): prepend name to the created tile
-            images and masks. Defaults to "".
-        nproc (int, optional): number of processes to use for tiling.
-
-    Returns:
-        list[str]: A list of tuples: (tile file path, x, y coordinates
-            of tile).
-
-    """
-    # Format annotation documents for drawing on tile masks.
-    contours = {idx: {"points": [], "holes": []} for idx in label2idx.values()}
-
-    for ann_doc in annotation_docs:
-        # Loop through the elements of the annotation document.
-        elements = ann_doc["annotation"].get("elements", [])
-
-        for element in elements:
-            # Check if element has a label.
-            label = element.get("label", {}).get("value")
-
-            if label not in label2idx:
-                # Skip this element if it is not in the label2idx mapping.
-                continue
-
-            idx = label2idx[label]
-
-            element_type = element["type"]
-
-            if element_type == "polyline":
-                points = element.get("points", [])
-
-                if len(points):
-                    contours[idx]["points"].append(
-                        np.array(points, dtype=int)[:, :2]
-                    )
-
-                holes = element.get("holes", [])
-
-                if len(holes):
-                    for hole in holes:
-                        contours[idx]["holes"].append(
-                            np.array(hole, dtype=int)[:, :2]
-                        )
-            elif element_type == "rectangle":
-                # Convert the rectangle coordinates to polygon ones.
-                x1, y1 = element["center"][:2]
-                x2 = x1 + element["width"]
-                y2 = y1 + element["height"]
-
-                contours[idx]["points"].append(
-                    np.array(
-                        [[x1, y1], [x2, y1], [x2, y2], [x1, y2]], dtype=int
-                    )
-                )
-
-    # Create directory to save tile images and masks.
-    save_dir = Path(save_dir)
-    img_dir = save_dir / "images"
-    mask_dir = save_dir / "masks"
-    img_dir.mkdir(parents=True, exist_ok=True)
-    mask_dir.mkdir(exist_ok=True)
-
-    # Get the tile source of WSI.
-    ts = large_image.getTileSource(str(wsi_fp))
-
-    # Get the metadata of the WSI.
-    metadata = ts.getMetadata()
-
-    wsi_w, wsi_h = metadata["sizeX"], metadata["sizeY"]
-
-    # Get the magnification of the WSI.
-    wsi_mag = metadata["magnification"]
-
-    # Calculate the tile size at full resolution (1 if mag is None or the same as scan mag).
-    if mag is None:
-        scan_tile_size = tile_size
-        mag = wsi_mag
-        sf = 1
-    else:
-        sf = mag / wsi_mag  # scan mag -> desired mag
-        scan_tile_size = int(tile_size / sf)
-
-    # Get a list of x,y coordinates for the tile top left corners.
-    xys = [
-        (x, y)
-        for x in range(0, wsi_w, scan_tile_size)
-        for y in range(0, wsi_h, scan_tile_size)
-    ]
-
-    with Pool(nproc) as pool:
-        jobs = [
-            pool.apply_async(
-                _process_tile,
-                (
-                    ts,
-                    prepend_name,
-                    xy[0],
-                    xy[1],
-                    scan_tile_size,
-                    tile_size,
-                    mag,
-                    contours,
-                    sf,
-                    img_dir,
-                    mask_dir,
-                ),
-            )
-            for xy in xys
-        ]
-
-        tile_info = []
-
-        for job in tqdm(jobs, desc="Tiling..."):
-            tile_info.append(job.get())
-
-        return tile_info