| """Quality metrics for dense and post-processed contours.""" |
|
|
| from __future__ import annotations |
|
|
| import math |
|
|
| import numpy as np |
|
|
| from .geometry import rasterize_contour, strip_duplicate_endpoint, xy_to_physical |
| from .types import ContourQualityMetrics, PixelSpacing |
|
|
|
|
| def symmetric_boundary_distances(reference: np.ndarray, candidate: np.ndarray) -> np.ndarray: |
| reference = strip_duplicate_endpoint(reference) |
| candidate = strip_duplicate_endpoint(candidate) |
| if len(reference) == 0 or len(candidate) == 0: |
| return np.asarray([math.inf], dtype=np.float64) |
| try: |
| from scipy.spatial import cKDTree |
|
|
| forward = cKDTree(candidate).query(reference)[0] |
| reverse = cKDTree(reference).query(candidate)[0] |
| except Exception: |
| forward = np.linalg.norm( |
| reference[:, None, :] - candidate[None, :, :], axis=2 |
| ).min(axis=1) |
| reverse = np.linalg.norm( |
| candidate[:, None, :] - reference[None, :, :], axis=2 |
| ).min(axis=1) |
| return np.concatenate([forward, reverse]).astype(np.float64) |
|
|
|
|
| def contour_roughness(points: np.ndarray) -> float: |
| points = strip_duplicate_endpoint(points) |
| if len(points) < 4: |
| return 0.0 |
| previous = np.roll(points, 1, axis=0) |
| following = np.roll(points, -1, axis=0) |
| second_difference = following - 2.0 * points + previous |
| perimeter = float(np.linalg.norm(following - points, axis=1).sum()) |
| if perimeter <= 1e-12: |
| return 0.0 |
| return float(np.linalg.norm(second_difference, axis=1).sum() / perimeter) |
|
|
|
|
| def contour_quality_metrics( |
| dense_xy: np.ndarray, |
| smooth_xy: np.ndarray, |
| shape: tuple[int, int], |
| pixel_spacing: PixelSpacing, |
| control_point_count: int, |
| ) -> tuple[ContourQualityMetrics, np.ndarray]: |
| dense_mask = rasterize_contour(dense_xy, shape) |
| rendered_mask = rasterize_contour(smooth_xy, shape) |
| intersection = int(np.logical_and(dense_mask, rendered_mask).sum()) |
| union = int(np.logical_or(dense_mask, rendered_mask).sum()) |
| source_area = int(dense_mask.sum()) |
| rendered_area = int(rendered_mask.sum()) |
| distances = symmetric_boundary_distances( |
| xy_to_physical(dense_xy, pixel_spacing), |
| xy_to_physical(smooth_xy, pixel_spacing), |
| ) |
| source_roughness = contour_roughness(xy_to_physical(dense_xy, pixel_spacing)) |
| rendered_roughness = contour_roughness(xy_to_physical(smooth_xy, pixel_spacing)) |
| metrics = ContourQualityMetrics( |
| control_point_count=int(control_point_count), |
| boundary_mean_mm=float(np.mean(distances)), |
| boundary_p95_mm=float(np.percentile(distances, 95)), |
| boundary_max_mm=float(np.max(distances)), |
| mask_iou=float(intersection / union) if union else 0.0, |
| source_area_px=source_area, |
| rendered_area_px=rendered_area, |
| area_change_pct=( |
| float(100.0 * (rendered_area - source_area) / source_area) |
| if source_area |
| else math.inf |
| ), |
| roughness_ratio=( |
| float(rendered_roughness / source_roughness) if source_roughness > 0 else 0.0 |
| ), |
| ) |
| return metrics, rendered_mask |
|
|
