Spaces:
Running
Running
Download relief_workshop.py from bokula/pattern-ground: direct link, hf CLI and curl.
- Browser
- Download file 14 kB
-
https://huggingface.co/spaces/bokula/pattern-ground/resolve/main/relief_workshop.py
- Command line
-
hf download hf://spaces/bokula/pattern-ground/relief_workshop.py
-
curl -L -o relief_workshop.py https://huggingface.co/spaces/bokula/pattern-ground/resolve/main/relief_workshop.py
14 kB
| """ | |
| relief_workshop.py | |
| Image → 3D relief tile — versione workshop Fabrication Topologies | |
| """ | |
| import argparse | |
| import struct | |
| import sys | |
| from pathlib import Path | |
| import cv2 | |
| import numpy as np | |
| from PIL import Image | |
| def load_and_prepare(image_path: str, max_px: int) -> np.ndarray: | |
| img = Image.open(image_path).convert("RGB") | |
| ratio = min(max_px / img.width, max_px / img.height) | |
| new_w = max(2, int(img.width * ratio)) | |
| new_h = max(2, int(img.height * ratio)) | |
| img = img.resize((new_w, new_h), Image.LANCZOS) | |
| return np.array(img.convert("L"), dtype=np.float32) | |
| def smooth_heightmap(gray: np.ndarray, blur: float) -> np.ndarray: | |
| if blur <= 0: | |
| return gray | |
| result = cv2.bilateralFilter( | |
| gray.astype(np.uint8), d=9, | |
| sigmaColor=min(60, blur * 15), | |
| sigmaSpace=min(10, blur * 3) | |
| ).astype(np.float32) | |
| return result | |
| def quantize_heightmap(gray: np.ndarray, levels: int) -> np.ndarray: | |
| if levels < 2: | |
| return gray | |
| normalized = gray / 255.0 | |
| quantized = np.floor(normalized * levels) / levels | |
| return (quantized * 255.0).astype(np.float32) | |
| def make_tileable(gray: np.ndarray, fade_px: int) -> np.ndarray: | |
| if fade_px <= 0: | |
| return gray | |
| h, w = gray.shape | |
| mean_val = float(np.mean(gray)) | |
| result = gray.copy() | |
| fade = min(fade_px, w // 4, h // 4) | |
| for i in range(fade): | |
| alpha = i / fade | |
| result[i, :] = alpha * gray[i, :] + (1 - alpha) * mean_val | |
| result[h - 1 - i, :] = alpha * gray[h - 1 - i, :] + (1 - alpha) * mean_val | |
| result[:, i] = alpha * result[:, i] + (1 - alpha) * mean_val | |
| result[:, w - 1 - i] = alpha * result[:, w - 1 - i] + (1 - alpha) * mean_val | |
| return result | |
| def build_heightmap( | |
| image_path: str, | |
| max_px: int = 500, | |
| invert: bool = False, | |
| blur: float = 0.5, | |
| gamma: float = 1.1, | |
| quantize: int = 0, | |
| tileable: bool = False, | |
| fade_px: int = 8, | |
| ): | |
| gray = load_and_prepare(image_path, max_px) | |
| h, w = gray.shape | |
| gray = smooth_heightmap(gray, blur) | |
| gray = np.power(gray / 255.0, gamma) * 255.0 | |
| if quantize >= 2: | |
| gray = quantize_heightmap(gray, quantize) | |
| if tileable: | |
| gray = make_tileable(gray, fade_px) | |
| if invert: | |
| gray = 255.0 - gray | |
| gray = np.clip(gray, 0, 255) | |
| return gray / 255.0, w, h | |
| def _pack_triangle(normal, v1, v2, v3) -> bytes: | |
| return struct.pack("<ffffffffffffH", *normal, *v1, *v2, *v3, 0) | |
| def heightmap_to_stl( | |
| height_map: np.ndarray, | |
| px_w: int, | |
| px_h: int, | |
| tile_w_mm: float, | |
| tile_h_mm: float, | |
| relief_mm: float, | |
| base_mm: float, | |
| ) -> bytes: | |
| """ | |
| Genera STL da heightmap [0,1]. | |
| Se base_mm == 0: mesh aperta sotto (solo superficie + pareti che scendono | |
| fino al punto più basso del rilievo, nessun piano inferiore). | |
| Se base_mm > 0: solido chiuso con base piatta. | |
| """ | |
| pixel_x = tile_w_mm / (px_w - 1) | |
| pixel_y = tile_h_mm / (px_h - 1) | |
| no_base = (base_mm <= 0) | |
| def z_surf(row, col): | |
| # z della superficie di rilievo | |
| return base_mm + height_map[row, col] * relief_mm | |
| def z_bottom(row, col): | |
| # z del bordo inferiore: 0 se c'è la base, minimo locale se no | |
| if no_base: | |
| return height_map[row, col] * relief_mm # inizia dal rilievo stesso (min=0) | |
| return 0.0 | |
| triangles = [] | |
| # ── Superficie superiore ── | |
| for row in range(px_h - 1): | |
| for col in range(px_w - 1): | |
| x0, x1 = col * pixel_x, (col + 1) * pixel_x | |
| y0 = (px_h - 1 - row) * pixel_y | |
| y1 = (px_h - 2 - row) * pixel_y | |
| z00 = z_surf(row, col) | |
| z10 = z_surf(row, col + 1) | |
| z01 = z_surf(row + 1, col) | |
| z11 = z_surf(row + 1, col + 1) | |
| v00, v10 = (x0, y0, z00), (x1, y0, z10) | |
| v01, v11 = (x0, y1, z01), (x1, y1, z11) | |
| e1 = np.subtract(v10, v00); e2 = np.subtract(v01, v00) | |
| n = np.cross(e1, e2); nn = n / (np.linalg.norm(n) + 1e-12) | |
| triangles.append(_pack_triangle(nn, v00, v10, v01)) | |
| e1 = np.subtract(v01, v11); e2 = np.subtract(v10, v11) | |
| n = np.cross(e1, e2); nn = n / (np.linalg.norm(n) + 1e-12) | |
| triangles.append(_pack_triangle(nn, v11, v01, v10)) | |
| # ── Base inferiore (solo se base_mm > 0) ── | |
| if not no_base: | |
| for row in range(px_h - 1): | |
| for col in range(px_w - 1): | |
| x0, x1 = col * pixel_x, (col + 1) * pixel_x | |
| y0 = (px_h - 1 - row) * pixel_y | |
| y1 = (px_h - 2 - row) * pixel_y | |
| n = (0.0, 0.0, -1.0) | |
| triangles.append(_pack_triangle(n, (x0,y0,0),(x0,y1,0),(x1,y0,0))) | |
| triangles.append(_pack_triangle(n, (x1,y1,0),(x1,y0,0),(x0,y1,0))) | |
| W, H = tile_w_mm, tile_h_mm | |
| if no_base: | |
| # Senza base: le pareti laterali collegano la superficie al suo stesso | |
| # bordo inferiore (z = height_map * relief_mm, cioè parte da 0 al minimo) | |
| # Fronte (y=0, row = px_h-1) | |
| for col in range(px_w - 1): | |
| x0, x1 = col * pixel_x, (col + 1) * pixel_x | |
| zt0 = z_surf(px_h - 1, col); zt1 = z_surf(px_h - 1, col + 1) | |
| zb0 = height_map[px_h-1, col] * relief_mm | |
| zb1 = height_map[px_h-1, col+1] * relief_mm | |
| n = (0.0, -1.0, 0.0) | |
| triangles.append(_pack_triangle(n, (x0,0,zb0),(x1,0,zt1),(x0,0,zt0))) | |
| triangles.append(_pack_triangle(n, (x0,0,zb0),(x1,0,zb1),(x1,0,zt1))) | |
| # Retro (y=H, row = 0) | |
| for col in range(px_w - 1): | |
| x0, x1 = col * pixel_x, (col + 1) * pixel_x | |
| zt0 = z_surf(0, col); zt1 = z_surf(0, col + 1) | |
| zb0 = height_map[0, col] * relief_mm | |
| zb1 = height_map[0, col+1] * relief_mm | |
| n = (0.0, 1.0, 0.0) | |
| triangles.append(_pack_triangle(n, (x0,H,zt0),(x1,H,zt1),(x0,H,zb0))) | |
| triangles.append(_pack_triangle(n, (x1,H,zt1),(x1,H,zb1),(x0,H,zb0))) | |
| # Sinistra (x=0, col=0) | |
| for row in range(px_h - 1): | |
| y0 = (px_h - 1 - row) * pixel_y | |
| y1 = (px_h - 2 - row) * pixel_y | |
| zt0 = z_surf(row, 0); zt1 = z_surf(row + 1, 0) | |
| zb0 = height_map[row, 0] * relief_mm | |
| zb1 = height_map[row+1, 0] * relief_mm | |
| n = (-1.0, 0.0, 0.0) | |
| triangles.append(_pack_triangle(n, (0,y0,zt0),(0,y1,zt1),(0,y0,zb0))) | |
| triangles.append(_pack_triangle(n, (0,y1,zt1),(0,y1,zb1),(0,y0,zb0))) | |
| # Destra (x=W, col=px_w-1) | |
| for row in range(px_h - 1): | |
| y0 = (px_h - 1 - row) * pixel_y | |
| y1 = (px_h - 2 - row) * pixel_y | |
| zt0 = z_surf(row, px_w-1); zt1 = z_surf(row+1, px_w-1) | |
| zb0 = height_map[row, px_w-1] * relief_mm | |
| zb1 = height_map[row+1, px_w-1] * relief_mm | |
| n = (1.0, 0.0, 0.0) | |
| triangles.append(_pack_triangle(n, (W,y0,zb0),(W,y1,zt1),(W,y0,zt0))) | |
| triangles.append(_pack_triangle(n, (W,y0,zb0),(W,y1,zb1),(W,y1,zt1))) | |
| else: | |
| # Con base: pareti vanno da z=0 alla superficie | |
| # Fronte | |
| for col in range(px_w - 1): | |
| x0, x1 = col * pixel_x, (col + 1) * pixel_x | |
| zt0 = z_surf(px_h-1, col); zt1 = z_surf(px_h-1, col+1) | |
| n = (0.0, -1.0, 0.0) | |
| triangles.append(_pack_triangle(n,(x0,0,0),(x1,0,zt1),(x0,0,zt0))) | |
| triangles.append(_pack_triangle(n,(x0,0,0),(x1,0,0),(x1,0,zt1))) | |
| # Retro | |
| for col in range(px_w - 1): | |
| x0, x1 = col * pixel_x, (col + 1) * pixel_x | |
| zt0 = z_surf(0, col); zt1 = z_surf(0, col+1) | |
| n = (0.0, 1.0, 0.0) | |
| triangles.append(_pack_triangle(n,(x0,H,zt0),(x1,H,zt1),(x0,H,0))) | |
| triangles.append(_pack_triangle(n,(x1,H,zt1),(x1,H,0),(x0,H,0))) | |
| # Sinistra | |
| for row in range(px_h - 1): | |
| y0 = (px_h-1-row)*pixel_y; y1 = (px_h-2-row)*pixel_y | |
| zt0 = z_surf(row,0); zt1 = z_surf(row+1,0) | |
| n = (-1.0, 0.0, 0.0) | |
| triangles.append(_pack_triangle(n,(0,y0,zt0),(0,y1,zt1),(0,y0,0))) | |
| triangles.append(_pack_triangle(n,(0,y1,0),(0,y0,0),(0,y1,zt1))) | |
| # Destra | |
| for row in range(px_h - 1): | |
| y0 = (px_h-1-row)*pixel_y; y1 = (px_h-2-row)*pixel_y | |
| zt0 = z_surf(row,px_w-1); zt1 = z_surf(row+1,px_w-1) | |
| n = (1.0, 0.0, 0.0) | |
| triangles.append(_pack_triangle(n,(W,y0,0),(W,y1,zt1),(W,y0,zt0))) | |
| triangles.append(_pack_triangle(n,(W,y0,0),(W,y1,0),(W,y1,zt1))) | |
| header = b"\x00" * 80 | |
| count = struct.pack("<I", len(triangles)) | |
| return header + count + b"".join(triangles) | |
| def save_depth_preview(height_map: np.ndarray, out_path: str): | |
| Image.fromarray((height_map * 255).astype(np.uint8)).save(out_path) | |
| # ───────────────────────────────────────────── | |
| # BLOB PIPELINE (pezzi separati) | |
| # ───────────────────────────────────────────── | |
| def _contour_to_stl(contour, height_mm: float) -> bytes: | |
| """ | |
| Converte un singolo contorno OpenCV in un solido STL chiuso | |
| (cilindretto: cappello superiore + base piatta + pareti laterali). | |
| Il contorno è in coordinate pixel; scaliamo dopo. | |
| """ | |
| import struct | |
| pts = contour.reshape(-1, 2).astype(float) | |
| n = len(pts) | |
| if n < 3: | |
| return b"" | |
| # Centra e normalizza — scala 1 px = 1 unità, poi il chiamante ri-scala | |
| # Triangolazione fan dalla centroide per cappello e base | |
| cx, cy = pts[:, 0].mean(), pts[:, 1].mean() | |
| def pack_tri(normal, v1, v2, v3): | |
| return struct.pack("<ffffffffffffH", *normal, *v1, *v2, *v3, 0) | |
| tris = [] | |
| # Cappello superiore (z = height_mm) — fan dalla centroide | |
| for i in range(n): | |
| a = pts[i] | |
| b = pts[(i + 1) % n] | |
| v0 = (cx, cy, height_mm) | |
| v1 = (a[0], a[1], height_mm) | |
| v2 = (b[0], b[1], height_mm) | |
| e1 = (v1[0]-v0[0], v1[1]-v0[1], 0) | |
| e2 = (v2[0]-v0[0], v2[1]-v0[1], 0) | |
| nx = e1[1]*e2[2] - e1[2]*e2[1] | |
| ny = e1[2]*e2[0] - e1[0]*e2[2] | |
| nz = e1[0]*e2[1] - e1[1]*e2[0] | |
| ln = (nx**2+ny**2+nz**2)**0.5 + 1e-12 | |
| tris.append(pack_tri((nx/ln, ny/ln, nz/ln), v0, v1, v2)) | |
| # Base inferiore (z = 0) — fan inverso | |
| for i in range(n): | |
| a = pts[i] | |
| b = pts[(i + 1) % n] | |
| v0 = (cx, cy, 0) | |
| v1 = (b[0], b[1], 0) | |
| v2 = (a[0], a[1], 0) | |
| tris.append(pack_tri((0, 0, -1), v0, v1, v2)) | |
| # Pareti laterali | |
| for i in range(n): | |
| a = pts[i] | |
| b = pts[(i + 1) % n] | |
| # due triangoli per ogni segmento | |
| v00 = (a[0], a[1], 0) | |
| v10 = (b[0], b[1], 0) | |
| v01 = (a[0], a[1], height_mm) | |
| v11 = (b[0], b[1], height_mm) | |
| # normale laterale approssimata | |
| dx, dy = b[0]-a[0], b[1]-a[1] | |
| ln = (dx**2+dy**2)**0.5 + 1e-12 | |
| nx, ny = dy/ln, -dx/ln | |
| tris.append(pack_tri((nx, ny, 0), v00, v10, v01)) | |
| tris.append(pack_tri((nx, ny, 0), v10, v11, v01)) | |
| header = b"\x00" * 80 | |
| count = struct.pack("<I", len(tris)) | |
| return header + count + b"".join(tris) | |
| def blobs_to_stl( | |
| image_path: str, | |
| tile_w_mm: float, | |
| tile_h_mm: float, | |
| height_mm: float, | |
| threshold: int = 127, | |
| min_area_px: int = 20, | |
| ) -> tuple[bytes, int]: | |
| """ | |
| Pipeline blob: soglia binaria → findContours → un cilindretto per blob. | |
| Restituisce (stl_bytes, n_blobs). | |
| Tutti i cilindretti sono nella stessa mesh (un solo file STL). | |
| """ | |
| img = Image.open(image_path).convert("L") | |
| arr = np.array(img, dtype=np.uint8) | |
| # Scala pixel → mm | |
| scale_x = tile_w_mm / arr.shape[1] | |
| scale_y = tile_h_mm / arr.shape[0] | |
| # Soglia binaria | |
| _, binary = cv2.threshold(arr, threshold, 255, cv2.THRESH_BINARY) | |
| # Trova contorni esterni | |
| contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) | |
| all_tris = [] | |
| n_blobs = 0 | |
| for cnt in contours: | |
| area = cv2.contourArea(cnt) | |
| if area < min_area_px: | |
| continue | |
| # Semplifica il contorno per ridurre la mesh | |
| eps = 0.01 * cv2.arcLength(cnt, True) | |
| cnt = cv2.approxPolyDP(cnt, eps, True) | |
| pts = cnt.reshape(-1, 2).astype(float) | |
| if len(pts) < 3: | |
| continue | |
| # Converti pixel → mm (y invertita: OpenCV ha y verso il basso) | |
| pts[:, 0] *= scale_x | |
| pts[:, 1] = tile_h_mm - pts[:, 1] * scale_y | |
| # Genera STL del singolo blob | |
| blob_bytes = _contour_to_stl(pts.reshape(-1, 1, 2), height_mm) | |
| if blob_bytes: | |
| # Estrai solo i triangoli (salta header 84 byte) | |
| n_tri = (len(blob_bytes) - 84) // 50 | |
| all_tris.append(blob_bytes[84:]) | |
| n_blobs += 1 | |
| if not all_tris: | |
| raise ValueError("Nessun blob trovato. Prova ad abbassare la soglia o caricare un'immagine con forme bianche su sfondo nero.") | |
| import struct | |
| total_tris = sum(len(t) // 50 for t in all_tris) | |
| header = b"\x00" * 80 | |
| count = struct.pack("<I", total_tris) | |
| return header + count + b"".join(all_tris), n_blobs | |
| def blob_preview(image_path: str, threshold: int = 127, min_area_px: int = 20) -> np.ndarray: | |
| """Restituisce un'immagine con i contorni trovati disegnati sopra l'originale.""" | |
| img = Image.open(image_path).convert("L") | |
| arr = np.array(img, dtype=np.uint8) | |
| _, binary = cv2.threshold(arr, threshold, 255, cv2.THRESH_BINARY) | |
| contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) | |
| preview = cv2.cvtColor(arr, cv2.COLOR_GRAY2RGB) | |
| valid = [c for c in contours if cv2.contourArea(c) >= min_area_px] | |
| cv2.drawContours(preview, valid, -1, (212, 169, 18), 2) | |
| return preview, len(valid) | |