| """Mathematical helpers for masks, calibration, and volume estimation.""" |
|
|
| from __future__ import annotations |
|
|
| import math |
| from typing import Sequence |
|
|
| import numpy as np |
|
|
|
|
| def mask_iou(a: np.ndarray, b: np.ndarray) -> float: |
| """Return intersection-over-union for two binary masks.""" |
|
|
| a_bool = np.asarray(a).astype(bool) |
| b_bool = np.asarray(b).astype(bool) |
| intersection = np.logical_and(a_bool, b_bool).sum() |
| union = np.logical_or(a_bool, b_bool).sum() |
| return float(intersection) / float(union) if union else 0.0 |
|
|
|
|
| def bbox_iou(a: Sequence[float], b: Sequence[float]) -> float: |
| """Return intersection-over-union for two ``[x1, y1, x2, y2]`` boxes.""" |
|
|
| ax1, ay1, ax2, ay2 = map(float, a) |
| bx1, by1, bx2, by2 = map(float, b) |
| ix1, iy1 = max(ax1, bx1), max(ay1, by1) |
| ix2, iy2 = min(ax2, bx2), min(ay2, by2) |
| iw, ih = max(0.0, ix2 - ix1), max(0.0, iy2 - iy1) |
| inter = iw * ih |
| area_a = max(0.0, ax2 - ax1) * max(0.0, ay2 - ay1) |
| area_b = max(0.0, bx2 - bx1) * max(0.0, by2 - by1) |
| union = area_a + area_b - inter |
| return inter / union if union else 0.0 |
|
|
|
|
| def polygon_area(points: np.ndarray) -> float: |
| """Return polygon area in pixel units using the shoelace formula.""" |
|
|
| if points is None or len(points) < 3: |
| return 0.0 |
| pts = np.asarray(points, dtype=np.float64) |
| x = pts[:, 0] |
| y = pts[:, 1] |
| return float(abs(np.dot(x, np.roll(y, -1)) - np.dot(y, np.roll(x, -1))) / 2.0) |
|
|
|
|
| def cm_per_pixel_from_real_width(real_width_cm: float, width_pixels: float) -> float: |
| """Convert a known real-world width and pixel width into cm-per-pixel.""" |
|
|
| if width_pixels <= 0: |
| raise ValueError("width_pixels must be positive") |
| return float(real_width_cm) / float(width_pixels) |
|
|
|
|
| def area_cm2_per_pixel(cm_per_pixel: float) -> float: |
| """Return square centimeters represented by one image pixel.""" |
|
|
| if cm_per_pixel <= 0: |
| raise ValueError("cm_per_pixel must be positive") |
| return float(cm_per_pixel) ** 2 |
|
|
|
|
| def cylinder_volume_cm3(radius_cm: float, height_cm: float) -> float: |
| """Return cylinder volume in cubic centimeters.""" |
|
|
| return math.pi * max(radius_cm, 0.0) ** 2 * max(height_cm, 0.0) |
|
|
|
|
| def solid_volume_cm3(mask_area_cm2: float, height_cm: float) -> float: |
| """Return prism-like solid volume in cubic centimeters.""" |
|
|
| return max(mask_area_cm2, 0.0) * max(height_cm, 0.0) |
|
|
|
|
| def soft_clamp(value: float, minimum: float, maximum: float) -> float: |
| """Clamp low values hard, reduce high outliers smoothly. |
| Examples: |
| soft_clamp(100, 50, 200) -> 100 (within range, unchanged) |
| soft_clamp(10, 50, 200) -> 50 (below min, hard floor) |
| soft_clamp(500, 50, 200) -> ~280 (above max, smoothly reduced) |
| soft_clamp(900, 50, 200) -> ~320 (far above max, asymptotes to 320) |
| """ |
|
|
| value = float(value) |
| minimum = float(minimum) |
| maximum = float(maximum) |
| if maximum < minimum: |
| minimum, maximum = maximum, minimum |
| if value < minimum: |
| return minimum |
| if value <= maximum: |
| return value |
|
|
| soft_top = maximum * 1.6 |
| excess = value - maximum |
| squashed = maximum + (soft_top - maximum) * (1.0 - math.exp(-excess / max(maximum, 1.0))) |
| return float(min(squashed, soft_top)) |
|
|
|
|
| def robust_percentile(values: np.ndarray, percentile: float, default: float = 0.0) -> float: |
| """Return a percentile while tolerating empty and non-finite arrays.""" |
|
|
| arr = np.asarray(values, dtype=np.float32) |
| arr = arr[np.isfinite(arr)] |
| if arr.size == 0: |
| return float(default) |
| return float(np.percentile(arr, percentile)) |
|
|
