Download test_simplify.py from histopathai/SICAPV2-Converter: direct link, hf CLI and curl.
- Browser
- Download file 8.42 kB
-
https://huggingface.co/datasets/histopathai/SICAPV2-Converter/resolve/main/test_simplify.py
- Command line
-
hf download hf://datasets/histopathai/SICAPV2-Converter/test_simplify.py
-
curl -L -o test_simplify.py https://huggingface.co/datasets/histopathai/SICAPV2-Converter/resolve/main/test_simplify.py
8.42 kB
| """ | |
| Polygon seyreltme karşılaştırma testi. | |
| Kullanım: | |
| python test_simplify.py | |
| python test_simplify.py --epsilon 3.0 --max-points 30 | |
| """ | |
| import argparse | |
| import json | |
| import random | |
| import sys | |
| from pathlib import Path | |
| import cv2 | |
| import matplotlib.patches as mpatches | |
| import matplotlib.pyplot as plt | |
| import numpy as np | |
| from matplotlib.patches import Polygon as MplPolygon | |
| from scipy.ndimage import gaussian_filter1d | |
| from scipy.signal import find_peaks | |
| BASE = Path(__file__).parent / "SICAPv2" | |
| MASKS_DIR = BASE / "masks" | |
| IMGS_DIR = BASE / "images" | |
| GRADE_RANGES = [(30, 80, "G3"), (80, 125, "G4"), (125, 256, "G5")] | |
| GRADE_COLORS = {"G3": "#00cc44", "G4": "#ff8800", "G5": "#ff2222"} | |
| MERGE_DIST = 20 | |
| MIN_AREA = 100 | |
| # --------------------------------------------------------------------------- | |
| # Kalibrasyon (extract_polygons'tan kopyalandı) | |
| # --------------------------------------------------------------------------- | |
| def grade_for_value(val): | |
| for lo, hi, grade in GRADE_RANGES: | |
| if lo <= val < hi: | |
| return grade | |
| return None | |
| def calibrate(gray): | |
| hist = np.bincount(gray.ravel(), minlength=256).astype(float) | |
| smooth = gaussian_filter1d(hist[8:], sigma=2) | |
| min_h = max(smooth.max() * 0.02, 5) | |
| idxs, _ = find_peaks(smooth, height=min_h, distance=10, prominence=min_h * 0.3) | |
| peaks = sorted([(int(i + 8), int(hist[i + 8])) for i in idxs]) | |
| merged = [] | |
| for val, cnt in peaks: | |
| if merged and val - merged[-1][0] <= MERGE_DIST: | |
| merged[-1] = (val, cnt) if cnt > merged[-1][1] else merged[-1] | |
| else: | |
| merged.append((val, cnt)) | |
| grade_map = {} | |
| for val, _ in merged: | |
| g = grade_for_value(val) | |
| if g and g not in grade_map.values(): | |
| grade_map[val] = g | |
| return grade_map | |
| def quantize(gray, centers): | |
| q = np.zeros_like(gray, dtype=np.int32) | |
| all_c = sorted([0] + list(centers)) | |
| for i in range(1, len(all_c)): | |
| c = all_c[i] | |
| lo = (all_c[i - 1] + c) // 2 | |
| hi = (all_c[i + 1] + c) // 2 if i + 1 < len(all_c) else 256 | |
| q[(gray >= lo) & (gray < hi)] = c | |
| return q | |
| def remove_small(binary): | |
| n, labels, stats, _ = cv2.connectedComponentsWithStats(binary, connectivity=8) | |
| clean = np.zeros_like(binary) | |
| for lid in range(1, n): | |
| if stats[lid, cv2.CC_STAT_AREA] >= MIN_AREA: | |
| clean[labels == lid] = 1 | |
| return clean | |
| # --------------------------------------------------------------------------- | |
| # İki farklı polygon çıkarma yöntemi | |
| # --------------------------------------------------------------------------- | |
| def extract_original(cnt): | |
| """Mevcut yöntem: epsilon=0.5""" | |
| approx = cv2.approxPolyDP(cnt, 0.5, closed=True) | |
| if len(approx) < 3: | |
| return None | |
| pts = [[int(p[0][0]), int(p[0][1])] for p in approx] | |
| pts.append(pts[0]) | |
| return pts | |
| def extract_simplified(cnt, epsilon_start=1.0, max_points=80): | |
| """Yeni yöntem: başlangıç epsilon yüksek + adaptif seyreltme.""" | |
| approx = cv2.approxPolyDP(cnt, epsilon_start, closed=True) | |
| arr = approx.astype(np.float32) | |
| eps = epsilon_start | |
| while len(arr) > max_points and eps <= 20: | |
| eps *= 1.5 | |
| arr = cv2.approxPolyDP(arr, eps, closed=True).astype(np.float32) | |
| if len(arr) < 3: | |
| return None | |
| pts = [[int(p[0][0]), int(p[0][1])] for p in arr] | |
| pts.append(pts[0]) | |
| return pts | |
| # --------------------------------------------------------------------------- | |
| # Tek patch işleme | |
| # --------------------------------------------------------------------------- | |
| def process_mask(mask_path, epsilon_start, max_points): | |
| gray = cv2.imread(str(mask_path), cv2.IMREAD_GRAYSCALE) | |
| if gray is None: | |
| return None, None | |
| gray_clean = cv2.medianBlur(gray, 5) | |
| grade_map = calibrate(gray_clean) | |
| if not grade_map: | |
| return None, None | |
| q = quantize(gray_clean, list(grade_map.keys())) | |
| orig_polys, simp_polys = [], [] | |
| for center, label in grade_map.items(): | |
| binary = (q == center).astype(np.uint8) | |
| binary = remove_small(binary) | |
| if binary.sum() == 0: | |
| continue | |
| cnts, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) | |
| for cnt in cnts: | |
| if cv2.contourArea(cnt) < MIN_AREA: | |
| continue | |
| op = extract_original(cnt) | |
| sp = extract_simplified(cnt, epsilon_start, max_points) | |
| if op: | |
| orig_polys.append((label, op)) | |
| if sp: | |
| simp_polys.append((label, sp)) | |
| return orig_polys, simp_polys | |
| # --------------------------------------------------------------------------- | |
| # Çizim | |
| # --------------------------------------------------------------------------- | |
| def draw_polys(ax, image, polys, title, alpha=0.35): | |
| ax.imshow(image) | |
| ax.set_title(title, fontsize=9) | |
| ax.axis("off") | |
| legend = {} | |
| for label, pts in polys: | |
| color = GRADE_COLORS.get(label, "#ffffff") | |
| arr = np.array(pts[:-1]) | |
| patch = MplPolygon(arr, closed=True, facecolor=color, | |
| alpha=alpha, edgecolor=color, linewidth=1.5) | |
| ax.add_patch(patch) | |
| if label not in legend: | |
| legend[label] = mpatches.Patch(color=color, label=label) | |
| if legend: | |
| ax.legend(handles=list(legend.values()), loc="upper right", | |
| fontsize=8, framealpha=0.7) | |
| def compare_patch(mask_path, epsilon_start, max_points): | |
| stem = mask_path.stem | |
| img_path = IMGS_DIR / mask_path.name | |
| image = cv2.cvtColor(cv2.imread(str(img_path)), cv2.COLOR_BGR2RGB) \ | |
| if img_path.exists() else np.zeros((512, 512, 3), dtype=np.uint8) | |
| mask_rgb = cv2.cvtColor(cv2.imread(str(mask_path)), cv2.COLOR_BGR2RGB) | |
| orig_polys, simp_polys = process_mask(mask_path, epsilon_start, max_points) | |
| if orig_polys is None: | |
| print(f" Kalibrasyon başarısız: {stem}") | |
| return | |
| orig_pts = sum(len(p) - 1 for _, p in orig_polys) | |
| simp_pts = sum(len(p) - 1 for _, p in simp_polys) | |
| reduction = (1 - simp_pts / orig_pts) * 100 if orig_pts else 0 | |
| fig, axes = plt.subplots(1, 4, figsize=(20, 5)) | |
| fig.suptitle(stem, fontsize=8, y=1.01) | |
| axes[0].imshow(mask_rgb) | |
| axes[0].set_title("Mask (ham)") | |
| axes[0].axis("off") | |
| axes[1].imshow(image) | |
| axes[1].set_title("Orijinal görüntü") | |
| axes[1].axis("off") | |
| draw_polys(axes[2], image, orig_polys, | |
| f"Mevcut (eps=0.5)\n{len(orig_polys)} poly {orig_pts} nokta") | |
| draw_polys(axes[3], image, simp_polys, | |
| f"Seyrelmiş (eps={epsilon_start}, max={max_points})\n" | |
| f"{len(simp_polys)} poly {simp_pts} nokta (-%{reduction:.0f})") | |
| plt.tight_layout() | |
| plt.savefig(f"simplify_test_{stem[:40]}.png", dpi=120, bbox_inches="tight") | |
| plt.show() | |
| print(f" {stem}") | |
| print(f" Mevcut : {len(orig_polys):3d} polygon {orig_pts:5d} nokta") | |
| print(f" Seyrelmiş: {len(simp_polys):3d} polygon {simp_pts:5d} nokta (-%{reduction:.1f})") | |
| # --------------------------------------------------------------------------- | |
| # Main | |
| # --------------------------------------------------------------------------- | |
| def main(): | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--epsilon", type=float, default=1.0) | |
| parser.add_argument("--max-points", type=int, default=50) | |
| parser.add_argument("--n", type=int, default=3, | |
| help="Kaç patch test edilsin") | |
| parser.add_argument("--seed", type=int, default=42) | |
| args = parser.parse_args() | |
| masks = sorted(MASKS_DIR.glob("*.jpg")) | |
| if not masks: | |
| sys.exit(f"Mask bulunamadı: {MASKS_DIR}") | |
| # Karmaşık polygon içerme ihtimali yüksek maskleri seç | |
| # (dosya boyutu büyük olanlar genellikle daha fazla içerik barındırır) | |
| masks_by_size = sorted(masks, key=lambda p: p.stat().st_size, reverse=True) | |
| candidates = masks_by_size[:50] | |
| random.seed(args.seed) | |
| selected = random.sample(candidates, min(args.n, len(candidates))) | |
| print(f"Test parametreleri: epsilon={args.epsilon} max_points={args.max_points}") | |
| print(f"Seçilen {len(selected)} patch:\n") | |
| for mp in selected: | |
| compare_patch(mp, args.epsilon, args.max_points) | |
| print("\nGörüntüler simplify_test_*.png olarak kaydedildi.") | |
| if __name__ == "__main__": | |
| main() | |