File size: 3,826 Bytes
5ed0011 | 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 | """Visualization utilities for disparity maps, depth maps, and error heatmaps."""
import numpy as np
import matplotlib.cm as cm
import cv2
from typing import Optional, Tuple
def colorize_disparity(
disp: np.ndarray,
cmap_name: str = 'plasma',
vmin: Optional[float] = None,
vmax: Optional[float] = None,
invalid_color: Tuple[int, int, int] = (0, 0, 0),
) -> np.ndarray:
"""Colorizes a 2D disparity map into an RGB uint8 image with robust dynamic range scaling.
Args:
disp: 2D float array of disparities.
cmap_name: Matplotlib colormap name ('plasma', 'turbo', 'viridis', 'magma').
vmin: Minimum value for colormap scaling. If None, computes robust lower percentile.
vmax: Maximum value for colormap scaling. If None, computes robust upper percentile.
invalid_color: RGB tuple for pixels where disp <= 0.
Returns:
RGB image as uint8 numpy array of shape (H, W, 3).
"""
valid_mask = (disp > 0) & np.isfinite(disp)
if not np.any(valid_mask):
return np.zeros((disp.shape[0], disp.shape[1], 3), dtype=np.uint8)
valid_vals = disp[valid_mask]
if vmin is None or vmax is None:
# Exclude outer frame margins (2.5%) when estimating dynamic range bounds
# to prevent boundary padding / edge extrapolation spikes from compressing colors
h, w = disp.shape[:2]
by = max(1, int(h * 0.025))
bx = max(1, int(w * 0.025))
if h > 2 * by and w > 2 * bx:
interior = disp[by : h - by, bx : w - bx]
interior_valid = interior[(interior > 0) & np.isfinite(interior)]
else:
interior_valid = np.array([], dtype=np.float32)
ref_vals = interior_valid if interior_valid.size > 200 else valid_vals
if vmin is None:
vmin = float(np.percentile(ref_vals, 2))
if vmax is None:
vmax = float(np.percentile(ref_vals, 98))
if vmax <= vmin:
vmax = vmin + 1.0
# Normalize between 0.0 and 1.0 with robust clipping
norm_disp = np.clip((disp - vmin) / (vmax - vmin), 0.0, 1.0)
# Apply colormap
try:
colormap = cm.get_cmap(cmap_name)
except Exception:
colormap = cm.plasma
rgba_img = colormap(norm_disp)
rgb_img = (rgba_img[:, :, :3] * 255).astype(np.uint8)
# Set invalid pixels to invalid_color
rgb_img[~valid_mask] = invalid_color
return rgb_img
def create_error_heatmap(
gt_disp: np.ndarray,
pred_disp: np.ndarray,
bad_threshold: float = 3.0,
max_error: float = 15.0,
) -> np.ndarray:
"""Generates an RGB error heatmap highlighting pixel errors.
Errors below bad_threshold (accurate matches) appear dark/cool.
Errors exceeding bad_threshold (bad pixels) transition through yellow to intense red.
Invalid ground-truth pixels are masked in gray.
Args:
gt_disp: Ground-truth disparity.
pred_disp: Predicted disparity.
bad_threshold: Bad pixel error threshold (default: 3.0 px).
max_error: Saturation point for the error scale in pixels.
Returns:
RGB uint8 image of shape (H, W, 3).
"""
if gt_disp.shape != pred_disp.shape:
pred_disp = cv2.resize(pred_disp, (gt_disp.shape[1], gt_disp.shape[0]), interpolation=cv2.INTER_LINEAR)
valid_mask = (gt_disp > 0) & np.isfinite(gt_disp)
error = np.abs(gt_disp - pred_disp)
# Normalize error to [0, 1]
norm_error = np.clip(error / max_error, 0.0, 1.0)
# Use 'turbo' or 'inferno' for high-contrast error rendering
colormap = cm.turbo
rgba = colormap(norm_error)
rgb = (rgba[:, :, :3] * 255).astype(np.uint8)
# Mask invalid ground truth areas with dark gray (40, 40, 40)
rgb[~valid_mask] = (40, 40, 40)
return rgb
|