btxrd-workstation / src /models /postprocessing.py
amitaddi
feat: deploy bone tumor segmentation workstation
1bd13a5
Raw History Blame Contribute Delete
7.23 kB
"""
Post-Processing Module for Bone Tumor Segmentation Masks.
Provides:
- Dense CRF refinement using image intensity gradients
- Morphological refinement (closing + opening)
- Combined pipeline for maximum boundary accuracy
These post-processing steps are applied after SAM2 inference
to sharpen mask boundaries, especially in low-contrast X-ray regions.
"""
import numpy as np
import cv2
from typing import Optional, Tuple
def morphological_refine(mask: np.ndarray,
close_kernel: int = 7,
open_kernel: int = 5,
fill_holes: bool = True) -> np.ndarray:
"""
Morphological refinement of a binary segmentation mask.
Applies closing (fill small gaps) followed by opening (remove noise),
then optionally fills interior holes.
Args:
mask: (H, W) binary mask (uint8, 0/1)
close_kernel: Kernel size for morphological closing
open_kernel: Kernel size for morphological opening
fill_holes: Whether to fill interior holes
Returns:
Refined binary mask (H, W), uint8
"""
mask_binary = (mask > 0).astype(np.uint8) * 255
# Closing: fills small gaps and connects nearby regions
k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (close_kernel, close_kernel))
closed = cv2.morphologyEx(mask_binary, cv2.MORPH_CLOSE, k_close)
# Opening: removes small noise blobs
k_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (open_kernel, open_kernel))
opened = cv2.morphologyEx(closed, cv2.MORPH_OPEN, k_open)
if fill_holes:
# Flood fill from corners to find exterior, then invert
h, w = opened.shape
flood = opened.copy()
flood_mask = np.zeros((h + 2, w + 2), dtype=np.uint8)
cv2.floodFill(flood, flood_mask, (0, 0), 255)
holes = cv2.bitwise_not(flood)
opened = cv2.bitwise_or(opened, holes)
return (opened > 127).astype(np.uint8)
def crf_refine(image: np.ndarray,
mask_prob: np.ndarray,
n_iterations: int = 5,
sxy_gauss: int = 3,
compat_gauss: int = 3,
sxy_bilateral: int = 80,
srgb_bilateral: int = 13,
compat_bilateral: int = 10) -> np.ndarray:
"""
Dense CRF refinement using image appearance.
Uses pydensecrf to refine mask boundaries using both spatial
smoothness and image intensity information, particularly effective
on X-rays where bone-tissue transitions are gradual.
Args:
image: (H, W, 3) RGB image, uint8
mask_prob: (H, W) mask probability [0, 1] or binary {0, 1}
n_iterations: CRF inference iterations
sxy_gauss: Spatial sigma for appearance-independent smoothness
compat_gauss: Compatibility for Gaussian kernel
sxy_bilateral: Spatial sigma for bilateral kernel
srgb_bilateral: Color sigma for bilateral kernel
compat_bilateral: Compatibility for bilateral kernel
Returns:
Refined binary mask (H, W), uint8
"""
try:
import pydensecrf.densecrf as dcrf
from pydensecrf.utils import unary_from_softmax
except ImportError:
print("[PostProcess] pydensecrf not installed, falling back to morphological refinement")
return morphological_refine((mask_prob > 0.5).astype(np.uint8))
h, w = mask_prob.shape
# Ensure mask_prob is float in [0, 1]
if mask_prob.max() > 1:
mask_prob = mask_prob.astype(np.float32) / 255.0
# Create 2-class softmax input (background, foreground)
prob_fg = np.clip(mask_prob, 0.001, 0.999).astype(np.float32)
prob_bg = 1.0 - prob_fg
probs = np.stack([prob_bg, prob_fg], axis=0) # (2, H, W)
# Create CRF
d = dcrf.DenseCRF2D(w, h, 2)
# Unary potentials from softmax probabilities
unary = unary_from_softmax(probs)
d.setUnaryEnergy(unary)
# Pairwise Gaussian (spatial smoothness)
d.addPairwiseGaussian(sxy=sxy_gauss, compat=compat_gauss)
# Pairwise bilateral (appearance-aware smoothness)
img_for_crf = np.ascontiguousarray(image[:, :, :3].astype(np.uint8))
d.addPairwiseBilateral(
sxy=sxy_bilateral,
srgb=srgb_bilateral,
rgbim=img_for_crf,
compat=compat_bilateral
)
# Inference
Q = d.inference(n_iterations)
result = np.argmax(Q, axis=0).reshape(h, w)
return result.astype(np.uint8)
def box_blend_refine(mask: np.ndarray, box: tuple, alpha: float = 0.0) -> np.ndarray:
"""
Refine a binary mask by blending it with the bounding box rectangle.
Useful for weakly annotated rectangular ground truth datasets.
Args:
mask: (H, W) binary mask (uint8)
box: (x1, y1, x2, y2) bounding box in pixel coordinates
alpha: Weight of the rectangular box prior [0.0, 1.0]
Returns:
Refined binary mask (H, W), uint8
"""
if alpha <= 0.0:
return mask
h, w = mask.shape
box_mask = np.zeros((h, w), dtype=np.float32)
x1, y1, x2, y2 = box
# Clamp bounding box coordinates to image dimensions
x1, y1 = max(0, int(x1)), max(0, int(y1))
x2, y2 = min(w - 1, int(x2)), min(h - 1, int(y2))
box_mask[y1:y2+1, x1:x2+1] = 1.0
blended = (1.0 - alpha) * mask.astype(np.float32) + alpha * box_mask
return (blended > 0.5).astype(np.uint8)
def refine_mask(image: np.ndarray,
mask: np.ndarray,
use_crf: bool = True,
use_morphology: bool = True,
box: Optional[Tuple[int, int, int, int]] = None,
box_blend_alpha: float = 0.0) -> np.ndarray:
"""
Combined post-processing pipeline.
Applies CRF refinement, morphological cleanup, and optional BBox Prior Fusion.
Args:
image: (H, W, 3) RGB image
mask: (H, W) binary mask or probability map
use_crf: Apply CRF refinement
use_morphology: Apply morphological cleanup
box: Bounding box for prior fusion
box_blend_alpha: Weight of the rectangular box prior
Returns:
Refined binary mask (H, W), uint8
"""
result = mask.copy()
if use_crf:
result = crf_refine(image, result.astype(np.float32))
if use_morphology:
result = morphological_refine(result)
if box is not None and box_blend_alpha > 0.0:
result = box_blend_refine(result, box, alpha=box_blend_alpha)
return result
if __name__ == '__main__':
# Quick test
print("Testing post-processing module...")
# Synthetic noisy mask
mask = np.zeros((256, 256), dtype=np.uint8)
rr, cc = np.ogrid[:256, :256]
mask[((rr - 128)**2 + (cc - 128)**2) < 60**2] = 1
# Add noise
noise = np.random.random((256, 256)) > 0.95
mask_noisy = np.clip(mask + noise.astype(np.uint8), 0, 1)
# Morphological refinement
refined = morphological_refine(mask_noisy)
print(f" Original area: {mask.sum()}")
print(f" Noisy area: {mask_noisy.sum()}")
print(f" Refined area: {refined.sum()}")
print(" Done!")