File size: 7,414 Bytes
4a2938a | 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 | """
Utility functions for preprocessing, TTA inference, postprocessing,
visualization, and Kaggle RLE formatting.
"""
import cv2
import numpy as np
import torch
from PIL import Image
IMG_H = 128
IMG_W = 800
NORM_MEAN = 0.449
NORM_STD = 0.226
CLASS_NAMES = ["defect_a", "defect_b", "defect_c", "defect_d"]
CLASS_LABELS = {
"defect_a": "Defect A (Pitted / Scratch)",
"defect_b": "Defect B (Minor defect)",
"defect_c": "Defect C (Inclusion / Slag)",
"defect_d": "Defect D (Surface patch / Scuff)"
}
# Color palette for classes (R, G, B)
CLASS_COLORS = [
(255, 60, 60), # Defect A: Red
(50, 220, 50), # Defect B: Green
(30, 150, 255), # Defect C: Cyan-Blue
(255, 180, 20) # Defect D: Orange-Gold
]
# Calibrated optimal thresholds & min component areas from notebook
DEFAULT_THRESHOLDS = [0.35, 0.22, 0.42, 0.42]
DEFAULT_MIN_AREAS = [25, 25, 220, 350]
def rle_encode(mask):
"""
1-indexed, column-major (Fortran) Run-Length Encoding.
Matches the official Kaggle competition format.
"""
mask = np.asarray(mask)
if mask.ndim != 2:
raise ValueError(f"rle_encode expects a 2D mask, got shape {mask.shape}")
pixels = np.concatenate([[0], (mask > 0).astype(np.uint8).flatten(order="F"), [0]])
runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
runs[1::2] -= runs[::2]
return " ".join(map(str, runs))
def rle_decode(rle, shape=(IMG_H, IMG_W)):
"""Decodes 1-indexed column-major RLE string back to 2D numpy mask."""
total = int(shape[0] * shape[1])
flat = np.zeros(total, dtype=np.uint8)
if not isinstance(rle, str) or not rle.strip():
return flat.reshape(shape, order="F")
nums = np.asarray(rle.split(), dtype=np.int64)
if nums.size % 2:
return flat.reshape(shape, order="F")
starts = nums[0::2] - 1
lengths = nums[1::2]
for start, length in zip(starts, lengths):
end = min(int(start + length), total)
if 0 <= start < total:
flat[int(start):end] = 1
return flat.reshape(shape, order="F")
def filter_small_components(mask, min_area):
"""Removes 8-connected components smaller than min_area pixels."""
if min_area <= 1 or not mask.any():
return mask
mask_u8 = mask.astype(np.uint8)
count, labels, stats, _ = cv2.connectedComponentsWithStats(mask_u8, connectivity=8)
if count <= 1:
return np.zeros_like(mask, dtype=bool)
keep = np.flatnonzero(stats[:, cv2.CC_STAT_AREA] >= min_area)
keep = keep[keep != 0] # exclude background (0)
return np.isin(labels, keep)
def preprocess_image(input_img):
"""
Prepares input image for model:
- Converts to Grayscale
- Resizes to (IMG_H=128, IMG_W=800)
- Normalizes with dataset mean & std
Returns:
tensor: shape (1, 1, 128, 800)
display_rgb: numpy uint8 (128, 800, 3) for overlay rendering
"""
if isinstance(input_img, str):
gray = cv2.imread(input_img, cv2.IMREAD_GRAYSCALE)
elif isinstance(input_img, np.ndarray):
if input_img.ndim == 3:
gray = cv2.cvtColor(input_img, cv2.COLOR_RGB2GRAY)
else:
gray = input_img.copy()
elif isinstance(input_img, Image.Image):
gray = np.array(input_img.convert("L"))
else:
raise ValueError("Unsupported image input format.")
if gray.shape != (IMG_H, IMG_W):
gray = cv2.resize(gray, (IMG_W, IMG_H), interpolation=cv2.INTER_AREA)
norm_img = gray.astype(np.float32) / 255.0
norm_img = (norm_img - NORM_MEAN) / NORM_STD
tensor = torch.from_numpy(norm_img).unsqueeze(0).unsqueeze(0) # (1, 1, 128, 800)
display_rgb = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
return tensor, display_rgb
@torch.no_grad()
def predict_with_tta(model, tensor_x, tta=True, device="cpu"):
"""
Inference with optional 4-view Test-Time Augmentation (flips).
Returns numpy probability array of shape (4, 128, 800) with values in [0, 1].
"""
model.eval()
tensor_x = tensor_x.to(device)
probs = torch.sigmoid(model(tensor_x).float())
if tta:
# 4-view flip TTA: original, hflip, vflip, hvflip
for dims in ([3], [2], [2, 3]):
flipped_in = torch.flip(tensor_x, dims)
flipped_pred = torch.sigmoid(model(flipped_in).float())
probs = probs + torch.flip(flipped_pred, dims)
probs = probs / 4.0
return probs.squeeze(0).cpu().numpy()
def apply_postprocess(probs_np, thresholds=None, min_areas=None):
"""
Applies calibrated probability thresholds and minimum connected component areas.
"""
if thresholds is None:
thresholds = DEFAULT_THRESHOLDS
if min_areas is None:
min_areas = DEFAULT_MIN_AREAS
n_cls = probs_np.shape[0]
masks = np.zeros_like(probs_np, dtype=bool)
for c in range(n_cls):
th = float(thresholds[c])
area = int(min_areas[c])
raw_mask = probs_np[c] >= th
masks[c] = filter_small_components(raw_mask, area)
return masks
def create_segmentation_overlay(base_rgb, masks, alpha=0.55):
"""
Overlays colored semi-transparent defect masks and clear contour borders onto base image.
"""
overlay = base_rgb.copy().astype(np.float32)
for c, mask in enumerate(masks):
if not mask.any():
continue
color = np.array(CLASS_COLORS[c], dtype=np.float32)
# Apply semi-transparent fill
idx = mask > 0
overlay[idx] = (1 - alpha) * overlay[idx] + alpha * color
overlay = np.clip(overlay, 0, 255).astype(np.uint8)
# Draw sharp contour borders on top for precision visibility
for c, mask in enumerate(masks):
if not mask.any():
continue
mask_u8 = mask.astype(np.uint8)
contours, _ = cv2.findContours(mask_u8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
color = CLASS_COLORS[c]
cv2.drawContours(overlay, contours, -1, color, 1)
return overlay
def compute_defect_diagnostics(masks, display_shape=(IMG_H, IMG_W)):
"""
Computes per-class analytics:
- Detection boolean
- Component count
- Total pixel area
- Coverage percentage
- RLE encoding string
"""
total_canvas_pixels = float(display_shape[0] * display_shape[1])
diagnostics = []
has_any_defect = False
for c, name in enumerate(CLASS_NAMES):
mask = masks[c]
is_detected = bool(mask.any())
if is_detected:
has_any_defect = True
count, _, stats, _ = cv2.connectedComponentsWithStats(mask.astype(np.uint8), connectivity=8)
comp_count = max(0, count - 1)
area_px = int(mask.sum())
area_pct = round(100.0 * (area_px / total_canvas_pixels), 3)
rle_str = rle_encode(mask)
else:
comp_count = 0
area_px = 0
area_pct = 0.0
rle_str = ""
diagnostics.append({
"Class Name": name,
"Label": CLASS_LABELS[name],
"Detected": "YES" if is_detected else "NO",
"Components": comp_count,
"Area (px)": area_px,
"Surface %": f"{area_pct}%",
"RLE Encoded": (rle_str[:60] + "...") if len(rle_str) > 60 else (rle_str or "EMPTY")
})
overall_status = "DEFECT DETECTED" if has_any_defect else "CLEAN / NO DEFECT"
return diagnostics, overall_status
|