data/pathml/graph/utils.py

"""
Copyright 2021, Dana-Farber Cancer Institute and Weill Cornell Medicine
License: GNU GPL 2.0
"""

import math

import numpy as np
import torch
from skimage.measure import label, regionprops
from torch_geometric.data import Data
from torch_geometric.utils import remove_self_loops, to_edge_index, to_torch_csr_tensor

MIN_NR_PIXELS = 50000
MAX_NR_PIXELS = 50000000


class Graph(Data):
    """Constructs pytorch-geometric data object for saving and loading

    Args:
        node_centroids (torch.tensor): Coordinates of the centers of each entity (cell or tissue) in the graph
        node_features (torch.tensor): Computed features of each entity (cell or tissue) in the graph
        edge_index (torch.tensor): Edge index in sparse format between nodes in the graph
        node_labels  (torch.tensor): Node labels of each entity (cell or tissue) in the graph. Defaults to None.
        target (torch.tensor): Target label if used in a supervised setting. Defaults to None.
    """

    def __init__(
        self,
        node_centroids,
        edge_index,
        node_features=None,
        node_labels=None,
        edge_features=None,
        target=None,
    ):
        super().__init__()
        self.node_centroids = node_centroids
        self.node_features = node_features
        self.edge_index = edge_index
        self.node_labels = node_labels
        self.target = target
        self.edge_features = edge_features

    def __inc__(self, key, value, *args, **kwargs):
        if key == "edge_index":
            return self.node_centroids.size(0)
        elif key == "target":
            return 0
        else:
            return super().__inc__(key, value, *args, **kwargs)


class HACTPairData(Data):
    """Constructs pytorch-geometric data object for handling both cell and tissue data.

    Args:
        x_cell (torch.tensor): Computed features of each cell in the graph
        edge_index_cell (torch.tensor): Edge index in sparse format between nodes in the cell graph
        x_tissue (torch.tensor): Computed features of each tissue in the graph
        edge_index_tissue (torch.tensor): Edge index in sparse format between nodes in the tissue graph
        assignment (torch.tensor): Assigment matrix that contains mapping between cells and tissues.
        target (torch.tensor): Target label if used in a supervised setting.

    References:
        Jaume, G., Pati, P., Anklin, V., Foncubierta, A. and Gabrani, M., 2021, September.
        Histocartography: A toolkit for graph analytics in digital pathology.
        In MICCAI Workshop on Computational Pathology (pp. 117-128). PMLR.
    """

    def __init__(
        self, x_cell, edge_index_cell, x_tissue, edge_index_tissue, assignment, target
    ):
        super().__init__()
        self.x_cell = x_cell
        self.edge_index_cell = edge_index_cell

        self.x_tissue = x_tissue
        self.edge_index_tissue = edge_index_tissue

        self.assignment = assignment
        self.target = target

    def __inc__(self, key, value, *args, **kwargs):
        if key == "edge_index_cell":
            return self.x_cell.size(0)
        if key == "edge_index_tissue":
            return self.x_tissue.size(0)
        elif key == "assignment":
            return self.x_tissue.size(0)
        elif key == "target":
            return 0
        else:
            return super().__inc__(key, value, *args, **kwargs)


def get_full_instance_map(wsi, patch_size, mask_name="cell"):
    """
    Generates and returns the normalized image, cell instance map and cell centroids from pathml SlideData object

    Args:
        wsi (pathml.core.SlideData): Normalized WSI object with detected cells in the 'masks' slot
        patch_size (int): Patch size used for cell detection
        mask_name (str): Name of the mask slot storing the detected cells. Defaults to 'cell'.

    Returns:
        The image in np.unint8 format, the instance map for the entity and the instance centroids for each entity in
        the instance map as numpy arrays.
    """

    x = math.ceil(wsi.shape[0] / patch_size) * patch_size
    y = math.ceil(wsi.shape[1] / patch_size) * patch_size
    image_norm = np.zeros((x, y, 3))
    instance_map = np.zeros((x, y))
    for tile in wsi.tiles:
        tx, ty = tile.coords
        image_norm[tx : tx + patch_size, ty : ty + patch_size] = tile.image
        instance_map[tx : tx + patch_size, ty : ty + patch_size] = np.squeeze(
            tile.masks[mask_name]
        )[:, :]
    image_norm = image_norm[: wsi.shape[0], : wsi.shape[1], :]
    instance_map = instance_map[: wsi.shape[0], : wsi.shape[1]]
    label_instance_map = label(instance_map)
    regions = regionprops(label_instance_map)
    instance_centroids = np.empty((len(regions), 2))
    for i, region in enumerate(regions):
        center_y, center_x = region.centroid  # row, col
        center_x = int(round(center_x))
        center_y = int(round(center_y))
        instance_centroids[i, 0] = center_x
        instance_centroids[i, 1] = center_y
    return image_norm.astype("uint8"), label_instance_map, instance_centroids


def build_assignment_matrix(low_level_centroids, high_level_map, matrix=False):
    """
    Builds an assignment matrix/mapping between low-level centroid locations and a high-level segmentation map

    Args:
        low_level_centroids (numpy.array): The low-level centroid coordinates in x-y plane
        high-level map (numpy.array): The high-level map returned from regionprops
        matrix (bool): Whether to return in a matrix format. If True, returns a N*L matrix where N is the number of low-level
            instances and L is the number of high-level instances. If False, returns this mapping in sparse format.
            Defaults to False.

    Returns:
        The assignment matrix as a numpy array.

    References:
        [1] https://github.com/BiomedSciAI/histocartography/tree/main
        [2] Jaume, G., Pati, P., Anklin, V., Foncubierta, A. and Gabrani, M., 2021, September.
        Histocartography: A toolkit for graph analytics in digital pathology.
        In MICCAI Workshop on Computational Pathology (pp. 117-128). PMLR.
    """

    low_level_centroids = low_level_centroids.astype(int)
    low_to_high = high_level_map[
        low_level_centroids[:, 1], low_level_centroids[:, 0]
    ].astype(int)
    high_instance_ids = np.sort(np.unique(np.ravel(high_level_map))).astype(int)
    if 0 in high_instance_ids:
        high_instance_ids = np.delete(high_instance_ids, 0)
    assignment_matrix = np.zeros((low_level_centroids.shape[0], len(high_instance_ids)))
    assignment_matrix[np.arange(low_to_high.size), low_to_high - 1] = 1
    if not matrix:
        sparse_matrix = np.nonzero(assignment_matrix)
        return np.array(sparse_matrix)
    return assignment_matrix


def two_hop(edge_index, num_nodes):
    """Calculates the two-hop graph.
    Args:
        edge_index (torch.tensor): The edge index in sparse form of the graph.
        num_nodes (int): maximum number of nodes.

    Returns:
        torch.tensor: Output edge index tensor.

    References:
        [1] https://github.com/BiomedSciAI/histocartography/tree/main
        [2] Jaume, G., Pati, P., Anklin, V., Foncubierta, A. and Gabrani, M., 2021, September.
        Histocartography: A toolkit for graph analytics in digital pathology.
        In MICCAI Workshop on Computational Pathology (pp. 117-128). PMLR.
    """
    adj = to_torch_csr_tensor(edge_index, size=(num_nodes, num_nodes))
    try:
        edge_index2, _ = to_edge_index(adj @ adj)
        edge_index2, _ = remove_self_loops(edge_index2)
        edge_index = torch.cat([edge_index, edge_index2], dim=1)
    except RuntimeError as e:  # pragma: no cover
        print(e, "Computing two-hop graph manually")
        edge_index = two_hop_no_sparse(edge_index, num_nodes)
    return edge_index


def two_hop_no_sparse(edge_index, num_nodes):  # pragma: no cover
    """Calculates the two-hop graph without using sparse tensors, in case of M1/M2 chips.
    Args:
        edge_index (torch.tensor): The edge index in sparse form of the graph (2, E)
        num_nodes (int): maximum number of nodes.
    Returns:
        torch.tensor: Output edge index tensor.
    """
    # Initialize an empty list to store the two-hop edges
    two_hop_edges = []

    # Convert edge_index tensor to a list of tuples (edges)
    edges = edge_index.t().tolist()

    # Iterate over all pairs of nodes
    for src, dest in edges:
        # First hop: Add direct edges
        two_hop_edges.append([src, dest])

        # Second hop: Find all neighbors of the destination node
        for neighbor in range(num_nodes):
            # Check if the neighbor is connected to the destination node
            if [dest, neighbor] in edges:
                # Avoid self-loops
                if neighbor != src:
                    two_hop_edges.append([src, neighbor])

    # Convert the list of two-hop edges to a PyTorch tensor
    edge_index_two_hop = torch.tensor(two_hop_edges).t().contiguous()

    return edge_index_two_hop