Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -1,28 +1,28 @@
-name: Run Python script
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: '3.9'
-
-    - name: Install Gradio
-      run: python -m pip install gradio
-
-    - name: Log in to Hugging Face
-      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
-
-    - name: Deploy to Spaces
-      run: gradio deploy
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

main.py

@@ -1,206 +1,206 @@
-# yolo11_gradio_single_textlist_enhance.py
-from ultralytics import YOLO
-import gradio as gr
-import cv2, numpy as np, random
-
-DEFAULT_MODEL = "weights/best.pt"
-_MODEL_CACHE = {}
-
-def get_model(path:str):
-    if path not in _MODEL_CACHE:
-        _MODEL_CACHE[path] = YOLO(path)
-    return _MODEL_CACHE[path]
-
-# ---------- utilities ----------
-def class_color(cid:int):
-    random.seed(int(cid) + 12345)
-    return tuple(int(x) for x in np.array([random.randrange(60,255) for _ in range(3)]))
-
-def ensure_odd(v:int, minv:int=3):
-    v = int(v)
-    if v < minv: v = minv
-    if v % 2 == 0: v += 1
-    return v
-
-def to_bgr(img):
-    if len(img.shape) == 2:  # gray -> BGR
-        return cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-    return img
-
-# ---------- enhancements (applied in this order) ----------
-def enhance_image(img_bgr,
-                  use_gray: bool,
-                  use_clahe: bool, clahe_clip: float, clahe_grid: int,
-                  use_bc: bool, alpha_gain: float, beta_bias: float,
-                  use_unsharp: bool, us_amount: float, us_radius: float,
-                  use_thresh: bool, th_block: int, th_C: int,
-                  use_morph: bool, morph_k: int, morph_iters: int,
-                  use_invert: bool):
-    base = img_bgr.copy()
-    work_gray = None
-
-    if use_gray or use_clahe or use_thresh:
-        work_gray = cv2.cvtColor(base, cv2.COLOR_BGR2GRAY)
-
-    # CLAHE on gray
-    if use_clahe:
-        clahe = cv2.createCLAHE(clipLimit=float(clahe_clip),
-                                tileGridSize=(int(clahe_grid), int(clahe_grid)))
-        work_gray = clahe.apply(work_gray)
-
-    # Brightness/Contrast (linear gain/bias)
-    if use_bc:
-        if work_gray is not None:
-            work_gray = cv2.convertScaleAbs(work_gray, alpha=float(alpha_gain), beta=float(beta_bias))
-        else:
-            base = cv2.convertScaleAbs(base, alpha=float(alpha_gain), beta=float(beta_bias))
-
-    # Unsharp mask (detail boost)
-    if use_unsharp:
-        # apply on gray if exists, else on color
-        if work_gray is not None:
-            blur = cv2.GaussianBlur(work_gray, (0,0), sigmaX=float(us_radius), sigmaY=float(us_radius))
-            work_gray = cv2.addWeighted(work_gray, 1.0 + float(us_amount), blur, -float(us_amount), 0)
-        else:
-            blur = cv2.GaussianBlur(base, (0,0), sigmaX=float(us_radius), sigmaY=float(us_radius))
-            base = cv2.addWeighted(base, 1.0 + float(us_amount), blur, -float(us_amount), 0)
-
-    # Adaptive threshold (great for floor plans)
-    if use_thresh:
-        bs = ensure_odd(int(th_block), 3)
-        work_gray = cv2.adaptiveThreshold(
-            work_gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, bs, int(th_C)
-        )
-
-    # Merge back to BGR if we are working in gray
-    if work_gray is not None:
-        base = to_bgr(work_gray)
-
-    # Morphological clean-up (OPEN to remove speckles)
-    if use_morph:
-        k = max(1, int(morph_k))
-        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (k, k))
-        base = cv2.morphologyEx(base, cv2.MORPH_OPEN, kernel, iterations=int(morph_iters))
-
-    # Invert black/white (sometimes better for plans)
-    if use_invert:
-        base = cv2.bitwise_not(base)
-
-    return base
-
-# ---------- drawing ----------
-def draw_transparent_boxes(img_bgr, boxes, alpha=0.5):
-    overlay = img_bgr.copy()
-    if boxes is not None and len(boxes):
-        xyxy = boxes.xyxy.cpu().numpy()
-        cls  = boxes.cls.cpu().numpy().astype(int)
-        for bb, cl in zip(xyxy, cls):
-            x1, y1, x2, y2 = [int(round(v)) for v in bb]
-            cv2.rectangle(overlay, (x1, y1), (x2, y2), class_color(cl), thickness=-1)
-    return cv2.addWeighted(overlay, float(alpha), img_bgr, 1 - float(alpha), 0.0)
-
-def detections_to_text(result):
-    if result.boxes is None or len(result.boxes) == 0:
-        return "Detections: 0"
-    names = result.names
-    xyxy = result.boxes.xyxy.cpu().numpy()
-    conf = result.boxes.conf.cpu().numpy()
-    cls  = result.boxes.cls.cpu().numpy().astype(int)
-    lines = [f"{i:02d}. {names.get(int(c), str(int(c)))}\t{cf:.2f}\t[{int(x1)},{int(y1)},{int(x2)},{int(y2)}]"
-             for i, ((x1,y1,x2,y2), cf, c) in enumerate(zip(xyxy, conf, cls), start=1)]
-    return "Detections: " + str(len(lines)) + "\n" + "\n".join(lines)
-
-# ---------- main inference ----------
-def infer(img_rgb, model_path, conf, iou, alpha,
-          # toggles
-          use_gray, use_clahe, use_bc, use_unsharp, use_thresh, use_morph, use_invert,
-          detect_on_enh,
-          # params
-          clahe_clip, clahe_grid,
-          alpha_gain, beta_bias,
-          us_amount, us_radius,
-          th_block, th_C,
-          morph_k, morph_iters):
-    if img_rgb is None:
-        return None, "Upload an image to run inference."
-
-    model = get_model(model_path)
-    img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
-
-    # Enhance image for visualization (and optionally for detection)
-    enh_bgr = enhance_image(
-        img_bgr,
-        use_gray, use_clahe, clahe_clip, int(clahe_grid),
-        use_bc, alpha_gain, beta_bias,
-        use_unsharp, us_amount, us_radius,
-        use_thresh, int(th_block), int(th_C),
-        use_morph, int(morph_k), int(morph_iters),
-        use_invert
-    )
-
-    det_input = enh_bgr if detect_on_enh else img_bgr
-    r = model.predict(det_input, conf=float(conf), iou=float(iou), verbose=False)[0]
-
-    # Draw only transparent boxes (no labels)
-    out_bgr = draw_transparent_boxes(enh_bgr, r.boxes, alpha=float(alpha))
-    out_rgb = cv2.cvtColor(out_bgr, cv2.COLOR_BGR2RGB)
-
-    # Detection list in textbox
-    det_text = detections_to_text(r)
-    return out_rgb, det_text
-
-# ---------- UI ----------
-with gr.Blocks(title="YOLOv11 — Split View with Floor-Plan Enhancers") as demo:
-    gr.Markdown("## MW Floor Plan")
-    with gr.Row():
-        with gr.Column(scale=1):
-            inp = gr.Image(type="numpy", label="Upload image", height=520)
-            model_path = gr.Textbox(value=DEFAULT_MODEL, label="Model (.pt)")
-            with gr.Row():
-                conf  = gr.Slider(0, 1, value=0.25, step=0.01, label="Confidence")
-                iou   = gr.Slider(0, 1, value=0.45, step=0.01, label="IoU")
-                alpha = gr.Slider(0, 1, value=0.50, step=0.05, label="Box transparency")
-        with gr.Column(scale=1):
-            out_img = gr.Image(label="Result (enhanced + transparent boxes)", height=520)
-            det_box = gr.Textbox(label="Detections (class, conf, [x1,y1,x2,y2])",
-                                 lines=12, interactive=False)
-
-    gr.Markdown("### Enhancements (tick to enable) — ordered top→bottom for best floor-plan contrast")
-    with gr.Row():
-        use_gray     = gr.Checkbox(value=True,  label="Grayscale")
-        use_clahe    = gr.Checkbox(value=False, label="Auto-contrast (CLAHE)")
-        use_bc       = gr.Checkbox(value=False, label="Brightness/Contrast")
-        use_unsharp  = gr.Checkbox(value=True,  label="Unsharp mask (sharpen)")
-        use_thresh   = gr.Checkbox(value=False, label="Adaptive threshold (binarize)")
-        use_morph    = gr.Checkbox(value=False, label="Morphological clean-up (OPEN)")
-        use_invert   = gr.Checkbox(value=False, label="Invert B/W")
-        detect_on_enh= gr.Checkbox(value=True,  label="Run detection on enhanced image")
-
-    with gr.Row():
-        clahe_clip = gr.Slider(1.0, 6.0, value=2.0, step=0.1, label="CLAHE clipLimit")
-        clahe_grid = gr.Slider(4, 16, value=8, step=1, label="CLAHE tileGridSize")
-        alpha_gain = gr.Slider(0.5, 2.0, value=1.2, step=0.05, label="Contrast gain (alpha)")
-        beta_bias  = gr.Slider(-64, 64, value=0, step=1, label="Brightness bias (beta)")
-    with gr.Row():
-        us_amount  = gr.Slider(0.0, 2.0, value=0.8, step=0.05, label="Unsharp amount")
-        us_radius  = gr.Slider(0.3, 5.0, value=1.2, step=0.1, label="Unsharp radius (sigma)")
-        th_block   = gr.Slider(3, 51, value=25, step=2, label="Adaptive block size (odd)")
-        th_C       = gr.Slider(-15, 15, value=5, step=1, label="Adaptive C")
-    with gr.Row():
-        morph_k     = gr.Slider(1, 9, value=3, step=1, label="Morph kernel size")
-        morph_iters = gr.Slider(0, 5, value=1, step=1, label="Morph iterations")
-
-    run = gr.Button("Run")
-    # wire events
-    inputs = [inp, model_path, conf, iou, alpha,
-              use_gray, use_clahe, use_bc, use_unsharp, use_thresh, use_morph, use_invert,
-              detect_on_enh,
-              clahe_clip, clahe_grid, alpha_gain, beta_bias, us_amount, us_radius,
-              th_block, th_C, morph_k, morph_iters]
-    outputs = [out_img, det_box]
-
-    run.click(infer, inputs, outputs)
-    inp.change(infer, inputs, outputs)   # auto-run on upload
-
-if __name__ == "__main__":
-    demo.launch(share=True)
+# yolo11_gradio_single_textlist_enhance.py
+from ultralytics import YOLO
+import gradio as gr
+import cv2, numpy as np, random
+
+DEFAULT_MODEL = "weights/best.pt"
+_MODEL_CACHE = {}
+
+def get_model(path:str):
+    if path not in _MODEL_CACHE:
+        _MODEL_CACHE[path] = YOLO(path)
+    return _MODEL_CACHE[path]
+
+# ---------- utilities ----------
+def class_color(cid:int):
+    random.seed(int(cid) + 12345)
+    return tuple(int(x) for x in np.array([random.randrange(60,255) for _ in range(3)]))
+
+def ensure_odd(v:int, minv:int=3):
+    v = int(v)
+    if v < minv: v = minv
+    if v % 2 == 0: v += 1
+    return v
+
+def to_bgr(img):
+    if len(img.shape) == 2:  # gray -> BGR
+        return cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+    return img
+
+# ---------- enhancements (applied in this order) ----------
+def enhance_image(img_bgr,
+                  use_gray: bool,
+                  use_clahe: bool, clahe_clip: float, clahe_grid: int,
+                  use_bc: bool, alpha_gain: float, beta_bias: float,
+                  use_unsharp: bool, us_amount: float, us_radius: float,
+                  use_thresh: bool, th_block: int, th_C: int,
+                  use_morph: bool, morph_k: int, morph_iters: int,
+                  use_invert: bool):
+    base = img_bgr.copy()
+    work_gray = None
+
+    if use_gray or use_clahe or use_thresh:
+        work_gray = cv2.cvtColor(base, cv2.COLOR_BGR2GRAY)
+
+    # CLAHE on gray
+    if use_clahe:
+        clahe = cv2.createCLAHE(clipLimit=float(clahe_clip),
+                                tileGridSize=(int(clahe_grid), int(clahe_grid)))
+        work_gray = clahe.apply(work_gray)
+
+    # Brightness/Contrast (linear gain/bias)
+    if use_bc:
+        if work_gray is not None:
+            work_gray = cv2.convertScaleAbs(work_gray, alpha=float(alpha_gain), beta=float(beta_bias))
+        else:
+            base = cv2.convertScaleAbs(base, alpha=float(alpha_gain), beta=float(beta_bias))
+
+    # Unsharp mask (detail boost)
+    if use_unsharp:
+        # apply on gray if exists, else on color
+        if work_gray is not None:
+            blur = cv2.GaussianBlur(work_gray, (0,0), sigmaX=float(us_radius), sigmaY=float(us_radius))
+            work_gray = cv2.addWeighted(work_gray, 1.0 + float(us_amount), blur, -float(us_amount), 0)
+        else:
+            blur = cv2.GaussianBlur(base, (0,0), sigmaX=float(us_radius), sigmaY=float(us_radius))
+            base = cv2.addWeighted(base, 1.0 + float(us_amount), blur, -float(us_amount), 0)
+
+    # Adaptive threshold (great for floor plans)
+    if use_thresh:
+        bs = ensure_odd(int(th_block), 3)
+        work_gray = cv2.adaptiveThreshold(
+            work_gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, bs, int(th_C)
+        )
+
+    # Merge back to BGR if we are working in gray
+    if work_gray is not None:
+        base = to_bgr(work_gray)
+
+    # Morphological clean-up (OPEN to remove speckles)
+    if use_morph:
+        k = max(1, int(morph_k))
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (k, k))
+        base = cv2.morphologyEx(base, cv2.MORPH_OPEN, kernel, iterations=int(morph_iters))
+
+    # Invert black/white (sometimes better for plans)
+    if use_invert:
+        base = cv2.bitwise_not(base)
+
+    return base
+
+# ---------- drawing ----------
+def draw_transparent_boxes(img_bgr, boxes, alpha=0.5):
+    overlay = img_bgr.copy()
+    if boxes is not None and len(boxes):
+        xyxy = boxes.xyxy.cpu().numpy()
+        cls  = boxes.cls.cpu().numpy().astype(int)
+        for bb, cl in zip(xyxy, cls):
+            x1, y1, x2, y2 = [int(round(v)) for v in bb]
+            cv2.rectangle(overlay, (x1, y1), (x2, y2), class_color(cl), thickness=-1)
+    return cv2.addWeighted(overlay, float(alpha), img_bgr, 1 - float(alpha), 0.0)
+
+def detections_to_text(result):
+    if result.boxes is None or len(result.boxes) == 0:
+        return "Detections: 0"
+    names = result.names
+    xyxy = result.boxes.xyxy.cpu().numpy()
+    conf = result.boxes.conf.cpu().numpy()
+    cls  = result.boxes.cls.cpu().numpy().astype(int)
+    lines = [f"{i:02d}. {names.get(int(c), str(int(c)))}\t{cf:.2f}\t[{int(x1)},{int(y1)},{int(x2)},{int(y2)}]"
+             for i, ((x1,y1,x2,y2), cf, c) in enumerate(zip(xyxy, conf, cls), start=1)]
+    return "Detections: " + str(len(lines)) + "\n" + "\n".join(lines)
+
+# ---------- main inference ----------
+def infer(img_rgb, model_path, conf, iou, alpha,
+          # toggles
+          use_gray, use_clahe, use_bc, use_unsharp, use_thresh, use_morph, use_invert,
+          detect_on_enh,
+          # params
+          clahe_clip, clahe_grid,
+          alpha_gain, beta_bias,
+          us_amount, us_radius,
+          th_block, th_C,
+          morph_k, morph_iters):
+    if img_rgb is None:
+        return None, "Upload an image to run inference."
+
+    model = get_model(model_path)
+    img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+
+    # Enhance image for visualization (and optionally for detection)
+    enh_bgr = enhance_image(
+        img_bgr,
+        use_gray, use_clahe, clahe_clip, int(clahe_grid),
+        use_bc, alpha_gain, beta_bias,
+        use_unsharp, us_amount, us_radius,
+        use_thresh, int(th_block), int(th_C),
+        use_morph, int(morph_k), int(morph_iters),
+        use_invert
+    )
+
+    det_input = enh_bgr if detect_on_enh else img_bgr
+    r = model.predict(det_input, conf=float(conf), iou=float(iou), verbose=False)[0]
+
+    # Draw only transparent boxes (no labels)
+    out_bgr = draw_transparent_boxes(enh_bgr, r.boxes, alpha=float(alpha))
+    out_rgb = cv2.cvtColor(out_bgr, cv2.COLOR_BGR2RGB)
+
+    # Detection list in textbox
+    det_text = detections_to_text(r)
+    return out_rgb, det_text
+
+# ---------- UI ----------
+with gr.Blocks(title="YOLOv11 — Split View with Floor-Plan Enhancers") as demo:
+    gr.Markdown("## MW Floor Plan")
+    with gr.Row():
+        with gr.Column(scale=1):
+            inp = gr.Image(type="numpy", label="Upload image", height=520)
+            model_path = gr.Textbox(value=DEFAULT_MODEL, label="Model (.pt)")
+            with gr.Row():
+                conf  = gr.Slider(0, 1, value=0.25, step=0.01, label="Confidence")
+                iou   = gr.Slider(0, 1, value=0.45, step=0.01, label="IoU")
+                alpha = gr.Slider(0, 1, value=0.50, step=0.05, label="Box transparency")
+        with gr.Column(scale=1):
+            out_img = gr.Image(label="Result (enhanced + transparent boxes)", height=520)
+            det_box = gr.Textbox(label="Detections (class, conf, [x1,y1,x2,y2])",
+                                 lines=12, interactive=False)
+
+    gr.Markdown("### Enhancements (tick to enable) — ordered top→bottom for best floor-plan contrast")
+    with gr.Row():
+        use_gray     = gr.Checkbox(value=True,  label="Grayscale")
+        use_clahe    = gr.Checkbox(value=False, label="Auto-contrast (CLAHE)")
+        use_bc       = gr.Checkbox(value=False, label="Brightness/Contrast")
+        use_unsharp  = gr.Checkbox(value=True,  label="Unsharp mask (sharpen)")
+        use_thresh   = gr.Checkbox(value=False, label="Adaptive threshold (binarize)")
+        use_morph    = gr.Checkbox(value=False, label="Morphological clean-up (OPEN)")
+        use_invert   = gr.Checkbox(value=False, label="Invert B/W")
+        detect_on_enh= gr.Checkbox(value=True,  label="Run detection on enhanced image")
+
+    with gr.Row():
+        clahe_clip = gr.Slider(1.0, 6.0, value=2.0, step=0.1, label="CLAHE clipLimit")
+        clahe_grid = gr.Slider(4, 16, value=8, step=1, label="CLAHE tileGridSize")
+        alpha_gain = gr.Slider(0.5, 2.0, value=1.2, step=0.05, label="Contrast gain (alpha)")
+        beta_bias  = gr.Slider(-64, 64, value=0, step=1, label="Brightness bias (beta)")
+    with gr.Row():
+        us_amount  = gr.Slider(0.0, 2.0, value=0.8, step=0.05, label="Unsharp amount")
+        us_radius  = gr.Slider(0.3, 5.0, value=1.2, step=0.1, label="Unsharp radius (sigma)")
+        th_block   = gr.Slider(3, 51, value=25, step=2, label="Adaptive block size (odd)")
+        th_C       = gr.Slider(-15, 15, value=5, step=1, label="Adaptive C")
+    with gr.Row():
+        morph_k     = gr.Slider(1, 9, value=3, step=1, label="Morph kernel size")
+        morph_iters = gr.Slider(0, 5, value=1, step=1, label="Morph iterations")
+
+    run = gr.Button("Run")
+    # wire events
+    inputs = [inp, model_path, conf, iou, alpha,
+              use_gray, use_clahe, use_bc, use_unsharp, use_thresh, use_morph, use_invert,
+              detect_on_enh,
+              clahe_clip, clahe_grid, alpha_gain, beta_bias, us_amount, us_radius,
+              th_block, th_C, morph_k, morph_iters]
+    outputs = [out_img, det_box]
+
+    run.click(infer, inputs, outputs)
+    inp.change(infer, inputs, outputs)   # auto-run on upload
+
+if __name__ == "__main__":
+    demo.launch(share=True)

requirements.txt

@@ -0,0 +1,3 @@
+ultralytics
+gradio 
+opencv-python