Spaces:
Paused
Paused
Download models/wrinkle_detector.py from TechAvenger/ClothIron: direct link, hf CLI and curl.
- Browser
- Download file 10.2 kB
-
https://huggingface.co/spaces/TechAvenger/ClothIron/resolve/main/models/wrinkle_detector.py
- Command line
-
hf download hf://spaces/TechAvenger/ClothIron/models/wrinkle_detector.py
-
curl -L -o wrinkle_detector.py https://huggingface.co/spaces/TechAvenger/ClothIron/resolve/main/models/wrinkle_detector.py
10.2 kB
| """ | |
| Wrinkle Detection Module | |
| Detects wrinkles, creases, and fabric deformation using multi-scale | |
| edge analysis + a lightweight CNN classifier. | |
| """ | |
| from __future__ import annotations | |
| import os | |
| import cv2 | |
| import numpy as np | |
| from PIL import Image | |
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| # ββ Lightweight wrinkle-scoring CNN ββββββββββββββββββββββββββββββββββββββββββ | |
| class WrinkleCNN(nn.Module): | |
| """ | |
| Small encoder that produces a per-pixel wrinkle probability map. | |
| Input : 3 Γ H Γ W (RGB, normalised) | |
| Output: 1 Γ H Γ W (probability 0-1) | |
| """ | |
| def __init__(self): | |
| super().__init__() | |
| self.enc1 = self._block(3, 32) | |
| self.enc2 = self._block(32, 64) | |
| self.enc3 = self._block(64, 128) | |
| self.dec2 = self._block(128 + 64, 64) | |
| self.dec1 = self._block(64 + 32, 32) | |
| self.head = nn.Conv2d(32, 1, 1) | |
| def _block(in_c, out_c): | |
| return nn.Sequential( | |
| nn.Conv2d(in_c, out_c, 3, padding=1, bias=False), | |
| nn.BatchNorm2d(out_c), | |
| nn.ReLU(inplace=True), | |
| nn.Conv2d(out_c, out_c, 3, padding=1, bias=False), | |
| nn.BatchNorm2d(out_c), | |
| nn.ReLU(inplace=True), | |
| ) | |
| def forward(self, x): | |
| e1 = self.enc1(x) | |
| e2 = self.enc2(F.avg_pool2d(e1, 2)) | |
| e3 = self.enc3(F.avg_pool2d(e2, 2)) | |
| d2 = F.interpolate(e3, scale_factor=2, mode="bilinear", align_corners=False) | |
| d2 = self.dec2(torch.cat([d2, e2], dim=1)) | |
| d1 = F.interpolate(d2, scale_factor=2, mode="bilinear", align_corners=False) | |
| d1 = self.dec1(torch.cat([d1, e1], dim=1)) | |
| return torch.sigmoid(self.head(d1)) | |
| # ββ Main detector class βββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| class WrinkleDetector: | |
| """ | |
| Combines classical edge/texture cues with optional CNN refinement. | |
| """ | |
| WRINKLE_MODEL_HF = os.getenv("WRINKLE_MODEL_HF") | |
| def __init__(self, device: str | None = None, use_cnn: bool = True): | |
| self.device = device or ("cuda" if torch.cuda.is_available() else "cpu") | |
| self.use_cnn = use_cnn | |
| self._cnn = None | |
| if use_cnn: | |
| self._init_cnn() | |
| # ββ init ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def _init_cnn(self): | |
| if not self.WRINKLE_MODEL_HF: | |
| print("[WrinkleDetector] No CNN repository configured; using classical detection.") | |
| self._cnn = None | |
| return | |
| self._cnn = WrinkleCNN().to(self.device).eval() | |
| # Attempt to load pre-trained weights; silently fall back to random init | |
| # (random-init will still work because we blend with classical cues) | |
| try: | |
| from huggingface_hub import hf_hub_download | |
| path = hf_hub_download(self.WRINKLE_MODEL_HF, "wrinkle_cnn.pth") | |
| state = torch.load(path, map_location=self.device) | |
| self._cnn.load_state_dict(state) | |
| print("[WrinkleDetector] Loaded CNN weights from HF Hub.") | |
| except Exception: | |
| print("[WrinkleDetector] No pre-trained CNN weights found; using classical detection only.") | |
| self._cnn = None | |
| # ββ public ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def detect( | |
| self, | |
| image: Image.Image, | |
| garment_mask: np.ndarray, | |
| ) -> dict: | |
| """ | |
| Returns | |
| ------- | |
| dict with keys: | |
| wrinkle_map β HΓW float32 [0,1], 1 = strong wrinkle | |
| wrinkle_score β scalar 0-100 | |
| zones β list of zone dicts {name, score, bbox} | |
| """ | |
| arr = np.array(image.convert("RGB")) | |
| h, w = arr.shape[:2] | |
| # ββ classical multi-scale wrinkle map ββββββββββββββββββββββββββββββββ | |
| classical = self._classical_map(arr, garment_mask) | |
| # ββ optional CNN refinement βββββββββββββββββββββββββββββββββββββββββββ | |
| if self._cnn is not None: | |
| cnn_map = self._cnn_map(arr, garment_mask) | |
| wrinkle_map = 0.4 * classical + 0.6 * cnn_map | |
| else: | |
| wrinkle_map = classical | |
| # apply garment mask | |
| wrinkle_map = wrinkle_map * garment_mask.astype(float) | |
| # global score | |
| garment_pixels = garment_mask.sum() | |
| score = 0.0 | |
| if garment_pixels > 0: | |
| score = float((wrinkle_map[garment_mask] > 0.3).sum()) / garment_pixels * 100.0 | |
| score = min(score * 1.3, 100.0) # scale to perceptible range | |
| # zone analysis | |
| zones = self._zone_analysis(wrinkle_map, garment_mask, h, w) | |
| return { | |
| "wrinkle_map": wrinkle_map.astype(np.float32), | |
| "wrinkle_score": round(score, 1), | |
| "zones": zones, | |
| } | |
| # ββ classical detection βββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def _classical_map(arr: np.ndarray, mask: np.ndarray) -> np.ndarray: | |
| if not mask.any(): | |
| return np.zeros(mask.shape, dtype=np.float32) | |
| lab = cv2.cvtColor(arr, cv2.COLOR_RGB2LAB).astype(np.float32) | |
| lum, a, b = lab[..., 0], lab[..., 1], lab[..., 2] | |
| # Wrinkles appear as thin dark/bright ridges and local luminance bands. | |
| ridge = np.zeros(mask.shape, dtype=np.float32) | |
| lum_u8 = lum.astype(np.uint8) | |
| for size in (5, 9, 15): | |
| kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (size, size)) | |
| dark = cv2.morphologyEx(lum_u8, cv2.MORPH_BLACKHAT, kernel) | |
| bright = cv2.morphologyEx(lum_u8, cv2.MORPH_TOPHAT, kernel) | |
| ridge = np.maximum(ridge, np.maximum(dark, bright).astype(np.float32)) | |
| # Difference-of-Gaussians adds broader wrinkle shading that morphology | |
| # alone can miss. | |
| fine = cv2.GaussianBlur(lum, (0, 0), 1.0) | |
| medium = cv2.GaussianBlur(lum, (0, 0), 5.0) | |
| broad = cv2.GaussianBlur(lum, (0, 0), 13.0) | |
| bands = 0.65 * np.abs(fine - medium) + 0.35 * np.abs(medium - broad) | |
| combined = 0.65 * ridge + 0.35 * bands | |
| # Colored boundaries are more likely logos/patterns than wrinkles. | |
| chroma_edge = np.hypot(_gradient_magnitude(a), _gradient_magnitude(b)) | |
| chroma_scale = _robust_scale(chroma_edge, mask, 65, 98.5) | |
| combined *= 1.0 - 0.75 * chroma_scale | |
| # Exclude the garment contour, which was a major source of false | |
| # wrinkle detections in the previous Canny-based implementation. | |
| eroded = cv2.erode(mask.astype(np.uint8), np.ones((5, 5), np.uint8), iterations=1) | |
| combined *= eroded.astype(np.float32) | |
| combined = _robust_scale(combined, eroded.astype(bool), 45, 99) | |
| return cv2.GaussianBlur(combined, (0, 0), 1.2).astype(np.float32) | |
| # ββ CNN path βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def _cnn_map(self, arr: np.ndarray, mask: np.ndarray) -> np.ndarray: | |
| h, w = arr.shape[:2] | |
| tensor = torch.from_numpy(arr).permute(2, 0, 1).float() / 255.0 | |
| tensor = tensor.unsqueeze(0).to(self.device) | |
| with torch.no_grad(): | |
| out = self._cnn(tensor) # 1Γ1ΓHΓW | |
| prob = out.squeeze().cpu().numpy() | |
| if prob.shape != (h, w): | |
| prob = cv2.resize(prob, (w, h), interpolation=cv2.INTER_LINEAR) | |
| return prob | |
| # ββ zone analysis βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def _zone_analysis( | |
| wrinkle_map: np.ndarray, | |
| garment_mask: np.ndarray, | |
| h: int, w: int, | |
| ) -> list[dict]: | |
| zones_def = { | |
| "shoulder region": (0, h // 4), | |
| "chest / torso": (h // 4, h // 2), | |
| "mid-body": (h // 2, 3 * h // 4), | |
| "lower body": (3 * h // 4, h), | |
| } | |
| results = [] | |
| for name, (y0, y1) in zones_def.items(): | |
| zone_mask = garment_mask[y0:y1, :] | |
| zone_wrinkle = wrinkle_map[y0:y1, :] | |
| n_px = zone_mask.sum() | |
| if n_px == 0: | |
| continue | |
| score = float(zone_wrinkle[zone_mask > 0].mean()) if n_px > 0 else 0.0 | |
| results.append({ | |
| "name": name, | |
| "score": round(score * 100, 1), | |
| "bbox": (0, y0, w, y1), | |
| "level": "high" if score > 0.45 else ("medium" if score > 0.25 else "low"), | |
| }) | |
| results.sort(key=lambda x: x["score"], reverse=True) | |
| return results | |
| def _gradient_magnitude(channel: np.ndarray) -> np.ndarray: | |
| gx = cv2.Sobel(channel, cv2.CV_32F, 1, 0, ksize=3) | |
| gy = cv2.Sobel(channel, cv2.CV_32F, 0, 1, ksize=3) | |
| return cv2.magnitude(gx, gy) | |
| def _robust_scale( | |
| values: np.ndarray, | |
| mask: np.ndarray, | |
| low_percentile: float, | |
| high_percentile: float, | |
| ) -> np.ndarray: | |
| selected = values[mask] | |
| if not selected.size: | |
| return np.zeros_like(values, dtype=np.float32) | |
| low, high = np.percentile(selected, (low_percentile, high_percentile)) | |
| if high <= low + 1e-6: | |
| return np.zeros_like(values, dtype=np.float32) | |
| return np.clip((values - low) / (high - low), 0.0, 1.0).astype(np.float32) | |