# 🏠 Floor Plan Parser + 3D Reconstruction

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

```
Floor Plan Image (raster or vector)
       │
       ▼
┌──────────────────────────────┐
│  1. INITIAL PARSE            │  VLM extracts walls/doors/windows
│     (VLM or vector parser)   │  into structured JSON schema
└──────────────────────────────┘
       │
       ▼
┌──────────────────────────────┐
│  2. COMPUTE TOPOLOGY         │  Derive rooms from wall faces
│     (computational geometry) │  via planar subdivision (Shapely)
└──────────────────────────────┘
       │
       ▼
┌──────────────────────────────┐
│  3. RENDER OVERLAY           │  Schema → SVG/PNG → alpha-composite
│     (PIL / SVG)              │  on original image for verification
└──────────────────────────────┘
       │
       ▼
┌──────────────────────────────┐
│  4. VERIFY & CORRECT         │  VLM sees overlay vs original,
│     (VLM or human)           │  outputs field-level corrections
└──────────────────────────────┘
       │
       ▼  converged? ──no──→ back to step 2
      yes
       ▼
┌──────────────────────────────┐
│  5. 3D RECONSTRUCTION        │  Extrude walls, cut openings,
│     (trimesh + manifold3d)   │  add floors/ceilings → GLB
└──────────────────────────────┘
       ▼
     Interactive 3D model (GLB/glTF)
```

## 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 |
| `floorplan/reconstruction.py` | **NEW** — 3D mesh generation, boolean ops, GLB/OBJ export |

## The Schema

```json
{
  "walls": [
    {
      "id": "w1",
      "centerline": [{"x": 0, "y": 0}, {"x": 6, "y": 0}],
      "thickness": 0.24,
      "openings": [
        {"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"}],
      "area": 16.0
    }
  ]
}
```

## Quick Start

### Demo (no API key needed)

```python
from floorplan import *

# 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)]),
    Wall(id="w2", centerline=[Point2D(x=5, y=0), Point2D(x=5, y=4)], thickness=0.24),
    Wall(id="w3", centerline=[Point2D(x=5, y=4), Point2D(x=0, y=4)], thickness=0.24),
    Wall(id="w4", centerline=[Point2D(x=0, y=4), Point2D(x=0, y=0)], thickness=0.24),
]

rooms, room_polygons = build_rooms(walls)
fp = FloorPlan(walls=walls, rooms=rooms)

# 2D render
img = render_to_image(fp, room_polygons=room_polygons)
img.save("output.png")

# 3D model
scene = generate_3d_model(fp, room_polygons=room_polygons)
export_glb(scene, "model.glb")  # Open in any 3D viewer or Three.js
```

### Parse a real floor plan with VLM

```python
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="hf_...",
    base_url="https://router.huggingface.co/v1",
    model="Qwen/Qwen2.5-VL-72B-Instruct",
    max_iterations=3,
)

# Generate 3D
scene = generate_3d_model(fp, room_polygons=room_polygons, pixels_per_meter=100)
export_glb(scene, "model.glb")
```

## 3D Output

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:**
- `pydantic` — schema validation
- `shapely` — computational geometry
- `numpy` — array ops
- `pillow` — image rendering

**3D reconstruction:**
- `trimesh[easy]` — mesh generation, boolean ops, GLB export (includes manifold3d)

**VLM parsing (optional):**
- `openai` — for VLM API calls

## License

MIT