🏠 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

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

{
  "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)

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

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