| import cv2 |
| import numpy as np |
| from PIL import Image, ImageDraw |
|
|
| MAGENTA = (255, 0, 255) |
|
|
|
|
| def stroke_width_for(img): |
| short = min(img.size) |
| return max(3, min(7, int(round(np.random.default_rng().uniform(0.004, 0.010) * short)))) |
|
|
|
|
| def _contours(mask): |
| m = (mask.astype(np.uint8) * 255) if mask.dtype == bool else mask |
| cs, _ = cv2.findContours(m, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) |
| return cs |
|
|
|
|
| def _smooth(poly, rng, amp): |
| |
| if len(poly) < 4: |
| return poly |
| p = poly.astype(np.float64) |
| n = len(p) |
| k = max(2, n // 12) |
| phase = rng.uniform(0, 2 * np.pi) |
| t = np.arange(n) |
| tang = np.gradient(p, axis=0) |
| nrm = tang / (np.linalg.norm(tang, axis=1, keepdims=True) + 1e-6) |
| nrm = np.stack([-nrm[:, 1], nrm[:, 0]], axis=1) |
| off = (amp * np.sin(2 * np.pi * t / k + phase))[:, None] * nrm |
| return (p + off).astype(np.int32) |
|
|
|
|
| def outline_polyline(mask, rng): |
| cs = _contours(mask) |
| if not cs: |
| return None |
| c = max(cs, key=cv2.contourArea) |
| if len(c) < 8: |
| return None |
| eps = rng.uniform(0.002, 0.006) * cv2.arcLength(c, True) |
| poly = cv2.approxPolyDP(c, eps, True).reshape(-1, 2) |
| short = min(mask.shape[:2]) |
| poly = _smooth(poly, rng, amp=rng.uniform(0.005, 0.02) * short) |
| segs = [np.stack([poly[i], poly[i + 1]]) for i in range(len(poly) - 1)] |
| if len(segs) > 2 and rng.random() < 0.5: |
| for _ in range(rng.integers(0, 3)): |
| i = int(rng.integers(0, len(segs))) |
| segs.pop(i) |
| if len(segs) < 2: |
| break |
| for seg in segs: |
| d = seg[-1] - seg[0] |
| L = max(float(np.hypot(d[0], d[1])), 1e-6) |
| u = d / L |
| e = rng.uniform(0.0, 0.015) * short |
| if rng.random() < 0.4: |
| seg[0] = (seg[0] - u * e).astype(seg.dtype) |
| if rng.random() < 0.4: |
| seg[-1] = (seg[-1] + u * e).astype(seg.dtype) |
| return segs |
|
|
|
|
| def interior_strokes(mask, gray, rng, max_strokes=4): |
| H, W = mask.shape[:2] |
| short = min(H, W) |
| k = max(3, int(0.03 * short) | 1) |
| er = cv2.erode(mask.astype(np.uint8) * 255, np.ones((k, k), np.uint8)) |
| edges = cv2.Canny(cv2.GaussianBlur(gray, (3, 3), 0), 40, 120) |
| edges[er == 0] = 0 |
| n, lbl = cv2.connectedComponents((edges > 0).astype(np.uint8), connectivity=8) |
| comps = [np.stack(np.where(lbl == i), axis=1) for i in range(1, n)] |
| comps = [c for c in comps if len(c) >= 8] |
| comps.sort(key=len, reverse=True) |
| strokes = [] |
| for c in comps[: int(rng.integers(1, max_strokes + 1))]: |
| pts = c[np.linspace(0, len(c) - 1, min(len(c), 40)).astype(int)] |
| pts = _smooth(pts.astype(np.int32), rng, amp=rng.uniform(0.004, 0.012) * short) |
| strokes.append(pts) |
| return strokes |
|
|
|
|
| def blob_polyline(mask, rng): |
| cs = _contours(mask) |
| if not cs: |
| return None |
| pts = np.vstack([c.reshape(-1, 2) for c in cs]).astype(np.float64) |
| hull = cv2.convexHull(pts.astype(np.int32)).reshape(-1, 2) |
| cx, cy = pts.mean(axis=0) |
| if len(hull) < 6: |
| return None |
| ang = np.arctan2(hull[:, 1] - cy, hull[:, 0] - cx) |
| rad = np.hypot(hull[:, 1] - cy, hull[:, 0] - cx) |
| o = np.argsort(ang) |
| ang, rad = ang[o], rad[o] |
| ang_s = np.linspace(-np.pi, np.pi, 28)[:-1] |
| ang_ext = np.concatenate([ang, ang[:1] + 2 * np.pi]) |
| rad_s = np.interp(ang_s, ang_ext, np.concatenate([rad, rad[:1]])) |
| short = min(mask.shape[:2]) |
| rad_s = rad_s * rng.uniform(0.92, 1.06) + rng.normal(0, 0.008 * short, rad_s.shape) |
| return [np.stack([cx + rad_s * np.cos(ang_s), |
| cy + rad_s * np.sin(ang_s)], axis=1).astype(np.int32)] |
|
|
|
|
| def make_scribble(mask, gray, style, rng): |
| if style == 'outline': |
| pl = outline_polyline(mask, rng) |
| return ([pl] if pl else []) or (blob_polyline(mask, rng) or []) |
| if style == 'detailed': |
| pl = outline_polyline(mask, rng) |
| ins = interior_strokes(mask, gray, rng) |
| return ([pl] if pl else []) + ins |
| if style == 'blob': |
| return blob_polyline(mask, rng) or outline_polyline(mask, rng) or [] |
| raise ValueError(style) |
|
|
|
|
| def draw_scribble(image, polylines, width, color=MAGENTA): |
| d = ImageDraw.Draw(image) |
| for pl in polylines: |
| if isinstance(pl, np.ndarray): |
| pl = [pl] |
| for chain in pl: |
| pts = [tuple(int(v) for v in p) for p in chain.reshape(-1, 2)] |
| if len(pts) >= 2: |
| d.line(pts, fill=color, width=width, joint='curve') |
| r = width / 2.0 |
| for p in (pts[0], pts[-1]): |
| d.ellipse([p[0] - r, p[1] - r, p[0] + r, p[1] + r], fill=color) |
| return image |
|
|
