Update README with 3D reconstruction docs and Space link

README.md

@@ -1,6 +1,8 @@
-# 🏠 Floor Plan Parser
+# 🏠 Floor Plan Parser + 3D Reconstruction
 
-Parse floor plan images into structured data — walls with thickness, doors, windows, and automatically detected rooms.
+Parse floor plan images into structured data — walls with thickness, doors, windows, and automatically detected rooms. Then generate interactive 3D models.
+
+**🎮 Try it live:** [rikhoffbauer2/floorplan-3d](https://huggingface.co/spaces/rikhoffbauer2/floorplan-3d)
 
 ## Architecture
 
@@ -31,15 +33,28 @@ Floor Plan Image (raster or vector)
 │     (VLM or human)           │  outputs field-level corrections
 └──────────────────────────────┘
        │
-       ▼  converged? ──no──→ back to step 1
+       ▼  converged? ──no──→ back to step 2
       yes
        ▼
-     Final structured schema (JSON)
+┌──────────────────────────────┐
+│  5. 3D RECONSTRUCTION        │  Extrude walls, cut openings,
+│     (trimesh + manifold3d)   │  add floors/ceilings → GLB
+└──────────────────────────────┘
+       ▼
+     Interactive 3D model (GLB/glTF)
 ```
 
-## The Schema
+## Modules
 
-Walls are first-class. Everything else references them.
+| File | Purpose |
+|------|---------|
+| `floorplan/schema.py` | Pydantic data models — `Wall`, `Opening`, `Room`, `FloorPlan`, `Correction` |
+| `floorplan/geometry.py` | Computational geometry — wall polygons, room detection, centerline ops |
+| `floorplan/renderer.py` | SVG + PIL rendering for visual verification and overlay |
+| `floorplan/parser.py` | VLM-based parsing with iterative correction loop |
+| `floorplan/reconstruction.py` | **NEW** — 3D mesh generation, boolean ops, GLB/OBJ export |
+
+## The Schema
 
 ```json
 {
@@ -49,76 +64,28 @@ Walls are first-class. Everything else references them.
       "centerline": [{"x": 0, "y": 0}, {"x": 6, "y": 0}],
       "thickness": 0.24,
       "openings": [
-        {
-          "id": "win1",
-          "type": "window",
-          "start": 1.5,
-          "length": 1.5
-        }
+        {"id": "win1", "type": "window", "start": 1.5, "length": 1.5}
       ]
     }
   ],
   "rooms": [
     {
-      "id": "r1",
-      "label": "bedroom",
-      "boundary": [
-        {"wall_id": "w1", "side": "right"},
-        {"wall_id": "w2", "side": "left"}
-      ],
+      "id": "r1", "label": "bedroom",
+      "boundary": [{"wall_id": "w1", "side": "right"}, {"wall_id": "w2", "side": "left"}],
       "area": 16.0
     }
   ]
 }
 ```
 
-**Key design decisions:**
-- **Walls have thickness** — exterior (0.20-0.30m) vs interior (0.10-0.15m)
-- **Openings live on walls** — `start` + `length` along the centerline
-- **Rooms are topological** — defined by ordered wall-face references (left/right side), not duplicate coordinates
-- **Curved walls** = polyline centerlines with many sample points
-- **Non-rectangular rooms** fully supported (any angles)
-
-## Modules
-
-| File | Purpose |
-|------|---------|
-| `floorplan/schema.py` | Pydantic data models — `Wall`, `Opening`, `Room`, `FloorPlan`, `Correction` |
-| `floorplan/geometry.py` | Computational geometry — wall polygons, room detection, centerline ops |
-| `floorplan/renderer.py` | SVG + PIL rendering for visual verification and overlay |
-| `floorplan/parser.py` | VLM-based parsing with iterative correction loop |
-
 ## Quick Start
 
 ### Demo (no API key needed)
 
-```bash
-pip install pydantic shapely numpy pillow
-python example.py --demo
-```
-
-Renders a 2-bedroom apartment with angled walls → `output/demo_floorplan.png` + `.svg` + `.json`
-
-### Parse a real floor plan
-
-```bash
-pip install pydantic shapely numpy pillow openai
-python example.py --image myfloorplan.png --api-key sk-...
-```
-
-Or with a local model (vLLM, Ollama, etc.):
-
-```bash
-python example.py --image myfloorplan.png --base-url http://localhost:8000/v1 --model qwen2.5-vl-72b
-```
-
-### Python API
-
 ```python
-from floorplan import FloorPlan, Wall, Opening, OpeningType, Point2D
-from floorplan import build_rooms, render_to_image, render_floorplan_svg
+from floorplan import *
 
-# Build a floor plan programmatically
+# Build a floor plan
 walls = [
     Wall(id="w1", centerline=[Point2D(x=0, y=0), Point2D(x=5, y=0)], thickness=0.24,
          openings=[Opening(id="d1", type=OpeningType.DOOR, start=1.0, length=0.9)]),
@@ -130,57 +97,59 @@ walls = [
 rooms, room_polygons = build_rooms(walls)
 fp = FloorPlan(walls=walls, rooms=rooms)
 
-# Render
+# 2D render
 img = render_to_image(fp, room_polygons=room_polygons)
 img.save("output.png")
 
-# Export SVG
-svg = render_floorplan_svg(fp, room_polygons=room_polygons)
-
-# Serialize to JSON
-print(fp.model_dump_json(indent=2))
+# 3D model
+scene = generate_3d_model(fp, room_polygons=room_polygons)
+export_glb(scene, "model.glb")  # Open in any 3D viewer or Three.js
 ```
 
-### VLM parsing with correction loop
+### Parse a real floor plan with VLM
 
 ```python
-from floorplan import parse_floorplan
+from floorplan import parse_floorplan, generate_3d_model, export_glb
 
+# Parse image → structured data (uses HF Inference API)
 fp, room_polygons, overlays = parse_floorplan(
     image="floorplan.png",
-    api_key="sk-...",
-    model="gpt-4o",
-    max_iterations=4,
+    api_key="hf_...",
+    base_url="https://router.huggingface.co/v1",
+    model="Qwen/Qwen2.5-VL-72B-Instruct",
+    max_iterations=3,
 )
 
-# overlays contains the render-on-original images for each iteration
-for i, overlay in enumerate(overlays):
-    overlay.save(f"overlay_{i}.png")
+# Generate 3D
+scene = generate_3d_model(fp, room_polygons=room_polygons, pixels_per_meter=100)
+export_glb(scene, "model.glb")
 ```
 
-## Features
+## 3D Output
 
-- ✅ **Wall thickness** — not just centerlines
-- ✅ **Non-rectangular rooms** — any angles
-- ✅ **Curved walls** — polyline approximation
-- ✅ **Automatic room detection** — from wall topology via Shapely
-- ✅ **Doors & windows** — parametric on walls
-- ✅ **SVG + PNG rendering** — dual output
-- ✅ **Overlay verification** — rendered schema composited on original
-- ✅ **Iterative VLM correction** — parse → render → compare → correct → repeat
-- ✅ **JSON serialization** — full Pydantic roundtrip
-- ✅ **Field-level corrections** — modify, add, delete walls/openings
+The 3D reconstruction generates:
+- **Walls** — extruded from 2D polygons, all walls boolean-unioned into a single watertight mesh
+- **Door openings** — cut through walls via boolean subtraction + door frame meshes
+- **Window openings** — cut at sill/head height + glass pane meshes
+- **Floor slabs** — per room, with wood material
+- **Ceilings** — per room, with white material
+- **PBR materials** — walls (warm white), floors (light wood), ceilings (white), glass (translucent blue)
+
+Export formats: **GLB** (web/Three.js), **glTF**, **OBJ**
 
 ## Dependencies
 
-**Core** (always needed):
+**Core:**
 - `pydantic` — schema validation
 - `shapely` — computational geometry
 - `numpy` — array ops
 - `pillow` — image rendering
 
-**VLM parsing** (optional):
-- `openai` — for VLM API calls (works with any OpenAI-compatible endpoint)
+**3D reconstruction:**
+- `trimesh[easy]` — mesh generation, boolean ops, GLB export (includes manifold3d)
+
+**VLM parsing (optional):**
+- `openai` — for VLM API calls
 
 ## License