File size: 9,090 Bytes
12d2e9e |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 |
"""
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
|