""" Wallpaper simulator — POC v7. New in v7: - Walls picked dynamically: after each wall, choose Refine / Add wall / Done. - Auto-mask detects bright outliers (windows, lights) in addition to colour differences (furniture, pipes...). - Per-wall refinement window: brush (add/remove) + magic wand (flood-fill) to fix anything the auto-mask missed. - Density slider inverted (right = larger motif). """ import argparse import subprocess import sys from pathlib import Path import cv2 import numpy as np from PIL import Image, ImageOps CONFIG_WIN = "Configurez votre papier peint" def _put_text(img, text, org, scale=0.5, color=(30, 30, 30), thickness=1): cv2.putText(img, text, org, cv2.FONT_HERSHEY_SIMPLEX, scale, color, thickness, cv2.LINE_AA) def _filled_box(img, x1, y1, x2, y2, color, border=None): cv2.rectangle(img, (x1, y1), (x2, y2), color, -1) if border is not None: cv2.rectangle(img, (x1, y1), (x2, y2), border, 1) def config_dialog(default_width=300, default_height=250, default_density=40, density_min=10, density_max=100, pattern_name=""): """OpenCV-based dialog mimicking the wellpapers.com configurator card. Click ``-`` / ``+`` buttons or use keys w/W h/H to nudge the width and height by 10 cm (Shift / capital = +50). Drag the density slider or use the trackbar. Click 'CONFIGURER' / press Enter to confirm. """ W, H = 520, 440 state = { "width": int(default_width), "height": int(default_height), "density": int(default_density), "submitted": False, "cancelled": False, "dragging": False, } # Layout regions (x1, y1, x2, y2) R = { "w_minus": (30, 130, 60, 168), "w_plus": (180, 130, 210, 168), "h_minus": (260, 130, 290, 168), "h_plus": (410, 130, 440, 168), "slider": (30, 290, W - 30, 312), "cancel": (30, 370, 140, 410), "ok": (260, 370, W - 30, 410), } def hit(rect, x, y): x1, y1, x2, y2 = rect return x1 <= x <= x2 and y1 <= y <= y2 def slider_value_at(x): x1, _, x2, _ = R["slider"] x = max(x1, min(x2, x)) t = (x - x1) / max(1, x2 - x1) return int(round(density_min + t * (density_max - density_min))) def on_mouse(event, x, y, flags, param): if event == cv2.EVENT_LBUTTONDOWN: if hit(R["w_minus"], x, y): state["width"] = max(50, state["width"] - 10) elif hit(R["w_plus"], x, y): state["width"] = min(2000, state["width"] + 10) elif hit(R["h_minus"], x, y): state["height"] = max(50, state["height"] - 10) elif hit(R["h_plus"], x, y): state["height"] = min(1000, state["height"] + 10) elif hit(R["cancel"], x, y): state["cancelled"] = True elif hit(R["ok"], x, y): state["submitted"] = True elif hit(R["slider"], x, y) or (R["slider"][1] - 15 <= y <= R["slider"][3] + 15 and R["slider"][0] <= x <= R["slider"][2]): state["dragging"] = True state["density"] = slider_value_at(x) elif event == cv2.EVENT_MOUSEMOVE and state["dragging"]: state["density"] = slider_value_at(x) elif event == cv2.EVENT_LBUTTONUP: state["dragging"] = False def render(): img = np.full((H, W, 3), 250, dtype=np.uint8) _put_text(img, "CONFIGUREZ VOTRE PAPIER PEINT", (30, 30), scale=0.6, color=(20, 20, 20), thickness=2) if pattern_name: _put_text(img, pattern_name, (30, 52), scale=0.45, color=(120, 120, 120)) cv2.line(img, (30, 70), (W - 30, 70), (220, 220, 220), 1) _put_text(img, "Mesures", (30, 95), scale=0.55, color=(20, 20, 20), thickness=2) # Width box _filled_box(img, 20, 115, 220, 175, (255, 255, 255), (200, 200, 200)) _put_text(img, "LARGEUR (EN CM)", (28, 128), scale=0.36, color=(140, 140, 140)) _filled_box(img, *R["w_minus"], color=(230, 230, 230), border=(180, 180, 180)) _put_text(img, "-", (39, 158), scale=0.9, thickness=2) _put_text(img, str(state["width"]), (75, 162), scale=1.0, thickness=2, color=(20, 20, 20)) _filled_box(img, *R["w_plus"], color=(230, 230, 230), border=(180, 180, 180)) _put_text(img, "+", (188, 158), scale=0.9, thickness=2) # Height box _filled_box(img, 250, 115, 450, 175, (255, 255, 255), (200, 200, 200)) _put_text(img, "HAUTEUR (EN CM)", (258, 128), scale=0.36, color=(140, 140, 140)) _filled_box(img, *R["h_minus"], color=(230, 230, 230), border=(180, 180, 180)) _put_text(img, "-", (269, 158), scale=0.9, thickness=2) _put_text(img, str(state["height"]), (305, 162), scale=1.0, thickness=2, color=(20, 20, 20)) _filled_box(img, *R["h_plus"], color=(230, 230, 230), border=(180, 180, 180)) _put_text(img, "+", (418, 158), scale=0.9, thickness=2) area = (state["width"] * state["height"]) / 10000.0 _put_text(img, f"~{area:.1f} m2 (largeur x hauteur)", (30, 200), scale=0.43, color=(130, 130, 130)) cv2.line(img, (30, 220), (W - 30, 220), (220, 220, 220), 1) # Density slider _put_text(img, "Taille des motifs", (30, 248), scale=0.55, color=(20, 20, 20), thickness=2) _put_text(img, str(state["density"]), (30, 285), scale=1.2, thickness=3, color=(20, 20, 20)) sx1, sy, sx2, _ = R["slider"] cv2.line(img, (sx1, sy + 11), (sx2, sy + 11), (220, 220, 220), 5) t = int(sx1 + (state["density"] - density_min) / max(1, density_max - density_min) * (sx2 - sx1)) cv2.circle(img, (t, sy + 11), 11, (50, 210, 250), -1) cv2.circle(img, (t, sy + 11), 11, (180, 180, 180), 1) _put_text(img, f"min {density_min}", (sx1, sy + 38), scale=0.35, color=(150, 150, 150)) _put_text(img, f"max {density_max}", (sx2 - 50, sy + 38), scale=0.35, color=(150, 150, 150)) # Buttons _filled_box(img, *R["cancel"], color=(230, 230, 230), border=(180, 180, 180)) _put_text(img, "ANNULER", (50, 395), scale=0.5, thickness=2, color=(80, 80, 80)) _filled_box(img, *R["ok"], color=(20, 200, 250)) _put_text(img, "CONFIGURER (Enter)", (272, 395), scale=0.55, thickness=2, color=(20, 20, 20)) return img cv2.namedWindow(CONFIG_WIN, cv2.WINDOW_AUTOSIZE) cv2.setMouseCallback(CONFIG_WIN, on_mouse) while True: cv2.imshow(CONFIG_WIN, render()) key = cv2.waitKey(20) & 0xFF if state["submitted"] or key in (13, 10): cv2.destroyWindow(CONFIG_WIN) return {"width": state["width"], "height": state["height"], "density": state["density"], "submitted": True} if state["cancelled"] or key in (ord('q'), 27): cv2.destroyWindow(CONFIG_WIN) return None if key == ord('w'): state["width"] = max(50, state["width"] - 10) elif key == ord('W'): state["width"] = min(2000, state["width"] + 10) elif key == ord('h'): state["height"] = max(50, state["height"] - 10) elif key == ord('H'): state["height"] = min(1000, state["height"] + 10) elif key == ord('['): state["density"] = max(density_min, state["density"] - 1) elif key == ord(']'): state["density"] = min(density_max, state["density"] + 1) # ---------- I/O ---------- def load_image(path: Path) -> np.ndarray: with Image.open(path) as im: im = ImageOps.exif_transpose(im).convert("RGB") arr = np.array(im) return cv2.cvtColor(arr, cv2.COLOR_RGB2BGR) # ---------- Geometry / texture ---------- def build_texture(pattern_bgr, target_w, target_h, repeats_x, mode): if mode == "panoramic": return cv2.resize(pattern_bgr, (target_w, target_h), interpolation=cv2.INTER_AREA) ph, pw = pattern_bgr.shape[:2] tile_w = max(1, int(round(target_w / max(repeats_x, 0.01)))) tile_h = max(1, int(round(tile_w * ph / pw))) tile = cv2.resize(pattern_bgr, (tile_w, tile_h), interpolation=cv2.INTER_AREA) cols = int(np.ceil(target_w / tile_w)) rows = int(np.ceil(target_h / tile_h)) return np.tile(tile, (rows, cols, 1))[:target_h, :target_w] def quad_mask(shape_hw, quad): h, w = shape_hw m = np.zeros((h, w), np.uint8) cv2.fillConvexPoly(m, quad.astype(np.int32), 255) return m _SEG_MODEL = None _SEG_PROCESSOR = None _SEG_PRED_CACHE: dict = {} WALL_CLASSES = {0} # ADE20K class index for 'wall' def get_seg_model(): global _SEG_MODEL, _SEG_PROCESSOR if _SEG_MODEL is None: import torch # noqa: F401 from transformers import (SegformerImageProcessor, SegformerForSemanticSegmentation) name = "nvidia/segformer-b2-finetuned-ade-512-512" print(" Loading SegFormer ADE20K weights (~250 MB first time)...") _SEG_PROCESSOR = SegformerImageProcessor.from_pretrained(name) _SEG_MODEL = SegformerForSemanticSegmentation.from_pretrained(name) _SEG_MODEL.eval() return _SEG_MODEL, _SEG_PROCESSOR def semantic_predict(photo_bgr): """Per-pixel ADE20K class labels for the photo. Cached by array id().""" key = id(photo_bgr) if key in _SEG_PRED_CACHE: return _SEG_PRED_CACHE[key] import torch from PIL import Image mdl, proc = get_seg_model() rgb = cv2.cvtColor(photo_bgr, cv2.COLOR_BGR2RGB) pil = Image.fromarray(rgb) inputs = proc(images=pil, return_tensors="pt") with torch.no_grad(): out = mdl(**inputs) h, w = photo_bgr.shape[:2] ups = torch.nn.functional.interpolate(out.logits, size=(h, w), mode="bilinear", align_corners=False) pred = ups.argmax(dim=1)[0].cpu().numpy().astype(np.int32) _SEG_PRED_CACHE[key] = pred return pred def semantic_wall_mask(photo_bgr, q_mask): """Mask = pixels classified as 'wall' by SegFormer, clipped to the quad.""" try: pred = semantic_predict(photo_bgr) except Exception as e: print(f" SegFormer error: {e}") return None wall = np.isin(pred, list(WALL_CLASSES)).astype(np.uint8) * 255 return cv2.bitwise_and(wall, q_mask) _SAM_MODEL = None def get_sam_model(): global _SAM_MODEL if _SAM_MODEL is None: from ultralytics import SAM weights = Path(__file__).parent / "mobile_sam.pt" weights_arg = str(weights) if weights.exists() else "mobile_sam.pt" print(" Loading MobileSAM weights...") _SAM_MODEL = SAM(weights_arg) return _SAM_MODEL def _heuristic_wall_mask(photo_bgr, q_mask, chroma_threshold=18.0, brightness_factor=2.5, min_brightness_gap=30.0): """Quick rough wall mask: chroma + brightness rejection, no morphological cleanup. Used to seed SAM prompt points.""" lab = cv2.cvtColor(photo_bgr, cv2.COLOR_BGR2LAB).astype(np.float32) L = lab[..., 0] ab = lab[..., 1:3] eroded = cv2.erode(q_mask, np.ones((25, 25), np.uint8)) sample_region = eroded if (eroded > 0).any() else q_mask samp_ab = ab[sample_region > 0].reshape(-1, 2) samp_L = L[sample_region > 0] if samp_ab.size == 0: return q_mask.copy() ref_ab = np.median(samp_ab, axis=0) L_mean, L_std = float(samp_L.mean()), float(samp_L.std()) gap = max(min_brightness_gap, brightness_factor * L_std) delta_ab = np.linalg.norm(ab - ref_ab, axis=-1) reject = ((delta_ab >= chroma_threshold) | (L > L_mean + gap) | (L < L_mean - gap)) & (q_mask > 0) rough = cv2.bitwise_and(q_mask, np.where(reject, 0, 255).astype(np.uint8)) return rough def _sample_points(mask, n): """Sample n approximately uniformly distributed points where mask>0.""" ys, xs = np.where(mask > 0) if len(ys) == 0: return [] if len(ys) < n: n = len(ys) idx = np.linspace(0, len(ys) - 1, n).astype(int) return [[int(xs[i]), int(ys[i])] for i in idx] STRICTNESS_MAP = { 0: (0, 0), 1: (12, 4), 2: (25, 10), 3: (45, 18), 4: (70, 30), } def sam_wall_mask(photo_bgr, q_mask, n_pos=5, n_neg=5, strictness=2): """Segment the wall inside the quadrilateral using MobileSAM. Strategy: 1. Compute a rough wall mask via colour+brightness heuristics. 2. Sample POSITIVE points deep inside the rough wall. 3. Sample NEGATIVE points deep inside the rejected zone (windows, furniture, etc.). 4. Send both as a SINGLE bundled prompt to SAM; SAM returns one mask that respects both constraints. Intersect with the quad. """ if (q_mask > 0).sum() < 500: return None rough_wall = _heuristic_wall_mask(photo_bgr, q_mask) not_wall = ((q_mask > 0) & (rough_wall == 0)).astype(np.uint8) * 255 pos_region = cv2.erode(rough_wall, np.ones((25, 25), np.uint8)) if (pos_region > 0).sum() < 200: pos_region = rough_wall pos = _sample_points(pos_region, n_pos) if not pos: return None neg_region = cv2.erode(not_wall, np.ones((15, 15), np.uint8)) if (neg_region > 0).sum() > 200: neg = _sample_points(neg_region, n_neg) else: neg = [] points = pos + neg labels = [1] * len(pos) + [0] * len(neg) try: model = get_sam_model() results = model.predict(photo_bgr, points=[points], labels=[labels], verbose=False) except Exception as e: print(f" SAM error: {e}") return None if not results or results[0].masks is None: return None sam_mask = (results[0].masks.data[0].cpu().numpy() > 0.5).astype(np.uint8) * 255 h_q, w_q = q_mask.shape if sam_mask.shape != (h_q, w_q): sam_mask = cv2.resize(sam_mask, (w_q, h_q), interpolation=cv2.INTER_NEAREST) out = cv2.bitwise_and(sam_mask, q_mask) close_o, dilate_o = STRICTNESS_MAP.get(int(strictness), STRICTNESS_MAP[2]) return _post_process_mask(out, q_mask, close_obj=close_o, dilate_obj=dilate_o) def _post_process_mask(wall_mask, q_mask, close_obj=25, dilate_obj=10, min_wall_blob_ratio=0.003): """Make object/window rejection sturdier: - close small holes in the rejected region (gaps between window bars, store slats, etc.) - dilate object contours to cover edge bleed - drop tiny isolated wall islands stranded inside an object """ quad_area = int((q_mask > 0).sum()) if quad_area == 0: return wall_mask not_wall = ((q_mask > 0) & (wall_mask == 0)).astype(np.uint8) * 255 if (not_wall > 0).any(): if close_obj > 0: k = np.ones((close_obj, close_obj), np.uint8) not_wall = cv2.morphologyEx(not_wall, cv2.MORPH_CLOSE, k) if dilate_obj > 0: k = np.ones((dilate_obj, dilate_obj), np.uint8) not_wall = cv2.dilate(not_wall, k) not_wall = cv2.bitwise_and(not_wall, q_mask) refined = cv2.bitwise_and(q_mask, cv2.bitwise_not(not_wall)) n_lbl, lbls, stats, _ = cv2.connectedComponentsWithStats(refined, connectivity=8) min_blob = max(500, int(min_wall_blob_ratio * quad_area)) out = np.zeros_like(refined) for i in range(1, n_lbl): if stats[i, cv2.CC_STAT_AREA] >= min_blob: out[lbls == i] = 255 return out def grabcut_refine(photo_bgr, q_mask, current_mask, max_dim=700, iters=3): """Refine the mask via GrabCut. GrabCut uses the photo's color GMM + smoothness term to snap the mask to actual image edges. Pixels currently marked wall are 'probable foreground', rejected pixels inside the quad are 'probable background', outside the quad is sure background. """ if (q_mask > 0).sum() < 1000: return current_mask h, w = photo_bgr.shape[:2] scale = min(1.0, max_dim / max(h, w)) if scale < 1: photo_s = cv2.resize(photo_bgr, None, fx=scale, fy=scale) q_s = cv2.resize(q_mask, (photo_s.shape[1], photo_s.shape[0]), interpolation=cv2.INTER_NEAREST) cur_s = cv2.resize(current_mask, (photo_s.shape[1], photo_s.shape[0]), interpolation=cv2.INTER_NEAREST) else: photo_s, q_s, cur_s = photo_bgr, q_mask, current_mask gc_mask = np.full(photo_s.shape[:2], cv2.GC_BGD, dtype=np.uint8) inside = q_s > 0 gc_mask[inside] = cv2.GC_PR_BGD gc_mask[inside & (cur_s > 0)] = cv2.GC_PR_FGD n_fg = int((gc_mask == cv2.GC_PR_FGD).sum()) n_bg = int((gc_mask == cv2.GC_PR_BGD).sum()) if n_fg < 200 or n_bg < 200: return current_mask bgd = np.zeros((1, 65), np.float64) fgd = np.zeros((1, 65), np.float64) try: cv2.grabCut(photo_s, gc_mask, None, bgd, fgd, iters, cv2.GC_INIT_WITH_MASK) except cv2.error: return current_mask refined = np.where((gc_mask == cv2.GC_FGD) | (gc_mask == cv2.GC_PR_FGD), 255, 0).astype(np.uint8) if scale < 1: refined = cv2.resize(refined, (w, h), interpolation=cv2.INTER_NEAREST) return cv2.bitwise_and(refined, q_mask) def occlusion_mask(photo_bgr, q_mask, chroma_threshold, min_object_ratio=0.004, brightness_factor=2.5, min_brightness_gap=35.0, use_grabcut=False, use_sam=True, use_semantic=True, strictness=2): close_o, dilate_o = STRICTNESS_MAP.get(int(strictness), STRICTNESS_MAP[2]) if use_semantic: m = semantic_wall_mask(photo_bgr, q_mask) if m is not None and (m > 0).sum() > 500: return _post_process_mask(m, q_mask, close_obj=close_o, dilate_obj=dilate_o) print(" SegFormer gave no valid mask, falling back to SAM.") if use_sam: m = sam_wall_mask(photo_bgr, q_mask, strictness=strictness) if m is not None and (m > 0).sum() > 500: return m print(" SAM gave no valid mask, falling back to heuristics.") """Quadrilateral minus furniture/windows. Rejection rules inside the quad: 1. Chromaticity (a, b) far from wall median -> furniture, pipes... 2. Luminance (L) far from wall mean -> windows, lights, dark holes. Only LARGE connected rejection blobs are kept; small specks fold back in. """ lab = cv2.cvtColor(photo_bgr, cv2.COLOR_BGR2LAB).astype(np.float32) L = lab[..., 0] ab = lab[..., 1:3] eroded = cv2.erode(q_mask, np.ones((25, 25), np.uint8)) sample_region = eroded if (eroded > 0).any() else q_mask samples_ab = ab[sample_region > 0].reshape(-1, 2) samples_L = L[sample_region > 0] if samples_ab.size == 0: return q_mask ref_ab = np.median(samples_ab, axis=0) delta_ab = np.linalg.norm(ab - ref_ab, axis=-1) L_mean = float(samples_L.mean()) L_std = float(samples_L.std()) L_gap = max(min_brightness_gap, brightness_factor * L_std) chroma_off = delta_ab >= chroma_threshold bright_off = L > (L_mean + L_gap) dark_off = L < (L_mean - L_gap) reject = ((chroma_off | bright_off | dark_off) & (q_mask > 0)).astype(np.uint8) * 255 reject = cv2.morphologyEx(reject, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8)) quad_area = int((q_mask > 0).sum()) min_area = max(200, int(min_object_ratio * quad_area)) n_lbl, labels, stats, _ = cv2.connectedComponentsWithStats(reject, connectivity=8) big_reject = np.zeros_like(reject) for i in range(1, n_lbl): if stats[i, cv2.CC_STAT_AREA] >= min_area: big_reject[labels == i] = 255 big_reject = cv2.dilate(big_reject, np.ones((3, 3), np.uint8), iterations=1) mask = cv2.bitwise_and(q_mask, cv2.bitwise_not(big_reject)) mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((11, 11), np.uint8), iterations=2) if use_grabcut: mask = grabcut_refine(photo_bgr, q_mask, mask) mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8)) return mask def transfer_shading(photo_bgr, warped_bgr, wall_mask, strength): if strength <= 0: return warped_bgr lab = cv2.cvtColor(photo_bgr, cv2.COLOR_BGR2LAB).astype(np.float32) L = lab[..., 0] inside = wall_mask > 0 if not inside.any(): return warped_bgr L_mean = max(float(L[inside].mean()), 1e-3) shading = (L / L_mean).clip(0.3, 1.8) shading = 1.0 + (shading - 1.0) * strength warped_lab = cv2.cvtColor(warped_bgr, cv2.COLOR_BGR2LAB).astype(np.float32) warped_lab[..., 0] = (warped_lab[..., 0] * shading).clip(0, 255) return cv2.cvtColor(warped_lab.astype(np.uint8), cv2.COLOR_LAB2BGR) def apply_wallpaper_on_quad(photo, canvas, quad, pattern, *, mode, repeats, shading_strength, feather, chroma_threshold, auto_mask, precomputed_mask=None): tl, tr, br, bl = quad rect_w = max(int(round(max(np.linalg.norm(tr - tl), np.linalg.norm(br - bl)))), 2) rect_h = max(int(round(max(np.linalg.norm(bl - tl), np.linalg.norm(br - tr)))), 2) texture = build_texture(pattern, rect_w, rect_h, repeats, mode) src = np.array([[0, 0], [rect_w-1, 0], [rect_w-1, rect_h-1], [0, rect_h-1]], dtype=np.float32) H = cv2.getPerspectiveTransform(src, quad.astype(np.float32)) h_img, w_img = photo.shape[:2] warped = cv2.warpPerspective(texture, H, (w_img, h_img), flags=cv2.INTER_LINEAR) q = quad_mask((h_img, w_img), quad) if precomputed_mask is not None: mask = precomputed_mask elif auto_mask: mask = occlusion_mask(photo, q, chroma_threshold) else: mask = q shaded = transfer_shading(photo, warped, mask, shading_strength) if feather > 0: k = feather * 2 + 1 mask_f = cv2.GaussianBlur(mask, (k, k), 0) else: mask_f = mask alpha = (mask_f.astype(np.float32) / 255.0)[..., None] out = shaded.astype(np.float32) * alpha + canvas.astype(np.float32) * (1 - alpha) return out.clip(0, 255).astype(np.uint8), mask def render_all(photo, walls, pattern, *, mode, repeats=None, density=None, shading_strength=0.85, feather=2, chroma_threshold=14, auto_mask=True): """Render wallpaper on each wall. For tile mode: each wall has its own ``width_cm`` and we compute ``repeats_w = width_cm / density``. If ``density`` is None, fall back to the global ``repeats``. """ canvas = photo.copy() masks_dbg = np.zeros(photo.shape[:2], np.uint8) for entry in walls: quad = entry["quad"] pre = entry.get("mask") if mode == "tile" and density is not None and entry.get("width_cm"): wall_repeats = max(0.1, entry["width_cm"] / density) else: wall_repeats = repeats if repeats is not None else 4.0 canvas, m = apply_wallpaper_on_quad( photo, canvas, quad, pattern, mode=mode, repeats=wall_repeats, shading_strength=shading_strength, feather=feather, chroma_threshold=chroma_threshold, auto_mask=auto_mask, precomputed_mask=pre, ) masks_dbg = np.maximum(masks_dbg, m) return canvas, masks_dbg # ---------- Picker helpers ---------- PICKER_WIN = "Wallpaper Sim" def _btn(img, x1, y1, x2, y2, color, label, hot=True): cv2.rectangle(img, (x1, y1), (x2, y2), color, -1) if not hot: overlay = img.copy() cv2.rectangle(overlay, (x1, y1), (x2, y2), (50, 50, 50), -1) img[y1:y2, x1:x2] = cv2.addWeighted(overlay[y1:y2, x1:x2], 0.5, img[y1:y2, x1:x2], 0.5, 0) (tw, th), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.8, 2) cv2.putText(img, label, (x1 + (x2 - x1 - tw) // 2, y1 + (y2 - y1 + th) // 2), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2) def _draw_walls(img, walls_disp, current=None, current_idx=None, total_walls=None): overlay = img.copy() for j, w in enumerate(walls_disp): poly = np.array(w, dtype=np.int32) cv2.fillPoly(overlay, [poly], (50, 50, 220)) cv2.polylines(img, [poly], True, (0, 0, 255), 3) c = poly.mean(axis=0).astype(int) cv2.putText(img, f"#{j+1}", tuple(c), cv2.FONT_HERSHEY_SIMPLEX, 1.6, (0, 0, 255), 5) if current: pts = np.array(current, dtype=np.int32) if len(current) >= 3: cv2.fillPoly(overlay, [pts], (60, 200, 60)) cv2.polylines(img, [pts], True, (0, 255, 0), 3) elif len(current) == 2: cv2.polylines(img, [pts], False, (0, 255, 0), 2) labels = ["TL", "TR", "BR", "BL"] for k, p in enumerate(current): cv2.circle(img, (int(p[0]), int(p[1])), 9, (0, 255, 0), -1) cv2.circle(img, (int(p[0]), int(p[1])), 9, (0, 0, 0), 2) cv2.putText(img, labels[k], (int(p[0]) + 12, int(p[1]) - 12), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 3) cv2.putText(img, labels[k], (int(p[0]) + 12, int(p[1]) - 12), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1) return cv2.addWeighted(overlay, 0.25, img, 0.75, 0) # ---------- Step 1: pick 4 corners of one wall ---------- def pick_corners(disp_base, walls_disp, wall_idx): """Return list of 4 (x, y) display-space tuples, or None if cancelled.""" current = [] validate = {"v": False} disp_h, disp_w = disp_base.shape[:2] BTN_H = 60 bx1, by1, bx2, by2 = 0, disp_h - BTN_H, disp_w, disp_h def on_mouse(event, x, y, flags, param): if event != cv2.EVENT_LBUTTONDOWN: return if bx1 <= x <= bx2 and by1 <= y <= by2: if len(current) == 4: validate["v"] = True return if len(current) < 4: current.append((x, y)) cv2.setMouseCallback(PICKER_WIN, on_mouse) while True: img = _draw_walls(disp_base.copy(), walls_disp, current=current) header = (f"Mur {wall_idx+1} - {len(current)}/4 points " "(u=undo r=reset q=quit)") cv2.rectangle(img, (0, 0), (img.shape[1], 50), (0, 0, 0), -1) cv2.putText(img, header, (10, 35), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 255, 255), 2) ready = len(current) == 4 _btn(img, bx1, by1, bx2, by2, (0, 170, 0) if ready else (90, 90, 90), "VALIDER LES 4 POINTS (Enter)" if ready else f"Place {4-len(current)} point(s) restant(s)", hot=ready) cv2.imshow(PICKER_WIN, img) key = cv2.waitKey(20) & 0xFF if validate["v"] and len(current) == 4: return current if key in (13, 10) and len(current) == 4: return current if key in (ord('u'), ord('U')) and current: current.pop() elif key in (ord('r'), ord('R')): current.clear() elif key in (ord('q'), 27): cv2.destroyAllWindows() sys.exit("Annule par l'utilisateur.") # ---------- Step 2: review wall (refine / add / done) ---------- def review_wall(disp_base, walls_disp, current_disp, mask_disp, wall_idx, state_widths): """Show mask overlay + dimensions input + buttons. Returns ('refine'|'add'|'done'|'cancel', width_cm). `state_widths` is the running list of widths chosen so far (used as default).""" disp_h, disp_w = disp_base.shape[:2] BTN_H = 70 bw = disp_w // 4 btns = { "refine": (0, disp_h - BTN_H, bw, disp_h, (180, 100, 0), "RAFFINER (R)"), "add": (bw, disp_h - BTN_H, 2 * bw, disp_h, (180, 100, 0), "+ MUR SUIVANT (A)"), "cancel": (2 * bw, disp_h - BTN_H, 3 * bw, disp_h, (60, 60, 60), "ANNULER MUR (C)"), "done": (3 * bw, disp_h - BTN_H, disp_w, disp_h, (0, 170, 0), "TERMINER (Enter)"), } # Width input controls on top-right W_FIELD = (disp_w - 380, 60, disp_w - 20, 110) W_MINUS = (disp_w - 380, 60, disp_w - 320, 110) W_PLUS = (disp_w - 80, 60, disp_w - 20, 110) default_w = int(state_widths[-1]) if state_widths else 300 state = {"action": None, "width": default_w} def on_mouse(event, x, y, flags, param): if event != cv2.EVENT_LBUTTONDOWN: return # Width adjust buttons if W_MINUS[0] <= x <= W_MINUS[2] and W_MINUS[1] <= y <= W_MINUS[3]: state["width"] = max(50, state["width"] - 10) return if W_PLUS[0] <= x <= W_PLUS[2] and W_PLUS[1] <= y <= W_PLUS[3]: state["width"] = min(2000, state["width"] + 10) return # Action buttons for k, (x1, y1, x2, y2, _, _) in btns.items(): if x1 <= x <= x2 and y1 <= y <= y2: state["action"] = k return cv2.setMouseCallback(PICKER_WIN, on_mouse) walls_for_draw = walls_disp + [current_disp] while state["action"] is None: base = _draw_walls(disp_base.copy(), walls_for_draw) if mask_disp is not None: ovr = base.copy() ovr[mask_disp > 0] = ovr[mask_disp > 0] * 0.3 + np.array([0, 255, 0]) * 0.7 base = cv2.addWeighted(ovr.astype(np.uint8), 0.55, base, 0.45, 0) quad_mask_disp = np.zeros_like(mask_disp) cv2.fillConvexPoly(quad_mask_disp, np.array(current_disp, dtype=np.int32), 255) rejected = (quad_mask_disp > 0) & (mask_disp == 0) r_ovr = base.copy() r_ovr[rejected] = r_ovr[rejected] * 0.3 + np.array([0, 0, 255]) * 0.7 base = cv2.addWeighted(r_ovr.astype(np.uint8), 0.45, base, 0.55, 0) header = (f"Mur {wall_idx+1} - vert = papier rouge = preserve " "(objets, fenetres)") cv2.rectangle(base, (0, 0), (base.shape[1], 50), (0, 0, 0), -1) cv2.putText(base, header, (10, 35), cv2.FONT_HERSHEY_SIMPLEX, 0.85, (255, 255, 255), 2) # Width input _filled_box(base, W_FIELD[0] - 6, W_FIELD[1] - 6, W_FIELD[2] + 6, W_FIELD[3] + 6, color=(255, 255, 255), border=(180, 180, 180)) _put_text(base, "LARGEUR DU MUR (CM)", (W_FIELD[0] + 4, W_FIELD[1] + 12), scale=0.4, color=(120, 120, 120)) _filled_box(base, *W_MINUS, color=(230, 230, 230), border=(180, 180, 180)) _put_text(base, "-", (W_MINUS[0] + 22, W_MINUS[3] - 12), scale=1.1, thickness=3, color=(40, 40, 40)) _put_text(base, str(state["width"]), (W_MINUS[2] + 20, W_FIELD[3] - 12), scale=1.1, thickness=3, color=(20, 20, 20)) _filled_box(base, *W_PLUS, color=(230, 230, 230), border=(180, 180, 180)) _put_text(base, "+", (W_PLUS[0] + 22, W_PLUS[3] - 12), scale=1.1, thickness=3, color=(40, 40, 40)) _put_text(base, "w/W = -10/+10 (10/50 cm)", (W_FIELD[0], W_FIELD[3] + 24), scale=0.4, color=(120, 120, 120)) for x1, y1, x2, y2, col, label in btns.values(): _btn(base, x1, y1, x2, y2, col, label) cv2.imshow(PICKER_WIN, base) key = cv2.waitKey(20) & 0xFF if key in (13, 10): state["action"] = "done" elif key in (ord('r'), ord('R')): state["action"] = "refine" elif key in (ord('a'), ord('A')): state["action"] = "add" elif key in (ord('c'), ord('C')): state["action"] = "cancel" elif key == ord('w'): state["width"] = max(50, state["width"] - 10) elif key == ord('W'): state["width"] = min(2000, state["width"] + 50) elif key == 27 or key == ord('q'): cv2.destroyAllWindows() sys.exit("Annule par l'utilisateur.") return state["action"], state["width"] # ---------- Step 3: brush + magic wand refinement ---------- def refine_mask(disp_photo, mask, quad_mask_disp): """Interactive refinement. Returns the updated mask (in disp resolution).""" state = { "mode": "add", # add | remove | wand_add | wand_remove "brush": 30, "wand_tol": 12, "drawing": False, "last": None, "undo": [], } h, w = disp_photo.shape[:2] BTN_H = 60 bw = w // 6 btns = { "add": (0, h - BTN_H, bw, h, (0, 150, 0), "Brosse + (1)"), "remove": (bw, h - BTN_H, 2 * bw, h, (0, 0, 150), "Brosse - (2)"), "wand_add": (2 * bw, h - BTN_H, 3 * bw, h, (0, 150, 150),"Wand + (3)"), "wand_rem": (3 * bw, h - BTN_H, 4 * bw, h, (150, 0, 150),"Wand - (4)"), "reset": (4 * bw, h - BTN_H, 5 * bw, h, (60, 60, 60), "Reset (r)"), "ok": (5 * bw, h - BTN_H, w, h, (0, 170, 0), "VALIDER (Enter)"), } mode_map = {"add": "add", "remove": "remove", "wand_add": "wand_add", "wand_rem": "wand_remove"} done = {"v": False} def commit(): state["undo"].append(mask.copy()) if len(state["undo"]) > 20: state["undo"].pop(0) def apply_brush_point(x, y): val = 255 if state["mode"] == "add" else 0 cv2.circle(mask, (x, y), state["brush"], val, -1) if val == 255: np.bitwise_and(mask, quad_mask_disp, out=mask) def apply_brush_line(p1, p2): val = 255 if state["mode"] == "add" else 0 cv2.line(mask, p1, p2, val, state["brush"] * 2) if val == 255: np.bitwise_and(mask, quad_mask_disp, out=mask) def apply_wand(x, y): flood = np.zeros((h + 2, w + 2), dtype=np.uint8) tol = state["wand_tol"] flags = 4 | (255 << 8) | cv2.FLOODFILL_MASK_ONLY | cv2.FLOODFILL_FIXED_RANGE cv2.floodFill(disp_photo.copy(), flood, (x, y), 0, loDiff=(tol, tol, tol), upDiff=(tol, tol, tol), flags=flags) region = (flood[1:-1, 1:-1] > 0).astype(np.uint8) * 255 region = cv2.bitwise_and(region, quad_mask_disp) if state["mode"] == "wand_add": np.maximum(mask, region, out=mask) else: mask[region > 0] = 0 def on_mouse(event, x, y, flags, param): if event == cv2.EVENT_LBUTTONDOWN: for k, (x1, y1, x2, y2, *_) in btns.items(): if x1 <= x <= x2 and y1 <= y <= y2: if k == "ok": done["v"] = True elif k == "reset": commit() mask[:] = state["undo"][0] if False else mask # noop placeholder elif k in mode_map: state["mode"] = mode_map[k] return commit() if state["mode"].startswith("wand"): apply_wand(x, y) else: state["drawing"] = True state["last"] = (x, y) apply_brush_point(x, y) elif event == cv2.EVENT_MOUSEMOVE and state["drawing"]: if state["mode"] in ("add", "remove") and state["last"]: apply_brush_line(state["last"], (x, y)) state["last"] = (x, y) elif event == cv2.EVENT_LBUTTONUP: state["drawing"] = False state["last"] = None cv2.setMouseCallback(PICKER_WIN, on_mouse) initial_mask = mask.copy() while not done["v"]: img = disp_photo.copy() # green overlay where wall, red where excluded inside quad wall_pix = mask > 127 ovr = img.copy().astype(np.float32) ovr[wall_pix] = ovr[wall_pix] * 0.55 + np.array([0, 200, 0]) * 0.45 excl_pix = (quad_mask_disp > 0) & (~wall_pix) ovr[excl_pix] = ovr[excl_pix] * 0.55 + np.array([0, 0, 200]) * 0.45 img = ovr.clip(0, 255).astype(np.uint8) header = (f"Mode: {state['mode']} | Brosse: {state['brush']}px " f"| Tol wand: {state['wand_tol']} | " "[/]=brosse ,/.=tol u=undo r=reset") cv2.rectangle(img, (0, 0), (img.shape[1], 38), (0, 0, 0), -1) cv2.putText(img, header, (10, 26), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (255, 255, 255), 1) for k, (x1, y1, x2, y2, col, label) in btns.items(): active = (k in mode_map and mode_map[k] == state["mode"]) actual_col = tuple(int(c * 1.4) if active else c for c in col) _btn(img, x1, y1, x2, y2, actual_col, label) cv2.imshow(PICKER_WIN, img) key = cv2.waitKey(20) & 0xFF if key == ord('1'): state["mode"] = "add" elif key == ord('2'): state["mode"] = "remove" elif key == ord('3'): state["mode"] = "wand_add" elif key == ord('4'): state["mode"] = "wand_remove" elif key == ord('['): state["brush"] = max(5, state["brush"] - 5) elif key == ord(']'): state["brush"] = min(200, state["brush"] + 5) elif key == ord(','): state["wand_tol"] = max(2, state["wand_tol"] - 2) elif key == ord('.'): state["wand_tol"] = min(60, state["wand_tol"] + 2) elif key == ord('u') and state["undo"]: mask[:] = state["undo"].pop() elif key == ord('r'): commit() mask[:] = initial_mask elif key in (13, 10): done["v"] = True elif key in (ord('q'), 27): mask[:] = initial_mask break return mask # ---------- Top-level picker ---------- def pick_walls_dynamic(photo_bgr, args, pad_ratio=0.25): h, w = photo_bgr.shape[:2] pad_w = int(w * pad_ratio) pad_h = int(h * pad_ratio) padded = cv2.copyMakeBorder(photo_bgr, pad_h, pad_h, pad_w, pad_w, cv2.BORDER_CONSTANT, value=(40, 40, 40)) max_w = 1500 scale = min(1.0, max_w / padded.shape[1]) disp_base = cv2.resize(padded, None, fx=scale, fy=scale) if scale < 1 else padded.copy() walls_disp: list[list[tuple[int, int]]] = [] wall_idx = 0 cv2.namedWindow(PICKER_WIN, cv2.WINDOW_AUTOSIZE) # Helper: convert one disp wall to photo-coords quad def disp_to_photo(pts): arr = np.array(pts, dtype=np.float32) / scale return arr - np.array([pad_w, pad_h], dtype=np.float32) # For mask computation we need a downscaled photo of disp_base size photo_for_disp = cv2.resize(photo_bgr, (disp_base.shape[1] - 0, disp_base.shape[0] - 0)) # Actually we want a disp_base-sized version of the photo. disp_base contains padding. # Build a padded version of photo at disp scale: photo_padded = cv2.copyMakeBorder(photo_bgr, pad_h, pad_h, pad_w, pad_w, cv2.BORDER_CONSTANT, value=(40, 40, 40)) photo_disp = (cv2.resize(photo_padded, (disp_base.shape[1], disp_base.shape[0])) if scale < 1 else photo_padded.copy()) wall_masks_full: list[np.ndarray] = [] wall_widths_cm: list[float] = [] full_h, full_w = photo_bgr.shape[:2] def _full_to_disp(mask_full): padded = np.zeros((photo_padded.shape[0], photo_padded.shape[1]), np.uint8) padded[pad_h:pad_h + full_h, pad_w:pad_w + full_w] = mask_full return cv2.resize(padded, (disp_base.shape[1], disp_base.shape[0]), interpolation=cv2.INTER_NEAREST) def _disp_to_full(mask_disp): padded = cv2.resize(mask_disp, (photo_padded.shape[1], photo_padded.shape[0]), interpolation=cv2.INTER_NEAREST) return padded[pad_h:pad_h + full_h, pad_w:pad_w + full_w] while True: current = pick_corners(disp_base, walls_disp, wall_idx) # Convert to full-res photo coords and compute mask there. current_photo = disp_to_photo(current) q_full = quad_mask(photo_bgr.shape[:2], current_photo) print(f" Computing mask for wall {wall_idx + 1}...") if args.auto_mask: mask_full = occlusion_mask(photo_bgr, q_full, args.chroma_threshold, use_semantic=args.semantic, use_sam=args.sam, strictness=args.strictness) else: mask_full = q_full.copy() mask_disp = _full_to_disp(mask_full) q_disp = np.zeros(disp_base.shape[:2], np.uint8) cv2.fillConvexPoly(q_disp, np.array(current, dtype=np.int32), 255) while True: action, width_cm = review_wall(disp_base, walls_disp, current, mask_disp, wall_idx, wall_widths_cm) if action == "refine": mask_disp = refine_mask(photo_disp.copy(), mask_disp.copy(), q_disp) mask_full = _disp_to_full(mask_disp) elif action == "cancel": break elif action in ("add", "done"): walls_disp.append(current) wall_masks_full.append(mask_full) wall_widths_cm.append(float(width_cm)) wall_idx += 1 break if action == "done": break if action == "cancel": continue cv2.destroyWindow(PICKER_WIN) walls_entries = [] for w_disp, m_full, w_cm in zip(walls_disp, wall_masks_full, wall_widths_cm): quad_photo = disp_to_photo(w_disp) walls_entries.append({"quad": quad_photo, "mask": m_full, "width_cm": w_cm}) return walls_entries # ---------- Density preview ---------- def interactive_preview(photo, walls, pattern, args): h, w = photo.shape[:2] max_w = 1300 scale = min(1.0, max_w / w) if scale < 1: prev_photo = cv2.resize(photo, None, fx=scale, fy=scale) prev_walls = [] for e in walls: q = np.asarray(e["quad"], dtype=np.float32) * scale m = cv2.resize(e["mask"], (prev_photo.shape[1], prev_photo.shape[0]), interpolation=cv2.INTER_NEAREST) entry = {"quad": q, "mask": m, "width_cm": e.get("width_cm")} prev_walls.append(entry) else: prev_photo = photo.copy() prev_walls = walls is_tile = (args.mode == "tile") d_min = int(args.density_min) d_max = int(args.density_max) initial_density = max(d_min, min(d_max, int(args.density))) if is_tile else None BAR_H = 90 canvas_w = prev_photo.shape[1] sx1, sx2 = 30, canvas_w - 30 sy_offset = 50 state = {"density": initial_density, "dirty": True, "img": None, "dragging": False} def density_at(x): t = max(0.0, min(1.0, (x - sx1) / max(1, sx2 - sx1))) return int(round(d_min + t * (d_max - d_min))) def on_mouse(event, x, y, flags, param): if not is_tile: return bar_top = prev_photo.shape[0] if event == cv2.EVENT_LBUTTONDOWN: sy_abs = bar_top + sy_offset if abs(y - sy_abs) <= 25 and sx1 - 15 <= x <= sx2 + 15: state["dragging"] = True state["density"] = density_at(x) state["dirty"] = True elif event == cv2.EVENT_MOUSEMOVE and state["dragging"]: state["density"] = density_at(x) state["dirty"] = True elif event == cv2.EVENT_LBUTTONUP: state["dragging"] = False win = ("Preview densite - drag slider - S/Enter export - Q annuler" if is_tile else "Preview panoramique - S/Enter export - Q annuler") cv2.namedWindow(win, cv2.WINDOW_AUTOSIZE) cv2.setMouseCallback(win, on_mouse) while True: if state["dirty"]: density = state["density"] canvas, _ = render_all( prev_photo, prev_walls, pattern, mode=args.mode, density=density if is_tile else None, shading_strength=args.shading_strength, feather=args.feather, chroma_threshold=args.chroma_threshold, auto_mask=args.auto_mask, ) full = np.full((canvas.shape[0] + BAR_H, canvas.shape[1], 3), 35, dtype=np.uint8) full[:canvas.shape[0]] = canvas if is_tile: sy = canvas.shape[0] + sy_offset _put_text(full, f"Densite = {density} cm", (sx1, sy - 16), scale=0.7, thickness=2, color=(255, 255, 255)) cv2.line(full, (sx1, sy), (sx2, sy), (110, 110, 110), 5) t = (density - d_min) / max(1, d_max - d_min) tx = int(sx1 + t * (sx2 - sx1)) cv2.circle(full, (tx, sy), 12, (50, 210, 250), -1) cv2.circle(full, (tx, sy), 12, (200, 200, 200), 1) _put_text(full, str(d_min), (sx1 - 4, sy + 26), scale=0.45, color=(170, 170, 170)) _put_text(full, str(d_max), (sx2 - 28, sy + 26), scale=0.45, color=(170, 170, 170)) info_y = canvas.shape[0] + BAR_H - 12 parts = [] for i, e in enumerate(prev_walls, 1): wc = e.get("width_cm") if wc: parts.append(f"mur{i}={int(wc)}cm/~{wc/density:.1f}rep") _put_text(full, " ".join(parts), (sx1, info_y), scale=0.45, color=(190, 190, 190)) else: cy = canvas.shape[0] + BAR_H // 2 + 6 _put_text(full, "Mode panoramique : motif etire sur chaque mur. " "S/Enter = exporter - Q = annuler", (sx1, cy), scale=0.6, thickness=2, color=(255, 255, 255)) state["img"] = full state["dirty"] = False cv2.imshow(win, state["img"]) key = cv2.waitKey(30) & 0xFF if key in (ord('s'), ord('S'), 13, 10): cv2.destroyWindow(win) return state["density"] if key in (ord('q'), 27): cv2.destroyAllWindows() sys.exit("Annule par l'utilisateur.") if is_tile and key == ord('['): state["density"] = max(d_min, state["density"] - 1); state["dirty"] = True elif is_tile and key == ord(']'): state["density"] = min(d_max, state["density"] + 1); state["dirty"] = True # ---------- Main ---------- def main(): ap = argparse.ArgumentParser(description="Wallpaper simulator POC v7") ap.add_argument("--photo", required=True, type=Path) ap.add_argument("--pattern", required=True, type=Path) ap.add_argument("--mode", choices=["tile", "panoramic"], default="tile") ap.add_argument("--density", type=int, default=40, help="Pattern repetition width in cm — same scale as on " "wellpapers.com (e.g. Stripes & Swing: 10-100, default 40)") ap.add_argument("--density-min", type=int, default=10) ap.add_argument("--density-max", type=int, default=100) ap.add_argument("--wall-width", type=float, default=300.0, help="Real wall width in cm (used for all walls). Default 300.") ap.add_argument("--shading-strength", type=float, default=0.85) ap.add_argument("--feather", type=int, default=2) ap.add_argument("--auto-mask", action=argparse.BooleanOptionalAction, default=True) ap.add_argument("--chroma-threshold", type=float, default=14.0) ap.add_argument("--min-object-ratio", type=float, default=0.004) ap.add_argument("--semantic", action=argparse.BooleanOptionalAction, default=True, help="Use SegFormer ADE20K for wall segmentation (default on)") ap.add_argument("--sam", action=argparse.BooleanOptionalAction, default=True, help="Fallback to MobileSAM if semantic fails (default on)") ap.add_argument("--strictness", type=int, default=2, help="Object rejection strictness 0-4. Higher = more " "aggressive (closes window gaps, eats further into " "object edges).") ap.add_argument("--out", type=Path, default=Path("out.png")) args = ap.parse_args() photo = load_image(args.photo) pattern = load_image(args.pattern) print(f"Photo : {args.photo.name} {photo.shape[1]}x{photo.shape[0]}") print(f"Motif : {args.pattern.name}") print(f"Densite range : {args.density_min}-{args.density_max} cm (def {args.density})") print(f"Largeur mur par defaut : {int(args.wall_width)} cm") print("Workflow : Photo -> Pick corners -> Mesures -> Mur suivant -> Densite") walls = pick_walls_dynamic(photo, args) if not walls: sys.exit("Aucun mur selectionne.") print(f"Murs selectionnes : {len(walls)}") final_density = interactive_preview(photo, walls, pattern, args) if args.mode == "tile": print(f"Densite finale : {final_density} cm (largeur d'une " f"repetition du motif). Achetable sur wellpapers.com avec " f"le slider 'Taille des motifs' = {final_density}.") canvas, masks_dbg = render_all( photo, walls, pattern, mode=args.mode, density=final_density, shading_strength=args.shading_strength, feather=args.feather, chroma_threshold=args.chroma_threshold, auto_mask=args.auto_mask, ) args.out.parent.mkdir(parents=True, exist_ok=True) cv2.imwrite(str(args.out), canvas) cmp_p = args.out.with_name(args.out.stem + "_compare" + args.out.suffix) cv2.imwrite(str(cmp_p), np.concatenate([photo, canvas], axis=1)) mask_p = args.out.with_name(args.out.stem + "_mask" + args.out.suffix) cv2.imwrite(str(mask_p), masks_dbg) print(f"Sortie : {args.out}") print(f"Avant / apres : {cmp_p}") try: subprocess.run(["open", str(cmp_p)], check=False) except Exception: pass if __name__ == "__main__": main()