Upload 3 files

app.py.txt

@@ -0,0 +1,41 @@
+import gradio as gr
+import tempfile, os
+from raster_to_dxf import convert
+
+def run_convert(image_path, upscale, denoise, hough_min, hough_gap, scale_mm):
+    settings = {
+        "upscale":         upscale,
+        "denoise_h":       int(denoise),
+        "hough_min_len":   int(hough_min),
+        "hough_max_gap":   int(hough_gap),
+        "output_scale_mm": scale_mm,
+    }
+    out_path = tempfile.mktemp(suffix=".dxf")
+    stats = convert(image_path, out_path, settings)
+    summary = (f"✅ Lines: {stats['lines']}  |  "
+               f"Polylines: {stats['polylines']}  |  "
+               f"Circles: {stats['circles']}")
+    return out_path, summary
+
+with gr.Blocks(title="VectorForge — PNG to DXF") as demo:
+    gr.Markdown("# ⬡ VectorForge\n### Raster-to-Vector converter · PNG → DXF")
+
+    with gr.Row():
+        with gr.Column():
+            image_in = gr.Image(type="filepath", label="Upload PNG / JPG / BMP")
+            upscale  = gr.Slider(1, 4, value=2, step=0.5, label="Upscale factor")
+            denoise  = gr.Slider(1, 20, value=6, step=1,   label="Denoise strength")
+            hmin     = gr.Slider(5, 80, value=18, step=1,  label="Hough min line length (px)")
+            hgap     = gr.Slider(2, 40, value=10, step=1,  label="Hough max gap (px)")
+            scale    = gr.Slider(0.05, 1, value=0.1, step=0.05, label="Output scale (mm/px)")
+            btn      = gr.Button("⚡ Convert to DXF", variant="primary")
+
+        with gr.Column():
+            dxf_out  = gr.File(label="Download DXF")
+            status   = gr.Textbox(label="Stats", interactive=False)
+
+    btn.click(run_convert,
+              inputs=[image_in, upscale, denoise, hmin, hgap, scale],
+              outputs=[dxf_out, status])
+
+demo.launch()

raster_to_dxf.py

@@ -0,0 +1,463 @@
+#!/usr/bin/env python3
+"""
+Production-grade Raster-to-Vector converter: PNG -> DXF
+Optimised for engineering/architectural drawings (like HVAC details).
+"""
+
+import sys
+import argparse
+import numpy as np
+import cv2
+import ezdxf
+from ezdxf import units
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import List, Tuple, Optional
+import math
+
+
+# ─── Data types ──────────────────────────────────────────────────────────────
+
+@dataclass
+class VectorLine:
+    x1: float; y1: float; x2: float; y2: float
+    layer: str = "LINES"
+
+@dataclass
+class VectorPolyline:
+    points: List[Tuple[float, float]]
+    closed: bool = False
+    layer: str = "CONTOURS"
+
+@dataclass
+class VectorCircle:
+    cx: float; cy: float; r: float
+    layer: str = "CIRCLES"
+
+@dataclass
+class VectorArc:
+    cx: float; cy: float; r: float
+    start_angle: float; end_angle: float
+    layer: str = "ARCS"
+
+@dataclass
+class VectorText:
+    x: float; y: float; text: str; height: float = 2.5
+    layer: str = "TEXT"
+
+@dataclass
+class VectorResult:
+    lines: List[VectorLine] = field(default_factory=list)
+    polylines: List[VectorPolyline] = field(default_factory=list)
+    circles: List[VectorCircle] = field(default_factory=list)
+    arcs: List[VectorArc] = field(default_factory=list)
+    texts: List[VectorText] = field(default_factory=list)
+    width_px: int = 0
+    height_px: int = 0
+    scale: float = 1.0          # px → mm
+
+
+# ─── Image pre-processing ────────────────────────────────────────────────────
+
+def preprocess(img_bgr: np.ndarray, settings: dict) -> Tuple[np.ndarray, np.ndarray]:
+    """Return (binary_clean, gray_original)."""
+    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+
+    # Upscale if small
+    h, w = gray.shape
+    scale_up = settings.get("upscale", 2.0)
+    if min(h, w) < 800 or scale_up != 1.0:
+        gray = cv2.resize(gray, (int(w * scale_up), int(h * scale_up)),
+                          interpolation=cv2.INTER_CUBIC)
+
+    # Denoise
+    denoised = cv2.fastNlMeansDenoising(gray, h=settings.get("denoise_h", 8),
+                                         templateWindowSize=7, searchWindowSize=21)
+
+    # Adaptive threshold + Otsu combined
+    block = settings.get("adaptive_block", 51)
+    C = settings.get("adaptive_C", 10)
+    adapt = cv2.adaptiveThreshold(denoised, 255,
+                                  cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                                  cv2.THRESH_BINARY_INV, block, C)
+
+    _, otsu = cv2.threshold(denoised, 0, 255,
+                            cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    binary = cv2.bitwise_or(adapt, otsu)
+
+    # Morphological clean-up
+    k_open = settings.get("morph_open", 2)
+    k_close = settings.get("morph_close", 3)
+    kernel_o = cv2.getStructuringElement(cv2.MORPH_RECT, (k_open, k_open))
+    kernel_c = cv2.getStructuringElement(cv2.MORPH_RECT, (k_close, k_close))
+    binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN,  kernel_o)
+    binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel_c)
+
+    return binary, gray
+
+
+# ─── Skeleton / thinning for line extraction ─────────────────────────────────
+
+def thin_image(binary: np.ndarray) -> np.ndarray:
+    """Skeletonise binary image (Zhang-Suen via scikit-image)."""
+    from skimage.morphology import skeletonize as sk_skeletonize
+    bool_img = (binary > 0)
+    skel = sk_skeletonize(bool_img)
+    return (skel.astype(np.uint8) * 255)
+
+
+# ─── Probabilistic Hough lines ───────────────────────────────────────────────
+
+def extract_hough_lines(thin: np.ndarray, settings: dict,
+                         scale: float) -> List[VectorLine]:
+    lines_out = []
+    rho        = settings.get("hough_rho", 1)
+    theta      = np.pi / 180 * settings.get("hough_theta_deg", 1)
+    threshold  = settings.get("hough_threshold", 30)
+    min_len    = settings.get("hough_min_len", 20)
+    max_gap    = settings.get("hough_max_gap", 8)
+
+    detected = cv2.HoughLinesP(thin, rho, theta, threshold,
+                                minLineLength=min_len, maxLineGap=max_gap)
+    h = thin.shape[0]
+    if detected is not None:
+        for ln in detected:
+            x1, y1, x2, y2 = ln[0]
+            lines_out.append(VectorLine(
+                x1 * scale, (h - y1) * scale,
+                x2 * scale, (h - y2) * scale,
+                layer="LINES"
+            ))
+    return lines_out
+
+
+# ─── Contour extraction (closed shapes, arcs, circles) ───────────────────────
+
+def _fit_circle(pts):
+    """Algebraic circle fit (Kåsa method)."""
+    x = pts[:, 0].astype(float)
+    y = pts[:, 1].astype(float)
+    A = np.column_stack([x, y, np.ones(len(x))])
+    b = x**2 + y**2
+    result = np.linalg.lstsq(A, b, rcond=None)
+    c = result[0]
+    cx = c[0] / 2
+    cy = c[1] / 2
+    r = math.sqrt(c[2] + cx**2 + cy**2)
+    residuals = np.sqrt((x - cx)**2 + (y - cy)**2) - r
+    rmse = np.sqrt(np.mean(residuals**2))
+    return cx, cy, r, rmse
+
+
+def _is_circular(cnt, tol=0.15) -> Optional[Tuple[float, float, float]]:
+    if len(cnt) < 20:
+        return None
+    pts = cnt[:, 0, :]
+    cx, cy, r, rmse = _fit_circle(pts)
+    if r < 3:
+        return None
+    if rmse / r < tol:
+        return cx, cy, r
+    return None
+
+
+def extract_contours(binary: np.ndarray, settings: dict,
+                      scale: float) -> Tuple[List[VectorPolyline],
+                                              List[VectorCircle],
+                                              List[VectorArc]]:
+    polylines_out = []
+    circles_out   = []
+    arcs_out      = []
+
+    min_area  = settings.get("contour_min_area", 50)
+    epsilon_r = settings.get("contour_epsilon_ratio", 0.004)
+    h = binary.shape[0]
+
+    contours, hierarchy = cv2.findContours(binary, cv2.RETR_CCOMP,
+                                            cv2.CHAIN_APPROX_TC89_KCOS)
+    if hierarchy is None:
+        return polylines_out, circles_out, arcs_out
+
+    for i, cnt in enumerate(contours):
+        area = cv2.contourArea(cnt)
+        if area < min_area:
+            continue
+
+        # Try circle
+        circle = _is_circular(cnt)
+        if circle:
+            cx, cy, r = circle
+            circles_out.append(VectorCircle(
+                cx * scale, (h - cy) * scale, r * scale
+            ))
+            continue
+
+        # Approximate polygon / spline
+        peri    = cv2.arcLength(cnt, True)
+        epsilon = epsilon_r * peri
+        approx  = cv2.approxPolyDP(cnt, epsilon, True)
+        if len(approx) < 2:
+            continue
+
+        pts = [(p[0][0] * scale, (h - p[0][1]) * scale) for p in approx]
+        is_closed = (hierarchy[0][i][2] >= 0 or
+                     cv2.isContourConvex(approx) or
+                     len(pts) > 4)
+        polylines_out.append(VectorPolyline(pts, closed=is_closed))
+
+    return polylines_out, circles_out, arcs_out
+
+
+# ─── Line merging / deduplication ────────────────────────────────────────────
+
+def _line_angle(vl: VectorLine) -> float:
+    return math.atan2(vl.y2 - vl.y1, vl.x2 - vl.x1)
+
+
+def _line_length(vl: VectorLine) -> float:
+    return math.hypot(vl.x2 - vl.x1, vl.y2 - vl.y1)
+
+
+def _point_to_line_dist(px, py, x1, y1, x2, y2) -> float:
+    dx, dy = x2 - x1, y2 - y1
+    denom = math.hypot(dx, dy)
+    if denom < 1e-9:
+        return math.hypot(px - x1, py - y1)
+    return abs(dy * px - dx * py + x2 * y1 - y2 * x1) / denom
+
+
+def merge_lines(lines: List[VectorLine],
+                angle_tol: float = 3.0,
+                dist_tol: float = 2.5) -> List[VectorLine]:
+    """Merge nearly collinear line segments."""
+    if not lines:
+        return lines
+    angle_tol_rad = math.radians(angle_tol)
+    merged = []
+    used = [False] * len(lines)
+
+    for i, a in enumerate(lines):
+        if used[i]:
+            continue
+        ang_a = _line_angle(a) % math.pi
+        group = [a]
+        used[i] = True
+        for j, b in enumerate(lines):
+            if used[j]:
+                continue
+            ang_b = _line_angle(b) % math.pi
+            da = min(abs(ang_a - ang_b), math.pi - abs(ang_a - ang_b))
+            if da > angle_tol_rad:
+                continue
+            d = _point_to_line_dist(b.x1, b.y1, a.x1, a.y1, a.x2, a.y2)
+            if d > dist_tol:
+                continue
+            group.append(b)
+            used[j] = True
+
+        # Longest span in the group
+        pts = [(g.x1, g.y1) for g in group] + [(g.x2, g.y2) for g in group]
+        best_len = -1
+        bx1 = bx2 = by1 = by2 = 0.0
+        for p1 in pts:
+            for p2 in pts:
+                l = math.hypot(p2[0] - p1[0], p2[1] - p1[1])
+                if l > best_len:
+                    best_len = l
+                    bx1, by1 = p1
+                    bx2, by2 = p2
+        merged.append(VectorLine(bx1, by1, bx2, by2))
+    return merged
+
+
+# ─── Main conversion pipeline ────────────────────────────────────────────────
+
+DEFAULT_SETTINGS = {
+    "upscale":               2.0,
+    "denoise_h":             6,
+    "adaptive_block":        51,
+    "adaptive_C":            10,
+    "morph_open":            2,
+    "morph_close":           3,
+    "hough_rho":             1,
+    "hough_theta_deg":       0.5,
+    "hough_threshold":       25,
+    "hough_min_len":         18,
+    "hough_max_gap":         10,
+    "contour_min_area":      40,
+    "contour_epsilon_ratio": 0.003,
+    "merge_angle_tol":       2.5,
+    "merge_dist_tol":        3.0,
+    "output_scale_mm":       0.1,    # 1 px in output image → 0.1 mm
+}
+
+
+def convert(input_path: str,
+            output_path: str,
+            settings: dict = None,
+            progress_cb=None) -> dict:
+    """Full conversion pipeline. Returns stats dict."""
+    s = {**DEFAULT_SETTINGS, **(settings or {})}
+
+    def progress(msg, pct):
+        if progress_cb:
+            progress_cb(msg, pct)
+        else:
+            print(f"  [{pct:3d}%] {msg}")
+
+    # ── Load ──────────────────────────────────────────────────────
+    progress("Loading image…", 5)
+    img = cv2.imread(input_path)
+    if img is None:
+        raise FileNotFoundError(f"Cannot load: {input_path}")
+    h0, w0 = img.shape[:2]
+
+    # ── Preprocess ────────────────────────────────────────────────
+    progress("Preprocessing (denoise + threshold)…", 15)
+    binary, gray = preprocess(img, s)
+    h_up, w_up = binary.shape[:2]
+    scale = s["output_scale_mm"] / s["upscale"]   # px (upscaled) → mm
+
+    # ── Thin ──────────────────────────────────────────────────────
+    progress("Thinning / skeletonising…", 28)
+    thin = thin_image(binary)
+
+    # ── Hough lines ───────────────────────────────────────────────
+    progress("Extracting straight lines (Hough)…", 40)
+    raw_lines = extract_hough_lines(thin, s, scale)
+
+    # ── Merge ─────────────────────────────────────────────────────
+    progress("Merging collinear segments…", 52)
+    merged_lines = merge_lines(raw_lines,
+                                angle_tol=s["merge_angle_tol"],
+                                dist_tol=s["merge_dist_tol"])
+
+    # ── Contours ──────────────────────────────────────────────────
+    progress("Extracting contours, circles, arcs…", 64)
+    polylines, circles, arcs = extract_contours(binary, s, scale)
+
+    result = VectorResult(
+        lines=merged_lines,
+        polylines=polylines,
+        circles=circles,
+        arcs=arcs,
+        width_px=w0,
+        height_px=h0,
+        scale=scale,
+    )
+
+    # ── Write DXF ─────────────────────────────────────────────────
+    progress("Writing DXF…", 80)
+    write_dxf(result, output_path)
+
+    stats = {
+        "lines":     len(result.lines),
+        "polylines": len(result.polylines),
+        "circles":   len(result.circles),
+        "arcs":      len(result.arcs),
+        "source_w":  w0,
+        "source_h":  h0,
+    }
+    progress("Done ✓", 100)
+    return stats
+
+
+# ─── DXF writer ──────────────────────────────────────────────────────────────
+
+LAYER_COLORS = {
+    "LINES":    7,   # white/black
+    "CONTOURS": 3,   # green
+    "CIRCLES":  4,   # cyan
+    "ARCS":     1,   # red
+    "TEXT":     2,   # yellow
+}
+
+
+def write_dxf(result: VectorResult, path: str):
+    doc = ezdxf.new(dxfversion="R2010")
+    doc.units = units.MM
+    msp = doc.modelspace()
+
+    # Create layers
+    for name, color in LAYER_COLORS.items():
+        if name not in doc.layers:
+            doc.layers.add(name, dxfattribs={"color": color, "lineweight": 25})
+
+    # Lines
+    for vl in result.lines:
+        msp.add_line(
+            (vl.x1, vl.y1), (vl.x2, vl.y2),
+            dxfattribs={"layer": vl.layer}
+        )
+
+    # Polylines
+    for vp in result.polylines:
+        if len(vp.points) >= 2:
+            if vp.closed and len(vp.points) >= 3:
+                msp.add_lwpolyline(
+                    vp.points,
+                    close=True,
+                    dxfattribs={"layer": vp.layer}
+                )
+            else:
+                msp.add_lwpolyline(
+                    vp.points,
+                    close=False,
+                    dxfattribs={"layer": vp.layer}
+                )
+
+    # Circles
+    for vc in result.circles:
+        msp.add_circle(
+            (vc.cx, vc.cy), vc.r,
+            dxfattribs={"layer": vc.layer}
+        )
+
+    # Arcs
+    for va in result.arcs:
+        msp.add_arc(
+            (va.cx, va.cy), va.r,
+            va.start_angle, va.end_angle,
+            dxfattribs={"layer": va.layer}
+        )
+
+    # Texts
+    for vt in result.texts:
+        msp.add_text(
+            vt.text,
+            dxfattribs={"layer": vt.layer, "height": vt.height,
+                         "insert": (vt.x, vt.y)}
+        )
+
+    doc.saveas(path)
+
+
+# ─── CLI ─────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Raster-to-Vector converter: PNG → DXF")
+    parser.add_argument("input",  help="Input PNG/JPG/BMP path")
+    parser.add_argument("output", help="Output DXF path")
+    parser.add_argument("--upscale",      type=float, default=2.0)
+    parser.add_argument("--denoise",      type=int,   default=6)
+    parser.add_argument("--hough-min",    type=int,   default=18,
+                        dest="hough_min_len")
+    parser.add_argument("--hough-gap",    type=int,   default=10,
+                        dest="hough_max_gap")
+    parser.add_argument("--scale-mm",     type=float, default=0.1,
+                        dest="output_scale_mm",
+                        help="mm per source pixel (default 0.1)")
+    args = parser.parse_args()
+
+    settings = {
+        "upscale":           args.upscale,
+        "denoise_h":         args.denoise,
+        "hough_min_len":     args.hough_min_len,
+        "hough_max_gap":     args.hough_max_gap,
+        "output_scale_mm":   args.output_scale_mm,
+    }
+    stats = convert(args.input, args.output, settings)
+    print("\nConversion complete:")
+    for k, v in stats.items():
+        print(f"  {k}: {v}")

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+ezdxf
+opencv-python-headless
+scikit-image
+numpy
+scipy