Purged CV model deployment

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,46 @@
+# Stage 1: Build Frontend
+FROM node:20-slim AS frontend-build
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ ./
+RUN npm run build
+
+# Stage 2: Final Image
+FROM python:3.10-slim
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    tesseract-ocr \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy backend code and modules
+COPY src/ ./src/
+COPY models/ ./models/
+COPY api.py .
+COPY endToEnd2.py .
+
+# Copy built frontend from stage 1
+COPY --from=frontend-build /app/frontend/dist ./frontend/dist
+
+# Set environment variables
+ENV PORT=7860
+ENV MPLBACKEND=Agg
+ENV HOME=/tmp
+
+# Create necessary directories and set permissions
+RUN mkdir -p samples generated_models outputs && \
+    chmod -R 777 samples generated_models outputs && \
+    chmod -R 777 /app
+
+EXPOSE 7860
+
+# Run the app
+CMD ["python", "api.py"]

api.py

@@ -0,0 +1,90 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+import os
+import shutil
+from pathlib import Path
+import uuid
+import sys
+
+# Import the existing pipeline
+from endToEnd2 import run_pipeline
+
+app = FastAPI(title="Floor2Model API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+GENERATED_DIR = PROJECT_ROOT / "generated_models"
+SAMPLES_DIR = PROJECT_ROOT / "samples"
+FRONTEND_DIST = PROJECT_ROOT / "frontend" / "dist"
+
+SAMPLES_DIR.mkdir(exist_ok=True)
+GENERATED_DIR.mkdir(exist_ok=True)
+
+# Mount static files to serve the generated models directly
+app.mount("/generated_models", StaticFiles(directory=str(GENERATED_DIR)), name="generated_models")
+
+@app.post("/upload")
+async def upload_image(file: UploadFile = File(...)):
+    try:
+        # Generate a unique ID for this upload
+        file_id = str(uuid.uuid4())[:8]
+        file_ext = Path(file.filename).suffix
+        if not file_ext:
+            file_ext = ".png"
+        
+        stem = f"upload_{file_id}"
+        save_path = SAMPLES_DIR / f"{stem}{file_ext}"
+        
+        with open(save_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+            
+        return {"status": "success", "id": stem, "filename": file.filename}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/process/{stem}")
+async def process_image(stem: str):
+    # Find the file in samples
+    sample_files = list(SAMPLES_DIR.glob(f"{stem}.*"))
+    if not sample_files:
+        raise HTTPException(status_code=404, detail="File not found")
+        
+    sample_image = sample_files[0]
+    out_dir = GENERATED_DIR / stem
+    
+    try:
+        # Run the actual pipeline
+        run_pipeline(sample_image)
+        
+        if not out_dir.exists() or not list(out_dir.glob("*")):
+            raise HTTPException(status_code=500, detail="Processing failed to generate output")
+            
+        return {
+            "status": "success", 
+            "results": {
+                "detections": f"/generated_models/{stem}/{stem}_detections.png",
+                "gltf": f"/generated_models/{stem}/{stem}.gltf",
+                "obj": f"/generated_models/{stem}/{stem}.obj",
+            }
+        }
+        
+    except Exception as e:
+        print(f"Error processing {stem}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Serve frontend
+if FRONTEND_DIST.exists():
+    app.mount("/", StaticFiles(directory=str(FRONTEND_DIST), html=True), name="frontend")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

endToEnd2.py

@@ -0,0 +1,93 @@
+import cv2
+import os
+import sys
+import shutil
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+os.chdir(PROJECT_ROOT)
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.segmentation.predictor import FloorPlanPredictor
+from src.segmentation.visualizer import SegmentationVisualizer
+from src.geometry.pipeline import GeometryPipeline
+from src.reconstruction.pipeline import ReconstructionPipeline
+
+# Auto-detect device
+import torch
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device: {DEVICE}")
+
+MODEL_PATH    = PROJECT_ROOT / "models" / "best.pt"
+OUTPUTS_DIR   = PROJECT_ROOT / "outputs"
+GENERATED_DIR = PROJECT_ROOT / "generated_models"
+
+def run_pipeline(sample_image: Path):
+    stem = sample_image.stem
+
+    print(f"\n{'='*60}")
+    print(f"Processing: {sample_image.name}")
+    print(f"{'='*60}")
+
+    # ── Phase 2: Segmentation ──────────────────────────────────────────
+    print(f"\n[Phase 2] Segmentation on {DEVICE}...")
+    best_conf   = None
+    best_result = None
+
+    for conf in [0.35, 0.25, 0.15, 0.10, 0.05]:
+        predictor  = FloorPlanPredictor(str(MODEL_PATH), confidence=conf, device=DEVICE)
+        seg_result = predictor.predict(str(sample_image))
+        total      = seg_result.summary["total_elements"]
+        if total > 0 and best_result is None:
+            best_conf   = conf
+            best_result = seg_result
+
+    base_img = cv2.imread(str(sample_image), cv2.IMREAD_COLOR)
+    out_dir  = GENERATED_DIR / stem
+    if out_dir.exists():
+        shutil.rmtree(out_dir)
+    out_dir.mkdir(parents=True)
+
+    ann_path = out_dir / f"{stem}_detections.png"
+
+    if best_result is None:
+        print("  ⚠ No elements detected.")
+        if base_img is not None:
+            cv2.imwrite(str(ann_path), base_img)
+        return
+
+    viz       = SegmentationVisualizer()
+    annotated = viz.draw(base_img, best_result)
+    cv2.imwrite(str(ann_path), annotated)
+
+    # ── Phase 3: Geometry ─────────────────────────────────────────────
+    print("\n[Phase 3] Geometry reconstruction...")
+    img = cv2.imread(str(sample_image))
+    geo_result, _, _ = GeometryPipeline().run_and_visualize(
+        best_result, img,
+        image_path=str(sample_image),
+        output_dir=str(OUTPUTS_DIR / "geometry"),
+    )
+
+    # ── Phase 4: 3D Reconstruction ────────────────────────────────────
+    print("\n[Phase 4] 3D reconstruction...")
+
+    has_polygons = len(geo_result.vectorization.all_polygons) > 0
+    if not has_polygons:
+        print("  ⚠ No geometry to extrude — skipping 3D.")
+        return
+
+    model_3d = ReconstructionPipeline().reconstruct(
+        geo_result,
+        output_dir=str(out_dir),
+        stem=stem,
+        floorplan_image_path=str(sample_image),
+        render_image_path=None
+    )
+    print(f"  ✓ {model_3d.summary}")
+
+if __name__ == "__main__":
+    samples_dir = PROJECT_ROOT / "samples"
+    samples = sorted(list(samples_dir.glob("*.png")) + list(samples_dir.glob("*.jpg")))
+    for sample in samples:
+        run_pipeline(sample)

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.

frontend/eslint.config.js

@@ -0,0 +1,21 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      globals: globals.browser,
+      parserOptions: { ecmaFeatures: { jsx: true } },
+    },
+  },
+])

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>frontend</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@google/model-viewer": "^4.2.0",
+    "axios": "^1.15.2",
+    "framer-motion": "^12.38.0",
+    "lucide-react": "^1.11.0",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "eslint": "^10.2.1",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.5.0",
+    "vite": "^8.0.10"
+  }
+}

frontend/public/bg-video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e932a47117072aa9190e723e678510ff1758e329901bf60780c5f29d6cd3a945
+size 8875980

frontend/src/App.css

@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,160 @@
+import React, { useState } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import { UploadCloud, Layers, Cuboid, RotateCw, CheckCircle2 } from 'lucide-react';
+import axios from 'axios';
+import '@google/model-viewer';
+
+const API_BASE = ''; // Use relative paths for co-located serving
+
+function App() {
+  const [file, setFile] = useState(null);
+  const [status, setStatus] = useState('landing'); // landing, idle, uploading, processing, done, error
+  const [results, setResults] = useState(null);
+  const [errorMsg, setErrorMsg] = useState('');
+
+  const handleDrop = (e) => {
+    e.preventDefault();
+    const droppedFile = e.dataTransfer.files[0];
+    if (droppedFile && droppedFile.type.startsWith('image/')) {
+      setFile(droppedFile);
+    }
+  };
+
+  const handleUpload = async () => {
+    if (!file) return;
+    
+    try {
+      setStatus('uploading');
+      const formData = new FormData();
+      formData.append('file', file);
+      
+      const uploadRes = await axios.post(`${API_BASE}/upload`, formData);
+      const stem = uploadRes.data.id;
+      
+      setStatus('processing');
+      const processRes = await axios.post(`${API_BASE}/process/${stem}`, {}, { timeout: 600000 });
+      
+      setResults(processRes.data.results);
+      setStatus('done');
+    } catch (error) {
+      console.error(error);
+      setErrorMsg(error.response?.data?.detail || error.message);
+      setStatus('error');
+    }
+  };
+
+  const reset = () => {
+    setFile(null);
+    setResults(null);
+    setStatus('idle');
+    setErrorMsg('');
+  };
+
+  return (
+    <>
+      <video 
+        autoPlay 
+        loop 
+        muted 
+        playsInline
+        className={`bg-video ${(status === 'processing' || status === 'done') ? 'hidden' : ''}`}
+      >
+        <source src="/bg-video.mp4" type="video/mp4" />
+      </video>
+
+      <div className="app-container">
+        {status !== 'landing' && (
+          <motion.header 
+            initial={{ opacity: 0, y: -20 }}
+            animate={{ opacity: 1, y: 0 }}
+            transition={{ duration: 0.8 }}
+          >
+            <h1>Floor2Model</h1>
+            <p className="subtitle">
+              Transform 2D floor plans into interactive 3D environments instantly.
+            </p>
+          </motion.header>
+        )}
+
+        <main>
+          <AnimatePresence mode="wait">
+            {status === 'landing' ? (
+              <motion.div 
+                key="landing"
+                initial={{ opacity: 0 }}
+                animate={{ opacity: 1 }}
+                exit={{ opacity: 0 }}
+                className="landing-container"
+              >
+                <h1 className="landing-title">Floor2Plan</h1>
+                <p className="landing-description">
+                  Upload any 2D blueprint and instantly reconstruct a fully interactive 3D model.
+                </p>
+                <button className="landing-btn" onClick={() => setStatus('idle')}>
+                  Enter Studio
+                </button>
+              </motion.div>
+            ) : status === 'idle' || status === 'uploading' || status === 'error' ? (
+              <motion.div 
+                key="upload"
+                initial={{ opacity: 0, scale: 0.9 }}
+                animate={{ opacity: 1, scale: 1 }}
+                className="dropzone-container"
+              >
+                <div 
+                  className={`dropzone glass-panel ${file ? 'active' : ''}`}
+                  onDragOver={(e) => e.preventDefault()}
+                  onDrop={handleDrop}
+                  onClick={() => document.getElementById('file-upload').click()}
+                >
+                  <input type="file" id="file-upload" hidden onChange={(e) => setFile(e.target.files[0])} />
+                  {file ? <CheckCircle2 size={60} color="#10b981" /> : <UploadCloud size={60} color="#6366f1" />}
+                  <p className="dropzone-text">{file ? file.name : "Drop floorplan here"}</p>
+                </div>
+
+                <div style={{ display: 'flex', justifyContent: 'center', marginTop: '2rem' }}>
+                  <button className="btn" onClick={handleUpload} disabled={!file || status === 'uploading'}>
+                    {status === 'uploading' ? <RotateCw className="animate-spin" /> : "Reconstruct"}
+                  </button>
+                </div>
+                {errorMsg && <p style={{ color: '#ef4444', textAlign: 'center', marginTop: '1rem' }}>{errorMsg}</p>}
+              </motion.div>
+            ) : status === 'processing' ? (
+              <motion.div key="processing" className="loader-container">
+                <div className="spinner"></div>
+                <p>Analyzing geometry and generating mesh...</p>
+              </motion.div>
+            ) : (
+              <motion.div key="results" className="results-container">
+                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+                  <h2>Reconstruction Complete</h2>
+                  <button className="btn" onClick={reset}>New Project</button>
+                </div>
+
+                <div className="result-card glass-panel viewer-3d">
+                  <model-viewer 
+                    src={`${API_BASE}${results?.gltf}`}
+                    camera-controls auto-rotate shadow-intensity="1"
+                    style={{ width: '100%', height: '600px' }}
+                  ></model-viewer>
+                </div>
+
+                <div className="results-grid" style={{ gridTemplateColumns: '1fr' }}>
+                  <div className="result-card glass-panel">
+                    <div className="result-card-header">
+                      <Layers size={20} color="var(--secondary)" />
+                      <span className="result-card-title">Detection Map</span>
+                    </div>
+                    <img src={`${API_BASE}${results?.detections}`} alt="Map" style={{ width: '100%', borderRadius: '8px' }} />
+                  </div>
+                </div>
+              </motion.div>
+            )}
+          </AnimatePresence>
+        </main>
+      </div>
+    </>
+  );
+}
+
+export default App;

frontend/src/index.css

@@ -0,0 +1,343 @@
+@import url('https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700&display=swap');
+
+:root {
+  --bg-color: #050505;
+  --text-color: #f1f1f1;
+  --primary: #6366f1;
+  --primary-glow: rgba(99, 102, 241, 0.5);
+  --secondary: #ec4899;
+  --glass-bg: rgba(255, 255, 255, 0.03);
+  --glass-border: rgba(255, 255, 255, 0.05);
+  --glass-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.37);
+  --radius: 16px;
+}
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: 'Outfit', sans-serif;
+  background-color: var(--bg-color);
+  color: var(--text-color);
+  min-height: 100vh;
+  overflow-x: hidden;
+  background-image: 
+    radial-gradient(circle at 15% 50%, rgba(99, 102, 241, 0.15), transparent 25%),
+    radial-gradient(circle at 85% 30%, rgba(236, 72, 153, 0.15), transparent 25%);
+  background-attachment: fixed;
+}
+
+.glass-panel {
+  background: var(--glass-bg);
+  backdrop-filter: blur(12px);
+  -webkit-backdrop-filter: blur(12px);
+  border: 1px solid var(--glass-border);
+  border-radius: var(--radius);
+  box-shadow: var(--glass-shadow);
+}
+
+.app-container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 2rem;
+  display: flex;
+  flex-direction: column;
+  gap: 3rem;
+}
+
+/* Header */
+header {
+  text-align: center;
+  margin-top: 4rem;
+  margin-bottom: 2rem;
+}
+
+h1 {
+  font-size: 4rem;
+  font-weight: 700;
+  background: linear-gradient(135deg, #fff 0%, #a5a5a5 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  margin-bottom: 1rem;
+  letter-spacing: -1px;
+}
+
+.subtitle {
+  font-size: 1.2rem;
+  color: #a1a1aa;
+  max-width: 600px;
+  margin: 0 auto;
+  line-height: 1.6;
+}
+
+/* Dropzone */
+.dropzone-container {
+  width: 100%;
+  max-width: 800px;
+  margin: 0 auto;
+}
+
+.dropzone {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 4rem 2rem;
+  border: 2px dashed rgba(99, 102, 241, 0.3);
+  border-radius: var(--radius);
+  background: rgba(99, 102, 241, 0.02);
+  cursor: pointer;
+  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+  position: relative;
+  overflow: hidden;
+}
+
+.dropzone:hover, .dropzone.active {
+  border-color: var(--primary);
+  background: rgba(99, 102, 241, 0.05);
+  box-shadow: 0 0 30px var(--primary-glow);
+}
+
+.dropzone-icon {
+  width: 64px;
+  height: 64px;
+  color: var(--primary);
+  margin-bottom: 1.5rem;
+  transition: transform 0.3s ease;
+}
+
+.dropzone:hover .dropzone-icon {
+  transform: translateY(-5px);
+}
+
+.dropzone-text {
+  font-size: 1.25rem;
+  font-weight: 500;
+  margin-bottom: 0.5rem;
+}
+
+.dropzone-subtext {
+  color: #71717a;
+  font-size: 0.9rem;
+}
+
+/* Results Grid */
+.results-container {
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+}
+
+.results-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+  gap: 2rem;
+}
+
+.result-card {
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  position: relative;
+  transition: transform 0.3s ease;
+}
+
+.result-card:hover {
+  transform: translateY(-5px);
+}
+
+.result-card-header {
+  padding: 1.25rem;
+  border-bottom: 1px solid var(--glass-border);
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.result-card-title {
+  font-size: 1.1rem;
+  font-weight: 600;
+}
+
+.result-card-content {
+  flex: 1;
+  min-height: 300px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  background: rgba(0, 0, 0, 0.2);
+}
+
+.result-image {
+  width: 100%;
+  height: 100%;
+  object-fit: contain;
+  padding: 1rem;
+}
+
+/* 3D Viewer specific */
+.viewer-3d {
+  grid-column: 1 / -1;
+  min-height: 500px;
+}
+
+model-viewer {
+  width: 100%;
+  height: 100%;
+  --poster-color: transparent;
+}
+
+/* Buttons */
+.btn {
+  background: linear-gradient(135deg, var(--primary) 0%, #4f46e5 100%);
+  color: white;
+  border: none;
+  padding: 0.75rem 1.5rem;
+  border-radius: 8px;
+  font-family: inherit;
+  font-weight: 600;
+  font-size: 1rem;
+  cursor: pointer;
+  transition: all 0.3s ease;
+  box-shadow: 0 4px 15px rgba(99, 102, 241, 0.4);
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.btn:hover:not(:disabled) {
+  transform: translateY(-2px);
+  box-shadow: 0 6px 20px rgba(99, 102, 241, 0.6);
+}
+
+.btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* Loading State */
+.loader-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 4rem 0;
+  gap: 2rem;
+}
+
+.spinner {
+  width: 60px;
+  height: 60px;
+  border: 4px solid rgba(255, 255, 255, 0.1);
+  border-left-color: var(--primary);
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+.processing-text {
+  font-size: 1.5rem;
+  font-weight: 500;
+  background: linear-gradient(90deg, #fff, #a5a5a5, #fff);
+  background-size: 200% auto;
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  animation: shine 2s linear infinite;
+}
+
+@keyframes shine {
+  to { background-position: 200% center; }
+}
+
+/* Scrollbar */
+::-webkit-scrollbar {
+  width: 8px;
+}
+::-webkit-scrollbar-track {
+  background: var(--bg-color);
+}
+::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.2);
+  border-radius: 4px;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 255, 255, 0.4);
+}
+
+/* Video Background */
+.bg-video {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100vw;
+  height: 100vh;
+  object-fit: cover;
+  z-index: -1;
+  opacity: 0.4;
+  transition: opacity 1s ease-in-out;
+  pointer-events: none;
+}
+
+.bg-video.hidden {
+  opacity: 0.05;
+  filter: blur(10px);
+}
+
+/* Landing Page */
+.landing-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 80vh;
+  text-align: center;
+  gap: 2rem;
+}
+
+.landing-title {
+  font-size: 6rem;
+  font-weight: 800;
+  background: linear-gradient(135deg, #fff 0%, var(--primary) 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  margin-bottom: 0.5rem;
+  letter-spacing: -2px;
+  filter: drop-shadow(0 4px 20px rgba(99, 102, 241, 0.3));
+}
+
+.landing-description {
+  font-size: 1.5rem;
+  color: #e4e4e7;
+  max-width: 800px;
+  line-height: 1.6;
+  margin-bottom: 2rem;
+  text-shadow: 0 2px 10px rgba(0,0,0,0.5);
+}
+
+.landing-btn {
+  font-size: 1.25rem;
+  padding: 1rem 3rem;
+  border-radius: 50px;
+  background: rgba(255, 255, 255, 0.1);
+  backdrop-filter: blur(10px);
+  border: 1px solid rgba(255, 255, 255, 0.2);
+  color: white;
+  cursor: pointer;
+  transition: all 0.3s ease;
+  font-weight: 600;
+  box-shadow: 0 10px 30px rgba(0,0,0,0.3);
+}
+
+.landing-btn:hover {
+  background: var(--primary);
+  border-color: var(--primary);
+  transform: translateY(-3px) scale(1.05);
+  box-shadow: 0 15px 40px var(--primary-glow);
+}

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/vite.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})

models/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93629f31b48ac1083265bc957d746ba887c68e425e508e28aa715d8fa069297b
+size 6260842

requirements.txt

@@ -0,0 +1,39 @@
+# Core API
+fastapi
+uvicorn
+python-multipart
+
+# Core image processing
+opencv-python-headless>=4.8.0
+numpy>=2.0.0
+pillow>=9.0.0
+
+# Visualization
+matplotlib>=3.5.0
+
+# OCR (optional — for scale estimation from dimension text)
+pytesseract>=0.3.10
+
+# Scientific / ML utilities
+scipy>=1.7.0
+scikit-learn>=1.0.0
+
+# Deep learning
+torch>=2.0.0
+torchvision>=0.15.0
+
+# YOLO segmentation
+ultralytics>=8.0.0
+
+# Progress bars
+tqdm>=4.60.0
+
+# Geometry processing
+shapely>=2.0.0
+
+# Room graph
+networkx>=3.0
+
+# 3D Reconstruction utilities
+trimesh
+pygltflib

src/detection/__init__.py

@@ -0,0 +1,19 @@
+"""
+Detection refinement module for improving door and window detection.
+
+This module provides geometry-based refinement of YOLO segmentation results,
+using wall structure analysis and computer vision techniques to improve
+detection accuracy for doors and windows in floor plans.
+"""
+
+from .refinement import (
+    RefinementConfig,
+    DetectionRefiner,
+    refine_detections,
+)
+
+__all__ = [
+    'RefinementConfig',
+    'DetectionRefiner',
+    'refine_detections',
+]

src/detection/refinement.py

@@ -0,0 +1,1184 @@
+"""
+Detection refinement module for improving door and window detection.
+
+This module provides geometry-based refinement of YOLO segmentation results,
+using wall structure, spatial relationships, and computer vision techniques.
+
+Example usage:
+    >>> from src.detection.refinement import refine_detections, RefinementConfig
+    >>> 
+    >>> # Use default configuration
+    >>> refined_result = refine_detections(yolo_output, image, geometry_output)
+    >>> 
+    >>> # Use custom configuration
+    >>> config = RefinementConfig(
+    ...     canny_low_threshold=40,
+    ...     canny_high_threshold=160,
+    ...     door_width=100
+    ... )
+    >>> refined_result = refine_detections(
+    ...     yolo_output, image, geometry_output, config=config
+    ... )
+"""
+
+from dataclasses import dataclass
+from typing import Optional, List, Tuple
+import logging
+
+import numpy as np
+import cv2
+
+from src.segmentation.predictor import SegmentationResult
+from src.geometry.wall_vectorizer import WallPolygon, VectorizationResult
+
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class RefinementConfig:
+    """Configuration for detection refinement algorithms."""
+    
+    # Edge detection parameters (Canny)
+    canny_low_threshold: int = 50
+    canny_high_threshold: int = 150
+    
+    # Line detection parameters (HoughLinesP)
+    hough_min_line_length: int = 30
+    hough_max_line_gap: int = 10
+    hough_threshold: int = 50
+    
+    # Window detection parameters
+    parallel_line_proximity: int = 20  # max distance between parallel lines (px)
+    parallel_angle_tolerance: float = 15.0  # degrees
+    window_min_length: int = 30  # minimum window length (px)
+    
+    # Door detection parameters
+    wall_gap_threshold: int = 20  # minimum gap width to consider as door (px)
+    room_adjacency_threshold: int = 50  # max distance for rooms to be adjacent (px)
+    door_width: int = 90  # standard door width in pixels (~0.9m)
+    
+    # Spatial analysis parameters
+    wall_thickness_tolerance: int = 10  # tolerance for point-on-wall checks (px)
+    
+    # Performance parameters
+    enable_door_detection: bool = True
+    enable_window_detection: bool = True
+    
+    def __post_init__(self):
+        """Validate and clamp configuration parameters to reasonable ranges."""
+        # Validate Canny thresholds
+        self.canny_low_threshold = max(1, min(255, self.canny_low_threshold))
+        self.canny_high_threshold = max(1, min(255, self.canny_high_threshold))
+        
+        if self.canny_high_threshold <= self.canny_low_threshold:
+            logger.warning(
+                f"Invalid Canny thresholds: low={self.canny_low_threshold}, "
+                f"high={self.canny_high_threshold}. Using defaults."
+            )
+            self.canny_low_threshold = 50
+            self.canny_high_threshold = 150
+        
+        # Validate positive integer parameters
+        self.hough_min_line_length = max(1, self.hough_min_line_length)
+        self.hough_max_line_gap = max(0, self.hough_max_line_gap)
+        self.hough_threshold = max(1, self.hough_threshold)
+        self.parallel_line_proximity = max(1, self.parallel_line_proximity)
+        self.window_min_length = max(1, self.window_min_length)
+        self.wall_gap_threshold = max(1, self.wall_gap_threshold)
+        self.room_adjacency_threshold = max(1, self.room_adjacency_threshold)
+        self.door_width = max(1, self.door_width)
+        self.wall_thickness_tolerance = max(1, self.wall_thickness_tolerance)
+        
+        # Validate angle tolerance
+        self.parallel_angle_tolerance = max(0.0, min(90.0, self.parallel_angle_tolerance))
+
+
+# Type aliases for clarity
+LineSegment = Tuple[Tuple[int, int], Tuple[int, int]]  # ((x1, y1), (x2, y2))
+
+
+class DetectionRefiner:
+    """Main orchestrator for detection refinement."""
+    
+    def __init__(self, config: Optional[RefinementConfig] = None):
+        """
+        Initialize the detection refiner.
+        
+        Parameters
+        ----------
+        config : RefinementConfig, optional
+            Configuration for refinement algorithms. If None, uses defaults.
+        """
+        self.config = config or RefinementConfig()
+        self.door_detector = DoorDetector(self.config)
+        self.window_detector = WindowDetector(self.config)
+    
+    def refine(
+        self,
+        yolo_output: SegmentationResult,
+        image: np.ndarray,
+        geometry_output: VectorizationResult
+    ) -> VectorizationResult:
+        """
+        Main refinement function that replaces YOLO doors/windows
+        with geometry-based detections.
+        
+        Parameters
+        ----------
+        yolo_output : SegmentationResult
+            Original YOLO segmentation result
+        image : np.ndarray
+            Preprocessed floor plan image (grayscale)
+        geometry_output : VectorizationResult
+            Vectorized geometry from Phase 3
+        
+        Returns
+        -------
+        VectorizationResult
+            Refined VectorizationResult with improved doors/windows
+        """
+        logger.info("Starting detection refinement")
+        
+        refined_doors = []
+        refined_windows = []
+        
+        # Try door detection
+        if self.config.enable_door_detection:
+            try:
+                refined_doors = self.door_detector.detect(
+                    geometry_output.walls,
+                    geometry_output.rooms
+                )
+                logger.info(f"Door detection complete: {len(refined_doors)} doors detected")
+            except Exception as e:
+                logger.error(f"Door detection failed: {e}", exc_info=True)
+                logger.warning("Falling back to original YOLO door detections")
+                refined_doors = geometry_output.doors
+        else:
+            refined_doors = geometry_output.doors
+        
+        # Try window detection independently
+        if self.config.enable_window_detection:
+            try:
+                refined_windows = self.window_detector.detect(
+                    image,
+                    geometry_output.walls
+                )
+                logger.info(f"Window detection complete: {len(refined_windows)} windows detected")
+            except Exception as e:
+                logger.error(f"Window detection failed: {e}", exc_info=True)
+                logger.warning("Falling back to original YOLO window detections")
+                refined_windows = geometry_output.windows
+        else:
+            refined_windows = geometry_output.windows
+        
+        # Merge results
+        refined_result = VectorizationResult(
+            walls=geometry_output.walls,
+            rooms=geometry_output.rooms,
+            doors=refined_doors,
+            windows=refined_windows,
+            other=geometry_output.other,
+            image_shape=geometry_output.image_shape
+        )
+        
+        logger.info(
+            f"Refinement complete: {len(refined_doors)} doors, "
+            f"{len(refined_windows)} windows"
+        )
+        
+        return refined_result
+
+
+def refine_detections(
+    yolo_output: SegmentationResult,
+    image: np.ndarray,
+    geometry_output: VectorizationResult,
+    config: Optional[RefinementConfig] = None
+) -> VectorizationResult:
+    """
+    Public API function for detection refinement.
+    
+    This is the main entry point called by GeometryPipeline.
+    
+    Parameters
+    ----------
+    yolo_output : SegmentationResult
+        Original YOLO segmentation result
+    image : np.ndarray
+        Preprocessed floor plan image (grayscale)
+    geometry_output : VectorizationResult
+        Vectorized geometry from Phase 3
+    config : RefinementConfig, optional
+        Optional custom configuration. If None, uses defaults.
+    
+    Returns
+    -------
+    VectorizationResult
+        Refined VectorizationResult with improved doors/windows
+    
+    Examples
+    --------
+    >>> refined = refine_detections(yolo_output, image, geometry_output)
+    >>> print(f"Detected {len(refined.doors)} doors")
+    """
+    try:
+        refiner = DetectionRefiner(config)
+        return refiner.refine(yolo_output, image, geometry_output)
+    except Exception as e:
+        logger.error(f"Refinement failed completely: {e}", exc_info=True)
+        logger.warning("Returning original geometry output unchanged")
+        return geometry_output
+
+
+class SpatialAnalyzer:
+    """Analyzes spatial relationships between rooms and walls."""
+    
+    def __init__(self, config: RefinementConfig):
+        """
+        Initialize spatial analyzer.
+        
+        Parameters
+        ----------
+        config : RefinementConfig
+            Configuration for spatial analysis parameters
+        """
+        self.config = config
+    
+    def find_adjacent_rooms(
+        self,
+        room_polygons: List[WallPolygon]
+    ) -> List[Tuple[WallPolygon, WallPolygon]]:
+        """
+        Find pairs of rooms that share a wall boundary.
+        
+        Uses polygon proximity analysis: rooms are adjacent if their
+        boundaries come within room_adjacency_threshold pixels.
+        
+        Parameters
+        ----------
+        room_polygons : List[WallPolygon]
+            List of room polygons
+        
+        Returns
+        -------
+        List[Tuple[WallPolygon, WallPolygon]]
+            List of (room_a, room_b) tuples representing adjacent room pairs
+        """
+        if not room_polygons or len(room_polygons) < 2:
+            return []
+        
+        adjacent_pairs = []
+        n = len(room_polygons)
+        
+        for i in range(n):
+            for j in range(i + 1, n):
+                room_a = room_polygons[i]
+                room_b = room_polygons[j]
+                
+                # Compute distance between room centroids
+                centroid_a = room_a.centroid
+                centroid_b = room_b.centroid
+                distance = np.sqrt(
+                    (centroid_a[0] - centroid_b[0])**2 +
+                    (centroid_a[1] - centroid_b[1])**2
+                )
+                
+                # Check if rooms are close enough to be adjacent
+                if distance <= self.config.room_adjacency_threshold * 3:  # Use 3x threshold for centroid distance
+                    # Verify actual boundary proximity using minimum distance between polygon points
+                    points_a = np.array(room_a.points, dtype=np.float32)
+                    points_b = np.array(room_b.points, dtype=np.float32)
+                    
+                    # Compute minimum distance between any two points
+                    min_dist = float('inf')
+                    for pt_a in points_a:
+                        for pt_b in points_b:
+                            dist = np.sqrt((pt_a[0] - pt_b[0])**2 + (pt_a[1] - pt_b[1])**2)
+                            min_dist = min(min_dist, dist)
+                    
+                    if min_dist <= self.config.room_adjacency_threshold:
+                        adjacent_pairs.append((room_a, room_b))
+        
+        logger.debug(f"Found {len(adjacent_pairs)} adjacent room pairs")
+        return adjacent_pairs
+    
+    def find_shared_wall_segment(
+        self,
+        room_a: WallPolygon,
+        room_b: WallPolygon,
+        wall_polygons: List[WallPolygon]
+    ) -> Optional[np.ndarray]:
+        """
+        Extract the wall segment between two adjacent rooms.
+        
+        Algorithm:
+        1. Find the line connecting room centroids
+        2. Find wall polygons that intersect this line
+        3. Extract the portion of wall between the two rooms
+        
+        Parameters
+        ----------
+        room_a : WallPolygon
+            First room polygon
+        room_b : WallPolygon
+            Second room polygon
+        wall_polygons : List[WallPolygon]
+            List of wall polygons
+        
+        Returns
+        -------
+        np.ndarray or None
+            Nx2 numpy array of wall segment points, or None if not found
+        """
+        if not wall_polygons:
+            return None
+        
+        centroid_a = np.array(room_a.centroid, dtype=np.float32)
+        centroid_b = np.array(room_b.centroid, dtype=np.float32)
+        
+        # Find walls that lie between the two rooms
+        # A wall is between rooms if it's close to the line connecting centroids
+        candidate_walls = []
+        
+        for wall in wall_polygons:
+            if not wall.is_wall:
+                continue
+            
+            wall_centroid = np.array(wall.centroid, dtype=np.float32)
+            
+            # Check if wall centroid is roughly between room centroids
+            # using dot product to check if it's in the same direction
+            vec_ab = centroid_b - centroid_a
+            vec_aw = wall_centroid - centroid_a
+            
+            # Project wall centroid onto line AB
+            if np.dot(vec_ab, vec_ab) > 0:
+                t = np.dot(vec_aw, vec_ab) / np.dot(vec_ab, vec_ab)
+                
+                # Wall should be between rooms (0 < t < 1)
+                if 0.2 < t < 0.8:  # Allow some tolerance
+                    # Check perpendicular distance to line
+                    projection = centroid_a + t * vec_ab
+                    perp_dist = np.linalg.norm(wall_centroid - projection)
+                    
+                    if perp_dist < self.config.room_adjacency_threshold:
+                        candidate_walls.append(wall)
+        
+        if not candidate_walls:
+            logger.debug("No shared wall segment found between rooms")
+            return None
+        
+        # Return the wall closest to the midpoint between rooms
+        midpoint = (centroid_a + centroid_b) / 2
+        closest_wall = min(
+            candidate_walls,
+            key=lambda w: np.linalg.norm(np.array(w.centroid) - midpoint)
+        )
+        
+        return np.array(closest_wall.points, dtype=np.float32)
+    
+    def is_point_on_wall(
+        self,
+        point: Tuple[float, float],
+        wall_polygon: WallPolygon
+    ) -> bool:
+        """
+        Check if a point lies within wall polygon boundaries.
+        
+        Uses cv2.pointPolygonTest with tolerance from config.
+        
+        Parameters
+        ----------
+        point : Tuple[float, float]
+            Point coordinates (x, y)
+        wall_polygon : WallPolygon
+            Wall polygon to test against
+        
+        Returns
+        -------
+        bool
+            True if point is on or near the wall, False otherwise
+        """
+        wall_pts = np.array(wall_polygon.points, dtype=np.int32)
+        
+        # Use cv2.pointPolygonTest to compute signed distance
+        # Positive = inside, 0 = on edge, negative = outside
+        dist = cv2.pointPolygonTest(wall_pts, point, measureDist=True)
+        
+        # Point is on wall if distance is within tolerance
+        return abs(dist) <= self.config.wall_thickness_tolerance
+    
+    def get_wall_direction(
+        self,
+        wall_segment: np.ndarray
+    ) -> float:
+        """
+        Compute orientation angle of a wall segment.
+        
+        Uses PCA (principal component analysis) on wall points
+        to find dominant direction.
+        
+        Parameters
+        ----------
+        wall_segment : np.ndarray
+            Nx2 array of wall segment points
+        
+        Returns
+        -------
+        float
+            Angle in degrees (0-180 range)
+        """
+        if len(wall_segment) < 2:
+            logger.warning("Wall segment has fewer than 2 points, returning 0 degrees")
+            return 0.0
+        
+        try:
+            # Use PCA to find principal direction
+            from sklearn.decomposition import PCA
+            
+            pca = PCA(n_components=1)
+            pca.fit(wall_segment)
+            
+            # Get principal component (dominant direction)
+            component = pca.components_[0]
+            angle = np.arctan2(component[1], component[0])
+            
+            # Convert to degrees, normalize to [0, 180)
+            angle_deg = np.degrees(angle) % 180
+            
+            return float(angle_deg)
+        
+        except Exception as e:
+            logger.warning(f"Failed to compute wall direction using PCA: {e}")
+            
+            # Fallback: use simple line fitting
+            try:
+                # Fit line using first and last points
+                p1 = wall_segment[0]
+                p2 = wall_segment[-1]
+                
+                dx = p2[0] - p1[0]
+                dy = p2[1] - p1[1]
+                
+                angle = np.arctan2(dy, dx)
+                angle_deg = np.degrees(angle) % 180
+                
+                return float(angle_deg)
+            
+            except Exception as e2:
+                logger.error(f"Failed to compute wall direction: {e2}")
+                return 0.0
+
+
+class GapDetector:
+    """Detects gaps and discontinuities in wall segments."""
+    
+    def __init__(self, config: RefinementConfig):
+        """
+        Initialize gap detector.
+        
+        Parameters
+        ----------
+        config : RefinementConfig
+            Configuration for gap detection parameters
+        """
+        self.config = config
+    
+    def detect_wall_gaps(
+        self,
+        wall_segment: np.ndarray
+    ) -> List[Tuple[np.ndarray, np.ndarray]]:
+        """
+        Identify breaks or discontinuities in a wall segment.
+        
+        Algorithm:
+        1. Sort wall points along the wall direction
+        2. Compute distances between consecutive points
+        3. Identify gaps where distance > wall_gap_threshold
+        
+        Parameters
+        ----------
+        wall_segment : np.ndarray
+            Nx2 array of wall segment points
+        
+        Returns
+        -------
+        List[Tuple[np.ndarray, np.ndarray]]
+            List of (start_point, end_point) tuples indicating gap locations
+        """
+        if len(wall_segment) < 2:
+            logger.debug("Wall segment too short for gap detection")
+            return []
+        
+        try:
+            # Compute wall direction to sort points along it
+            centroid = np.mean(wall_segment, axis=0)
+            
+            # Use PCA to find principal direction
+            from sklearn.decomposition import PCA
+            pca = PCA(n_components=1)
+            pca.fit(wall_segment)
+            direction = pca.components_[0]
+            
+            # Project points onto principal direction
+            projections = np.dot(wall_segment - centroid, direction)
+            
+            # Sort points by projection
+            sorted_indices = np.argsort(projections)
+            sorted_points = wall_segment[sorted_indices]
+            
+        except Exception as e:
+            logger.warning(f"Failed to sort wall points using PCA: {e}, using simple sort")
+            # Fallback: sort by x-coordinate
+            sorted_indices = np.argsort(wall_segment[:, 0])
+            sorted_points = wall_segment[sorted_indices]
+        
+        # Compute distances between consecutive points
+        gaps = []
+        for i in range(len(sorted_points) - 1):
+            p1 = sorted_points[i]
+            p2 = sorted_points[i + 1]
+            
+            distance = np.linalg.norm(p2 - p1)
+            
+            # If distance exceeds threshold, we found a gap
+            if distance > self.config.wall_gap_threshold:
+                gaps.append((p1, p2))
+                logger.debug(f"Found gap of width {distance:.1f}px at {p1} -> {p2}")
+        
+        if not gaps:
+            logger.debug("No wall gaps detected")
+        else:
+            logger.debug(f"Detected {len(gaps)} wall gaps")
+        
+        return gaps
+
+
+# Placeholder classes - will be implemented in subsequent tasks
+class DoorDetector:
+    """Detects doors based on wall gaps and room adjacency."""
+    
+    def __init__(self, config: RefinementConfig):
+        self.config = config
+        self.spatial_analyzer = SpatialAnalyzer(config)
+        self.gap_detector = GapDetector(config)
+    
+    def detect(
+        self,
+        wall_polygons: List[WallPolygon],
+        room_polygons: List[WallPolygon]
+    ) -> List[WallPolygon]:
+        """
+        Detect door locations from wall geometry and room adjacency.
+        
+        Parameters
+        ----------
+        wall_polygons : List[WallPolygon]
+            List of vectorized wall polygons
+        room_polygons : List[WallPolygon]
+            List of vectorized room polygons
+        
+        Returns
+        -------
+        List[WallPolygon]
+            List of door polygons with class_id=3, class_name="Door"
+        """
+        # Input validation
+        if not wall_polygons:
+            logger.warning("No wall polygons provided, skipping door detection")
+            return []
+        
+        if not room_polygons:
+            logger.warning("No room polygons provided, skipping door detection")
+            return []
+        
+        logger.info(f"Detecting doors from {len(wall_polygons)} walls and {len(room_polygons)} rooms")
+        
+        doors = []
+        
+        # Find all pairs of adjacent rooms
+        adjacent_pairs = self.spatial_analyzer.find_adjacent_rooms(room_polygons)
+        
+        if not adjacent_pairs:
+            logger.info("No adjacent rooms found, no doors to place")
+            return []
+        
+        logger.info(f"Found {len(adjacent_pairs)} adjacent room pairs")
+        
+        # For each adjacent room pair, place a door
+        for room_a, room_b in adjacent_pairs:
+            try:
+                # Find the shared wall segment
+                shared_wall = self.spatial_analyzer.find_shared_wall_segment(
+                    room_a, room_b, wall_polygons
+                )
+                
+                if shared_wall is None:
+                    logger.debug(f"No shared wall found between rooms, skipping")
+                    continue
+                
+                # Detect gaps in the wall
+                gaps = self.gap_detector.detect_wall_gaps(shared_wall)
+                
+                # Determine door position
+                if gaps:
+                    # Place door at first gap
+                    gap_start, gap_end = gaps[0]
+                    door_position = (gap_start + gap_end) / 2
+                    logger.debug(f"Placing door at gap location: {door_position}")
+                else:
+                    # Fallback: place door at midpoint of shared wall
+                    door_position = np.mean(shared_wall, axis=0)
+                    logger.debug(f"No gaps found, placing door at wall midpoint: {door_position}")
+                
+                # Get wall direction
+                wall_direction = self.spatial_analyzer.get_wall_direction(shared_wall)
+                
+                # Create door polygon
+                door = create_door_polygon(
+                    position=tuple(door_position),
+                    wall_direction=wall_direction,
+                    door_width=self.config.door_width
+                )
+                
+                doors.append(door)
+            
+            except Exception as e:
+                logger.warning(f"Failed to place door between rooms: {e}")
+                continue
+        
+        logger.info(f"Successfully detected {len(doors)} doors")
+        return doors
+
+
+def create_door_polygon(
+    position: Tuple[float, float],
+    wall_direction: float,
+    door_width: int
+) -> WallPolygon:
+    """
+    Create a door polygon at the specified position.
+    
+    The door is oriented perpendicular to the wall direction.
+    
+    Parameters
+    ----------
+    position : Tuple[float, float]
+        (x, y) center point for door
+    wall_direction : float
+        Wall orientation in degrees (0-180)
+    door_width : int
+        Door width in pixels
+    
+    Returns
+    -------
+    WallPolygon
+        WallPolygon with class_id=3, class_name="Door"
+    """
+    # Door is perpendicular to wall
+    door_angle = (wall_direction + 90) % 180
+    door_angle_rad = np.radians(door_angle)
+    
+    # Create door as a rectangle perpendicular to wall
+    half_width = door_width / 2
+    half_depth = door_width / 4  # Door depth is half the width
+    
+    # Direction vectors
+    dir_along = np.array([np.cos(door_angle_rad), np.sin(door_angle_rad)])
+    dir_perp = np.array([-np.sin(door_angle_rad), np.cos(door_angle_rad)])
+    
+    # Four corners of the door rectangle
+    center = np.array(position)
+    p1 = center - half_width * dir_along - half_depth * dir_perp
+    p2 = center + half_width * dir_along - half_depth * dir_perp
+    p3 = center + half_width * dir_along + half_depth * dir_perp
+    p4 = center - half_width * dir_along + half_depth * dir_perp
+    
+    # Convert to integer coordinates
+    points = [
+        (int(p1[0]), int(p1[1])),
+        (int(p2[0]), int(p2[1])),
+        (int(p3[0]), int(p3[1])),
+        (int(p4[0]), int(p4[1]))
+    ]
+    
+    # Compute area and bbox
+    points_array = np.array(points)
+    area = float(cv2.contourArea(points_array))
+    x_coords = points_array[:, 0]
+    y_coords = points_array[:, 1]
+    bbox = (
+        int(x_coords.min()),
+        int(y_coords.min()),
+        int(x_coords.max() - x_coords.min()),
+        int(y_coords.max() - y_coords.min())
+    )
+    
+    return WallPolygon(
+        class_id=3,
+        class_name="Door",
+        points=points,
+        area=area,
+        bbox=bbox,
+        confidence=1.0
+    )
+
+
+class EdgeAnalyzer:
+    """Performs edge detection on floor plan images."""
+    
+    def __init__(self, config: RefinementConfig):
+        """
+        Initialize edge analyzer.
+        
+        Parameters
+        ----------
+        config : RefinementConfig
+            Configuration for edge detection parameters
+        """
+        self.config = config
+    
+    def detect_edges(
+        self,
+        image: np.ndarray
+    ) -> np.ndarray:
+        """
+        Apply Canny edge detection to identify edges.
+        
+        Uses config.canny_low_threshold and config.canny_high_threshold.
+        
+        Parameters
+        ----------
+        image : np.ndarray
+            Input image (grayscale)
+        
+        Returns
+        -------
+        np.ndarray
+            Binary edge map (same size as input)
+        """
+        if image is None or image.size == 0:
+            logger.error("Invalid image provided to edge detection")
+            return np.zeros((100, 100), dtype=np.uint8)
+        
+        try:
+            # Ensure image is grayscale
+            if len(image.shape) == 3:
+                image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            
+            # Apply Canny edge detection
+            edges = cv2.Canny(
+                image,
+                self.config.canny_low_threshold,
+                self.config.canny_high_threshold
+            )
+            
+            logger.debug(f"Edge detection complete: {np.count_nonzero(edges)} edge pixels")
+            return edges
+        
+        except cv2.error as e:
+            logger.error(f"OpenCV edge detection failed: {e}")
+            return np.zeros_like(image, dtype=np.uint8)
+        except Exception as e:
+            logger.error(f"Edge detection failed: {e}")
+            return np.zeros_like(image, dtype=np.uint8)
+
+
+class LineDetector:
+    """Detects and analyzes line segments in images."""
+    
+    def __init__(self, config: RefinementConfig):
+        """
+        Initialize line detector.
+        
+        Parameters
+        ----------
+        config : RefinementConfig
+            Configuration for line detection parameters
+        """
+        self.config = config
+    
+    def detect_lines(
+        self,
+        edge_map: np.ndarray
+    ) -> List[LineSegment]:
+        """
+        Extract line segments using HoughLinesP.
+        
+        Uses config.hough_* parameters.
+        
+        Parameters
+        ----------
+        edge_map : np.ndarray
+            Binary edge map from edge detection
+        
+        Returns
+        -------
+        List[LineSegment]
+            List of ((x1, y1), (x2, y2)) line segments
+        """
+        if edge_map is None or edge_map.size == 0:
+            logger.warning("Invalid edge map provided to line detection")
+            return []
+        
+        try:
+            # Apply HoughLinesP
+            lines = cv2.HoughLinesP(
+                edge_map,
+                rho=1,
+                theta=np.pi / 180,
+                threshold=self.config.hough_threshold,
+                minLineLength=self.config.hough_min_line_length,
+                maxLineGap=self.config.hough_max_line_gap
+            )
+            
+            if lines is None:
+                logger.debug("No lines detected by HoughLinesP")
+                return []
+            
+            # Convert to list of line segments
+            line_segments = []
+            for line in lines:
+                x1, y1, x2, y2 = line[0]
+                line_segments.append(((int(x1), int(y1)), (int(x2), int(y2))))
+            
+            logger.debug(f"Detected {len(line_segments)} line segments")
+            return line_segments
+        
+        except cv2.error as e:
+            logger.error(f"OpenCV line detection failed: {e}")
+            return []
+        except Exception as e:
+            logger.error(f"Line detection failed: {e}")
+            return []
+    
+    def compute_line_angle(
+        self,
+        line: LineSegment
+    ) -> float:
+        """
+        Compute orientation angle of a line segment.
+        
+        Parameters
+        ----------
+        line : LineSegment
+            Line segment ((x1, y1), (x2, y2))
+        
+        Returns
+        -------
+        float
+            Angle in degrees (0-180 range)
+        """
+        (x1, y1), (x2, y2) = line
+        dx = x2 - x1
+        dy = y2 - y1
+        
+        angle = np.arctan2(dy, dx)
+        angle_deg = np.degrees(angle) % 180
+        
+        return float(angle_deg)
+    
+    def compute_line_distance(
+        self,
+        line_a: LineSegment,
+        line_b: LineSegment
+    ) -> float:
+        """
+        Compute perpendicular distance between two parallel lines.
+        
+        Parameters
+        ----------
+        line_a : LineSegment
+            First line segment
+        line_b : LineSegment
+            Second line segment
+        
+        Returns
+        -------
+        float
+            Distance in pixels
+        """
+        # Use midpoints of lines
+        (x1_a, y1_a), (x2_a, y2_a) = line_a
+        (x1_b, y1_b), (x2_b, y2_b) = line_b
+        
+        mid_a = np.array([(x1_a + x2_a) / 2, (y1_a + y2_a) / 2])
+        mid_b = np.array([(x1_b + x2_b) / 2, (y1_b + y2_b) / 2])
+        
+        # Compute distance between midpoints
+        distance = np.linalg.norm(mid_b - mid_a)
+        
+        return float(distance)
+    
+    def find_parallel_pairs(
+        self,
+        lines: List[LineSegment]
+    ) -> List[Tuple[int, int]]:
+        """
+        Identify pairs of parallel lines with close proximity.
+        
+        Algorithm:
+        1. Compute orientation angle for each line
+        2. For each line pair:
+           - Check if angles are within parallel_angle_tolerance
+           - Check if distance between lines < parallel_line_proximity
+        3. Return indices of parallel pairs
+        
+        Parameters
+        ----------
+        lines : List[LineSegment]
+            List of line segments
+        
+        Returns
+        -------
+        List[Tuple[int, int]]
+            List of (line_idx_a, line_idx_b) tuples
+        """
+        if not lines or len(lines) < 2:
+            return []
+        
+        pairs = []
+        n = len(lines)
+        
+        # Compute angles for all lines
+        angles = [self.compute_line_angle(line) for line in lines]
+        
+        for i in range(n):
+            for j in range(i + 1, n):
+                angle_i = angles[i]
+                angle_j = angles[j]
+                
+                # Check angle similarity (handle wraparound at 180 degrees)
+                angle_diff = abs(angle_i - angle_j)
+                angle_diff = min(angle_diff, 180 - angle_diff)
+                
+                if angle_diff > self.config.parallel_angle_tolerance:
+                    continue
+                
+                # Check distance
+                distance = self.compute_line_distance(lines[i], lines[j])
+                
+                if distance > self.config.parallel_line_proximity:
+                    continue
+                
+                # Check minimum line length
+                (x1_i, y1_i), (x2_i, y2_i) = lines[i]
+                (x1_j, y1_j), (x2_j, y2_j) = lines[j]
+                
+                len_i = np.sqrt((x2_i - x1_i)**2 + (y2_i - y1_i)**2)
+                len_j = np.sqrt((x2_j - x1_j)**2 + (y2_j - y1_j)**2)
+                
+                if len_i < self.config.window_min_length or len_j < self.config.window_min_length:
+                    continue
+                
+                pairs.append((i, j))
+                logger.debug(
+                    f"Found parallel pair: lines {i} and {j}, "
+                    f"angle_diff={angle_diff:.1f}°, distance={distance:.1f}px"
+                )
+        
+        logger.debug(f"Found {len(pairs)} parallel line pairs")
+        return pairs
+
+
+class WindowDetector:
+    """Detects windows using edge detection and line analysis."""
+    
+    def __init__(self, config: RefinementConfig):
+        self.config = config
+        self.edge_analyzer = EdgeAnalyzer(config)
+        self.line_detector = LineDetector(config)
+    
+    def detect(
+        self,
+        image: np.ndarray,
+        wall_polygons: List[WallPolygon]
+    ) -> List[WallPolygon]:
+        """
+        Detect window locations using edge detection and line analysis.
+        
+        Parameters
+        ----------
+        image : np.ndarray
+            Preprocessed floor plan image (grayscale)
+        wall_polygons : List[WallPolygon]
+            List of vectorized wall polygons
+        
+        Returns
+        -------
+        List[WallPolygon]
+            List of window polygons with class_id=2, class_name="Window"
+        """
+        # Input validation
+        if image is None or image.size == 0:
+            logger.warning("Invalid image provided, skipping window detection")
+            return []
+        
+        if not wall_polygons:
+            logger.warning("No wall polygons provided, skipping window detection")
+            return []
+        
+        logger.info(f"Detecting windows from image and {len(wall_polygons)} walls")
+        
+        # Step 1: Edge detection
+        edges = self.edge_analyzer.detect_edges(image)
+        
+        # Step 2: Line detection
+        lines = self.line_detector.detect_lines(edges)
+        
+        if not lines:
+            logger.info("No lines detected, no windows to place")
+            return []
+        
+        # Step 3: Find parallel line pairs
+        parallel_pairs = self.line_detector.find_parallel_pairs(lines)
+        
+        if not parallel_pairs:
+            logger.info("No parallel line pairs found, no windows to place")
+            return []
+        
+        logger.info(f"Found {len(parallel_pairs)} parallel line pairs")
+        
+        windows = []
+        
+        # Step 4: Create window polygons from parallel pairs
+        for idx_a, idx_b in parallel_pairs:
+            try:
+                line_a = lines[idx_a]
+                line_b = lines[idx_b]
+                
+                # Compute window center
+                (x1_a, y1_a), (x2_a, y2_a) = line_a
+                (x1_b, y1_b), (x2_b, y2_b) = line_b
+                
+                mid_a = np.array([(x1_a + x2_a) / 2, (y1_a + y2_a) / 2])
+                mid_b = np.array([(x1_b + x2_b) / 2, (y1_b + y2_b) / 2])
+                window_center = (mid_a + mid_b) / 2
+                
+                # Find which wall this window belongs to
+                wall = self._find_containing_wall(tuple(window_center), wall_polygons)
+                
+                if wall is None:
+                    logger.debug(f"Window at {window_center} not on any wall, skipping")
+                    continue
+                
+                # Verify alignment with wall direction
+                wall_points = np.array(wall.points, dtype=np.float32)
+                spatial_analyzer = SpatialAnalyzer(self.config)
+                wall_direction = spatial_analyzer.get_wall_direction(wall_points)
+                
+                line_direction = self.line_detector.compute_line_angle(line_a)
+                
+                # Check if line is parallel to wall (within tolerance)
+                angle_diff = abs(wall_direction - line_direction)
+                angle_diff = min(angle_diff, 180 - angle_diff)
+                
+                if angle_diff > self.config.parallel_angle_tolerance:
+                    logger.debug(
+                        f"Window lines not aligned with wall "
+                        f"(wall={wall_direction:.1f}°, line={line_direction:.1f}°), skipping"
+                    )
+                    continue
+                
+                # Create window polygon
+                window = create_window_polygon(line_a, line_b)
+                windows.append(window)
+            
+            except Exception as e:
+                logger.warning(f"Failed to create window from parallel lines: {e}")
+                continue
+        
+        logger.info(f"Successfully detected {len(windows)} windows")
+        return windows
+    
+    def _find_containing_wall(
+        self,
+        point: Tuple[float, float],
+        wall_polygons: List[WallPolygon]
+    ) -> Optional[WallPolygon]:
+        """
+        Find which wall contains the given point.
+        
+        Parameters
+        ----------
+        point : Tuple[float, float]
+            Point coordinates (x, y)
+        wall_polygons : List[WallPolygon]
+            List of wall polygons
+        
+        Returns
+        -------
+        WallPolygon or None
+            Wall containing the point, or None if not found
+        """
+        spatial_analyzer = SpatialAnalyzer(self.config)
+        
+        for wall in wall_polygons:
+            if not wall.is_wall:
+                continue
+            
+            if spatial_analyzer.is_point_on_wall(point, wall):
+                return wall
+        
+        return None
+
+
+def create_window_polygon(
+    line_a: LineSegment,
+    line_b: LineSegment
+) -> WallPolygon:
+    """
+    Create a window polygon from a pair of parallel lines.
+    
+    Parameters
+    ----------
+    line_a : LineSegment
+        First line segment ((x1, y1), (x2, y2))
+    line_b : LineSegment
+        Second line segment ((x1, y1), (x2, y2))
+    
+    Returns
+    -------
+    WallPolygon
+        WallPolygon with class_id=2, class_name="Window"
+    """
+    (x1_a, y1_a), (x2_a, y2_a) = line_a
+    (x1_b, y1_b), (x2_b, y2_b) = line_b
+    
+    # Create rectangle from the two parallel lines
+    # Use the endpoints of both lines as corners
+    points = [
+        (int(x1_a), int(y1_a)),
+        (int(x2_a), int(y2_a)),
+        (int(x2_b), int(y2_b)),
+        (int(x1_b), int(y1_b))
+    ]
+    
+    # Compute area and bbox
+    points_array = np.array(points)
+    area = float(cv2.contourArea(points_array))
+    
+    # Handle degenerate case where contour area is 0
+    if area == 0:
+        area = 1.0
+    
+    x_coords = points_array[:, 0]
+    y_coords = points_array[:, 1]
+    bbox = (
+        int(x_coords.min()),
+        int(y_coords.min()),
+        int(x_coords.max() - x_coords.min()),
+        int(y_coords.max() - y_coords.min())
+    )
+    
+    return WallPolygon(
+        class_id=2,
+        class_name="Window",
+        points=points,
+        area=area,
+        bbox=bbox,
+        confidence=1.0
+    )

src/geometry/pipeline.py

@@ -0,0 +1,372 @@
+"""
+pipeline.py
+-----------
+Orchestrates the complete Phase 3 geometry reconstruction pipeline:
+
+  segmentation_result → vectorize → estimate_scale → build_graph → save
+
+Usage:
+    from src.geometry.pipeline import GeometryPipeline
+
+    pipeline = GeometryPipeline()
+    result = pipeline.run(segmentation_result, image)
+    result.save("outputs/geometry/")
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import cv2
+import numpy as np
+
+from .wall_vectorizer import WallVectorizer, VectorizationResult
+from .scale_estimator import ScaleEstimator, ScaleEstimate
+from .room_graph import RoomGraphBuilder, FloorPlanGraph
+
+# Import refinement module (optional dependency)
+try:
+    from src.detection.refinement import RefinementConfig, refine_detections
+    REFINEMENT_AVAILABLE = True
+except ImportError:
+    REFINEMENT_AVAILABLE = False
+    RefinementConfig = None
+
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+@dataclass
+class GeometryConfig:
+    """Tunable parameters for Phase 3 geometry pipeline."""
+    epsilon_factor:      float = 0.008   # Polygon simplification
+    min_area:            int   = 200     # Min polygon area (px²)
+    morph_kernel:        int   = 3       # Morphological cleanup kernel
+    simplify_walls:      bool  = True    # Extra wall simplification
+    proximity_threshold: int   = 200     # Room adjacency threshold (px)
+    door_proximity:      int   = 150     # Door-to-room proximity (px)
+    target_image_size:   int   = 1024    # Phase 1 resize target
+    
+    # Detection refinement parameters
+    use_refinement:      bool  = True    # Enable detection refinement
+    refinement_config:   Optional['RefinementConfig'] = None  # Custom refinement config
+    
+    # Visualization parameters
+    debug_visualization: bool  = False   # Enable debug visualizations
+    visualization_dir:   str   = "outputs/debug_viz"  # Directory for debug images
+    
+    def __post_init__(self):
+        """Initialize default refinement config if not provided."""
+        if self.use_refinement and self.refinement_config is None and REFINEMENT_AVAILABLE:
+            from src.detection.refinement import RefinementConfig
+            self.refinement_config = RefinementConfig()
+
+
+# ── Result ────────────────────────────────────────────────────────────────────
+
+@dataclass
+class GeometryResult:
+    """Complete Phase 3 output for one floor plan."""
+    source_path:         str
+    vectorization:       VectorizationResult
+    scale:               ScaleEstimate
+    graph:               FloorPlanGraph
+    config:              GeometryConfig = field(repr=False)
+    segmentation_result: object = field(default=None, repr=False)  # raw SegmentationResult
+
+    def save(self, output_dir: str, prefix: str = "") -> dict[str, str]:
+        """
+        Save all Phase 3 outputs.
+
+        Returns:
+            Dict mapping output type → file path.
+        """
+        out = Path(output_dir)
+        out.mkdir(parents=True, exist_ok=True)
+
+        stem = Path(self.source_path).stem
+        p = f"{prefix}{stem}" if prefix else stem
+
+        paths = {
+            "graph_json": str(out / f"{p}_graph.json"),
+            "scale_json": str(out / f"{p}_scale.json"),
+        }
+
+        # Save room graph as JSON
+        graph_data = self.graph.to_dict()
+        with open(paths["graph_json"], "w") as f:
+            json.dump(graph_data, f, indent=2)
+
+        # Save scale estimate
+        scale_data = {
+            "pixels_per_metre": self.scale.pixels_per_metre,
+            "metres_per_pixel": self.scale.metres_per_pixel,
+            "confidence":       self.scale.confidence,
+            "method":           self.scale.method,
+            "notes":            self.scale.notes,
+        }
+        with open(paths["scale_json"], "w") as f:
+            json.dump(scale_data, f, indent=2)
+
+        # Print summary
+        print(f"\nGeometry reconstruction complete: {self.source_path}")
+        print(f"  Scale:  {self.scale.pixels_per_metre:.1f} px/m "
+              f"(method: {self.scale.method}, "
+              f"confidence: {self.scale.confidence:.0%})")
+        print(f"  Rooms:  {len(self.graph.nodes)}")
+        print(f"  Connections: {len(self.graph.edges)}")
+        print(f"  Walls:  {len(self.vectorization.walls)} polygons")
+        print(f"  Doors:  {len(self.vectorization.doors)} polygons")
+        print(f"  Files saved to: {output_dir}/")
+
+        return paths
+
+
+# ── Pipeline ────��─────────────────────────────────────────────────────────────
+
+class GeometryPipeline:
+    """
+    Phase 3: Geometry reconstruction pipeline.
+
+    Takes Phase 2 segmentation output and produces:
+    - Vectorized wall/room/door/window polygons
+    - Pixel-to-metre scale estimate
+    - Room connectivity graph
+
+    This output feeds directly into Phase 4 (3D extrusion).
+
+    Example:
+        from src.segmentation.predictor import FloorPlanPredictor
+        from src.geometry.pipeline import GeometryPipeline
+
+        predictor = FloorPlanPredictor("models/segmentation/best.pt")
+        seg_result = predictor.predict("outputs/plan_4_cleaned.png")
+
+        geo_pipeline = GeometryPipeline()
+        geo_result = geo_pipeline.run(seg_result, image)
+        geo_result.save("outputs/geometry/")
+    """
+
+    def __init__(self, config: Optional[GeometryConfig] = None):
+        self.config = config or GeometryConfig()
+        cfg = self.config
+
+        self.vectorizer = WallVectorizer(
+            epsilon_factor=cfg.epsilon_factor,
+            min_area=cfg.min_area,
+            morph_kernel=cfg.morph_kernel,
+            simplify_walls=cfg.simplify_walls,
+        )
+        self.scale_estimator = ScaleEstimator(
+            target_image_size=cfg.target_image_size,
+        )
+        self.graph_builder = RoomGraphBuilder(
+            proximity_threshold=cfg.proximity_threshold,
+            door_proximity=cfg.door_proximity,
+        )
+
+    def run(
+        self,
+        segmentation_result,
+        image: np.ndarray,
+        image_path: str = "unknown",
+    ) -> GeometryResult:
+        """
+        Run the full Phase 3 pipeline.
+
+        Args:
+            segmentation_result: FloorPlanPredictor output (Phase 2).
+            image:               The original floor plan image (numpy array).
+            image_path:          Source path for naming output files.
+
+        Returns:
+            GeometryResult with all Phase 3 outputs.
+        """
+        # ── Step 1: Vectorize masks → polygons ────────────────────────────
+        print("[1/3] Vectorizing segmentation masks...")
+        vec_result = self.vectorizer.extract(
+            segmentation_result,
+            image_shape=image.shape[:2],
+        )
+        print(f"  Walls:   {len(vec_result.walls)}")
+        print(f"  Rooms:   {len(vec_result.rooms)}")
+        print(f"  Doors:   {len(vec_result.doors)}")
+        print(f"  Windows: {len(vec_result.windows)}")
+        
+        # Store original for comparison if debug visualization enabled
+        vec_result_before = None
+        if self.config.debug_visualization:
+            vec_result_before = vec_result
+        
+        # ── NEW: Apply detection refinement if enabled ────────────────────
+        if self.config.use_refinement and REFINEMENT_AVAILABLE:
+            print("[1.5/3] Applying detection refinement...")
+            try:
+                vec_result = refine_detections(
+                    yolo_output=segmentation_result,
+                    image=image,
+                    geometry_output=vec_result,
+                    config=self.config.refinement_config
+                )
+                print(f"  Refined Doors:   {len(vec_result.doors)}")
+                print(f"  Refined Windows: {len(vec_result.windows)}")
+                
+                # Debug visualization if enabled
+                if self.config.debug_visualization:
+                    self._create_debug_visualizations(
+                        image, vec_result_before, vec_result, image_path
+                    )
+                
+            except Exception as e:
+                print(f"  WARNING: Refinement failed: {e}")
+                print(f"  Continuing with original YOLO detections")
+        elif self.config.use_refinement and not REFINEMENT_AVAILABLE:
+            print("  WARNING: Refinement requested but module not available")
+
+        # ── Step 2: Estimate scale ─────────────────────────────────────────
+        print("[2/3] Estimating scale...")
+        scale = self.scale_estimator.estimate(image, vec_result)
+        print(f"  {scale.pixels_per_metre:.1f} px/m "
+              f"(method: {scale.method}, "
+              f"confidence: {scale.confidence:.0%})")
+
+        # ── Step 3: Build room graph ───────────────────────────────────────
+        print("[3/3] Building room connectivity graph...")
+        graph = self.graph_builder.build(vec_result, scale)
+        print(f"  {len(graph.nodes)} rooms, {len(graph.edges)} connections")
+        for node in graph.nodes:
+            print(f"  → {node.class_name}: {node.area_m2:.1f} m²")
+
+        return GeometryResult(
+            source_path=image_path,
+            vectorization=vec_result,
+            scale=scale,
+            graph=graph,
+            config=self.config,
+            segmentation_result=segmentation_result,
+        )
+    
+    def _create_debug_visualizations(
+        self,
+        image: np.ndarray,
+        vec_before: VectorizationResult,
+        vec_after: VectorizationResult,
+        image_path: str
+    ):
+        """
+        Create debug visualizations for detection refinement.
+        
+        Args:
+            image: Original image
+            vec_before: VectorizationResult before refinement
+            vec_after: VectorizationResult after refinement
+            image_path: Source image path for naming
+        """
+        try:
+            from src.utils.visualization import (
+                visualize_vectorization_result,
+                visualize_comparison
+            )
+            from pathlib import Path
+            
+            # Create output directory
+            out_dir = Path(self.config.visualization_dir)
+            out_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Get filename stem
+            stem = Path(image_path).stem
+            
+            # Create before visualization
+            before_path = str(out_dir / f"{stem}_before_refinement.png")
+            visualize_vectorization_result(image, vec_before, before_path, show_labels=False)
+            
+            # Create after visualization
+            after_path = str(out_dir / f"{stem}_after_refinement.png")
+            visualize_vectorization_result(image, vec_after, after_path, show_labels=True)
+            
+            # Create comparison
+            comparison_path = str(out_dir / f"{stem}_comparison.png")
+            detections_before = {
+                "walls": [np.array(w.points) for w in vec_before.walls],
+                "rooms": [np.array(r.points) for r in vec_before.rooms],
+                "doors": [np.array(d.points) for d in vec_before.doors],
+                "windows": [np.array(w.points) for w in vec_before.windows]
+            }
+            detections_after = {
+                "walls": [np.array(w.points) for w in vec_after.walls],
+                "rooms": [np.array(r.points) for r in vec_after.rooms],
+                "doors": [np.array(d.points) for d in vec_after.doors],
+                "windows": [np.array(w.points) for w in vec_after.windows]
+            }
+            
+            from src.utils.visualization import visualize_comparison
+            visualize_comparison(image, detections_before, detections_after, comparison_path)
+            
+            print(f"  Debug visualizations saved to: {out_dir}/")
+            
+        except Exception as e:
+            print(f"  WARNING: Failed to create debug visualizations: {e}")
+
+    def run_and_visualize(
+        self,
+        segmentation_result,
+        image: np.ndarray,
+        image_path: str = "unknown",
+        output_dir: str = "outputs/geometry",
+    ) -> tuple[GeometryResult, np.ndarray, np.ndarray]:
+        """
+        Run pipeline and generate visualization images.
+
+        Returns:
+            (GeometryResult, polygon_viz_image, graph_viz_image)
+        """
+        result = self.run(segmentation_result, image, image_path)
+
+        # Visualization 1: vectorized polygons
+        poly_viz = self.vectorizer.draw(image, result.vectorization)
+
+        # Visualization 2: room graph
+        graph_viz = self.graph_builder.draw(image, result.graph)
+
+        # Save visualizations
+        out = Path(output_dir)
+        out.mkdir(parents=True, exist_ok=True)
+        stem = Path(image_path).stem
+
+        cv2.imwrite(str(out / f"{stem}_polygons.png"), poly_viz)
+        cv2.imwrite(str(out / f"{stem}_graph.png"), graph_viz)
+
+        return result, poly_viz, graph_viz
+
+    def run_batch(
+        self,
+        items: list[dict],
+        output_dir: str,
+    ) -> list[GeometryResult]:
+        """
+        Run geometry pipeline on multiple floor plans.
+
+        Args:
+            items: List of dicts with keys 'segmentation_result',
+                   'image', 'image_path'.
+            output_dir: Where to save outputs.
+
+        Returns:
+            List of GeometryResult objects.
+        """
+        results = []
+        for i, item in enumerate(items, 1):
+            print(f"\n── [{i}/{len(items)}] {item.get('image_path', '?')} ──")
+            try:
+                result = self.run(
+                    item["segmentation_result"],
+                    item["image"],
+                    item.get("image_path", f"item_{i}"),
+                )
+                result.save(output_dir)
+                results.append(result)
+            except Exception as e:
+                print(f"  ERROR: {e}")
+        return results

src/geometry/room_graph.py

@@ -0,0 +1,298 @@
+"""
+room_graph.py
+-------------
+Builds a room connectivity graph from vectorized floor plan polygons.
+
+The graph encodes:
+  - Nodes: rooms (with metadata — type, area, centroid)
+  - Edges: connections between rooms via doors or shared walls
+
+This structured representation is the bridge between 2D geometry
+and the 3D reconstruction in Phase 4.
+
+Usage:
+    from src.geometry.room_graph import RoomGraphBuilder
+
+    builder = RoomGraphBuilder()
+    graph = builder.build(vectorization_result, scale_estimate)
+    print(graph.summary)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+import math
+import numpy as np
+import cv2
+
+
+# ── Data structures ───────────────────────────────────────────────────────────
+
+@dataclass
+class RoomNode:
+    """A single room in the floor plan graph."""
+    node_id:    int
+    class_name: str
+    class_id:   int
+    centroid:   tuple[float, float]     # (x, y) in pixels
+    area_px:    float
+    area_m2:    float                   # real-world area
+    bbox:       tuple[int, int, int, int]  # (x, y, w, h) pixels
+    polygon:    list[tuple[int, int]]   # pixel boundary points
+
+    @property
+    def label(self) -> str:
+        return f"{self.class_name} ({self.area_m2:.1f}m²)"
+
+
+@dataclass
+class RoomEdge:
+    """A connection between two rooms."""
+    node_a:      int           # node_id of room A
+    node_b:      int           # node_id of room B
+    edge_type:   str           # 'door', 'opening', 'shared_wall'
+    via_element: Optional[int] = None   # index of door/window polygon if any
+    distance_px: float = 0.0
+
+
+@dataclass
+class FloorPlanGraph:
+    """Complete room connectivity graph for one floor plan."""
+    nodes:  list[RoomNode] = field(default_factory=list)
+    edges:  list[RoomEdge] = field(default_factory=list)
+    scale_method: str = "unknown"
+
+    @property
+    def summary(self) -> dict:
+        return {
+            "rooms":       len(self.nodes),
+            "connections": len(self.edges),
+            "room_types":  [n.class_name for n in self.nodes],
+            "total_area_m2": round(sum(n.area_m2 for n in self.nodes), 2),
+            "scale_method": self.scale_method,
+        }
+
+    def get_node(self, node_id: int) -> Optional[RoomNode]:
+        for node in self.nodes:
+            if node.node_id == node_id:
+                return node
+        return None
+
+    def get_neighbours(self, node_id: int) -> list[RoomNode]:
+        neighbour_ids = set()
+        for edge in self.edges:
+            if edge.node_a == node_id:
+                neighbour_ids.add(edge.node_b)
+            elif edge.node_b == node_id:
+                neighbour_ids.add(edge.node_a)
+        return [self.get_node(nid) for nid in neighbour_ids if self.get_node(nid)]
+
+    def to_dict(self) -> dict:
+        """Serialisable representation for saving/loading."""
+        return {
+            "nodes": [
+                {
+                    "id":         n.node_id,
+                    "class_name": n.class_name,
+                    "class_id":   n.class_id,
+                    "centroid":   list(n.centroid),
+                    "area_px":    n.area_px,
+                    "area_m2":    n.area_m2,
+                    "bbox":       list(n.bbox),
+                    "polygon":    n.polygon,
+                }
+                for n in self.nodes
+            ],
+            "edges": [
+                {
+                    "node_a":    e.node_a,
+                    "node_b":    e.node_b,
+                    "edge_type": e.edge_type,
+                    "distance":  e.distance_px,
+                }
+                for e in self.edges
+            ],
+            "summary": self.summary,
+        }
+
+
+# ── Graph builder ─────────────────────────────────────────────────────────────
+
+class RoomGraphBuilder:
+    """
+    Builds a room connectivity graph from Phase 3 vectorization output.
+
+    Connection strategy:
+      1. Door proximity — if a door polygon centroid is between two room
+         centroids, connect those rooms with a 'door' edge.
+      2. Centroid proximity — rooms whose centroids are within
+         proximity_threshold pixels are connected with a 'shared_wall' edge.
+
+    Args:
+        proximity_threshold: Max distance between room centroids to infer
+                             adjacency (pixels). Scaled with image size.
+        door_proximity:      Max distance from a door to a room centroid
+                             to consider the door as connecting that room.
+    """
+
+    def __init__(
+        self,
+        proximity_threshold: int = 200,
+        door_proximity: int = 150,
+    ):
+        self.proximity_threshold = proximity_threshold
+        self.door_proximity = door_proximity
+
+    def build(
+        self,
+        vectorization_result,
+        scale_estimate=None,
+    ) -> FloorPlanGraph:
+        """
+        Build the room graph from a VectorizationResult.
+
+        Args:
+            vectorization_result: Output from WallVectorizer.extract()
+            scale_estimate:       Output from ScaleEstimator.estimate()
+
+        Returns:
+            FloorPlanGraph with nodes and edges.
+        """
+        graph = FloorPlanGraph(
+            scale_method=scale_estimate.method if scale_estimate else "none"
+        )
+
+        # ── Step 1: Create room nodes ──────────────────────────────────────
+        for i, room in enumerate(vectorization_result.rooms):
+            area_m2 = 0.0
+            if scale_estimate:
+                area_m2 = scale_estimate.area_px_to_m2(room.area)
+
+            cx, cy = room.centroid
+            node = RoomNode(
+                node_id=i,
+                class_name=room.class_name,
+                class_id=room.class_id,
+                centroid=(cx, cy),
+                area_px=room.area,
+                area_m2=round(area_m2, 2),
+                bbox=room.bbox,
+                polygon=room.points,
+            )
+            graph.nodes.append(node)
+
+        if not graph.nodes:
+            return graph
+
+        # ── Step 2: Connect rooms via doors ───────────────────────────────
+        for door_idx, door in enumerate(vectorization_result.doors):
+            door_cx, door_cy = door.centroid
+            nearby_rooms = []
+
+            for node in graph.nodes:
+                dist = _euclidean(door_cx, door_cy, *node.centroid)
+                if dist <= self.door_proximity:
+                    nearby_rooms.append((dist, node.node_id))
+
+            nearby_rooms.sort()
+            if len(nearby_rooms) >= 2:
+                _, id_a = nearby_rooms[0]
+                _, id_b = nearby_rooms[1]
+                if id_a != id_b and not _edge_exists(graph, id_a, id_b):
+                    graph.edges.append(RoomEdge(
+                        node_a=id_a,
+                        node_b=id_b,
+                        edge_type="door",
+                        via_element=door_idx,
+                        distance_px=nearby_rooms[1][0],
+                    ))
+
+        # ── Step 3: Connect adjacent rooms by centroid proximity ──────────
+        n = len(graph.nodes)
+        for i in range(n):
+            for j in range(i + 1, n):
+                node_a = graph.nodes[i]
+                node_b = graph.nodes[j]
+                dist = _euclidean(*node_a.centroid, *node_b.centroid)
+
+                if dist <= self.proximity_threshold:
+                    if not _edge_exists(graph, node_a.node_id, node_b.node_id):
+                        graph.edges.append(RoomEdge(
+                            node_a=node_a.node_id,
+                            node_b=node_b.node_id,
+                            edge_type="shared_wall",
+                            distance_px=dist,
+                        ))
+
+        return graph
+
+    def draw(
+        self,
+        image: np.ndarray,
+        graph: FloorPlanGraph,
+    ) -> np.ndarray:
+        """
+        Visualise the room graph overlaid on the floor plan image.
+
+        Nodes drawn as circles with room labels.
+        Edges drawn as lines between centroids, coloured by type.
+        """
+        if len(image.shape) == 2:
+            canvas = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        else:
+            canvas = image.copy()
+
+        edge_colors = {
+            "door":        (50,  200, 200),
+            "shared_wall": (150, 150, 150),
+            "opening":     (200, 180,  50),
+        }
+
+        # Draw edges first (behind nodes)
+        for edge in graph.edges:
+            node_a = graph.get_node(edge.node_a)
+            node_b = graph.get_node(edge.node_b)
+            if node_a and node_b:
+                color = edge_colors.get(edge.edge_type, (200, 200, 200))
+                pt_a = (int(node_a.centroid[0]), int(node_a.centroid[1]))
+                pt_b = (int(node_b.centroid[0]), int(node_b.centroid[1]))
+                cv2.line(canvas, pt_a, pt_b, color, 2)
+
+                # Label edge type at midpoint
+                mid = ((pt_a[0] + pt_b[0]) // 2, (pt_a[1] + pt_b[1]) // 2)
+                cv2.putText(canvas, edge.edge_type, mid,
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.3, color, 1)
+
+        # Draw nodes
+        for node in graph.nodes:
+            cx, cy = int(node.centroid[0]), int(node.centroid[1])
+            cv2.circle(canvas, (cx, cy), 12, (50, 50, 200), -1)
+            cv2.circle(canvas, (cx, cy), 12, (255, 255, 255), 2)
+            cv2.putText(
+                canvas,
+                f"{node.class_name}",
+                (cx - 30, cy - 16),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1,
+            )
+            cv2.putText(
+                canvas,
+                f"{node.area_m2:.1f}m²",
+                (cx - 20, cy + 26),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.35, (200, 220, 200), 1,
+            )
+
+        return canvas
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _euclidean(x1, y1, x2, y2) -> float:
+    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+
+def _edge_exists(graph: FloorPlanGraph, id_a: int, id_b: int) -> bool:
+    for edge in graph.edges:
+        if (edge.node_a == id_a and edge.node_b == id_b) or \
+           (edge.node_a == id_b and edge.node_b == id_a):
+            return True
+    return False

src/geometry/scale_estimator.py

@@ -0,0 +1,262 @@
+"""
+scale_estimator.py
+------------------
+Estimates the pixel-to-metre scale of a floor plan image.
+
+Strategies (in priority order):
+  1. OCR — detect dimension annotations in the image (e.g. "4.5m", "450cm")
+  2. Standard room size — use detected room polygons and compare to known
+     average room dimensions to infer scale
+  3. Fallback — assume a standard A4/A3 drawing at 1:100 scale
+
+Usage:
+    from src.geometry.scale_estimator import ScaleEstimator
+
+    estimator = ScaleEstimator()
+    scale = estimator.estimate(image, vectorization_result)
+    print(f"1 pixel = {scale.pixels_per_metre:.2f} px/m")
+    real_area = polygon.area / (scale.pixels_per_metre ** 2)
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+import cv2
+import numpy as np
+
+
+# ── Data structures ───────────────────────────────────────────────────────────
+
+@dataclass
+class ScaleEstimate:
+    """Pixel-to-real-world scale estimate."""
+    pixels_per_metre: float         # How many pixels = 1 metre
+    confidence:       float         # 0-1, how confident we are
+    method:           str           # 'ocr', 'room_size', 'fallback'
+    notes:            str = ""
+
+    @property
+    def metres_per_pixel(self) -> float:
+        return 1.0 / self.pixels_per_metre
+
+    def pixels_to_metres(self, pixels: float) -> float:
+        return pixels / self.pixels_per_metre
+
+    def metres_to_pixels(self, metres: float) -> float:
+        return metres * self.pixels_per_metre
+
+    def area_px_to_m2(self, area_px: float) -> float:
+        return area_px / (self.pixels_per_metre ** 2)
+
+
+# ── Known room size priors (metres²) ─────────────────────────────────────────
+
+ROOM_SIZE_PRIORS = {
+    "Bedroom":    (9.0,  20.0),   # typical: 9–20 m²
+    "LivingRoom": (15.0, 40.0),   # typical: 15–40 m²
+    "Kitchen":    (7.0,  20.0),   # typical: 7–20 m²
+    "Bathroom":   (3.0,  8.0),    # typical: 3–8 m²
+    "Corridor":   (2.0,  12.0),   # typical: 2–12 m²
+    "Balcony":    (2.0,  10.0),   # typical: 2–10 m²
+}
+
+
+# ── Scale estimator ───────────────────────────────────────────────────────────
+
+class ScaleEstimator:
+    """
+    Estimates pixel-to-metre conversion factor for a floor plan.
+
+    Args:
+        target_image_size: The longer dimension of the normalized image (px).
+                           Should match Phase 1 target_size (default 1024).
+        fallback_scale:    Metres per pixel to use when all else fails.
+                           Default assumes a 10m × 10m plan at 1024px = 10m.
+    """
+
+    def __init__(
+        self,
+        target_image_size: int = 1024,
+        fallback_scale: float = 0.015,  # ~15mm per pixel = typical floor plan
+    ):
+        self.target_image_size = target_image_size
+        self.fallback_scale = fallback_scale
+
+    def estimate(
+        self,
+        image: np.ndarray,
+        vectorization_result=None,
+    ) -> ScaleEstimate:
+        """
+        Estimate scale using all available strategies.
+
+        Args:
+            image:                Grayscale or BGR floor plan image.
+            vectorization_result: Optional VectorizationResult from Phase 3.
+
+        Returns:
+            ScaleEstimate with best available estimate.
+        """
+        # Strategy 1: OCR-based scale detection
+        ocr_result = self._estimate_from_ocr(image)
+        if ocr_result is not None:
+            return ocr_result
+
+        # Strategy 2: Room size heuristics
+        if vectorization_result is not None and vectorization_result.rooms:
+            room_result = self._estimate_from_rooms(vectorization_result)
+            if room_result is not None:
+                return room_result
+
+        # Strategy 3: Fallback
+        return self._fallback_estimate(image)
+
+    def pixels_to_metres(self, pixels: float, scale: ScaleEstimate) -> float:
+        return scale.pixels_to_metres(pixels)
+
+    # ── Strategies ────────────────────────────────────────────────────────────
+
+    def _estimate_from_ocr(
+        self, image: np.ndarray
+    ) -> Optional[ScaleEstimate]:
+        """
+        Try to detect dimension text (e.g. '4.5m', '3500mm', '450cm')
+        in the image using pytesseract OCR.
+        """
+        try:
+            import pytesseract
+        except ImportError:
+            return None
+
+        try:
+            # Preprocess for OCR — invert if needed, sharpen
+            if len(image.shape) == 3:
+                gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            else:
+                gray = image.copy()
+
+            # Upscale small images for better OCR
+            h, w = gray.shape[:2]
+            if max(h, w) < 1000:
+                scale_up = 1000 / max(h, w)
+                gray = cv2.resize(gray, None, fx=scale_up, fy=scale_up,
+                                  interpolation=cv2.INTER_LINEAR)
+
+            # Threshold for cleaner text
+            _, thresh = cv2.threshold(gray, 0, 255,
+                                      cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+            text = pytesseract.image_to_string(
+                thresh,
+                config='--psm 11 -c tessedit_char_whitelist=0123456789.,m c'
+            )
+
+            scale = self._parse_dimension_text(text, image.shape)
+            if scale is not None:
+                return scale
+
+        except Exception:
+            pass
+
+        return None
+
+    def _parse_dimension_text(
+        self, text: str, image_shape: tuple
+    ) -> Optional[ScaleEstimate]:
+        """Parse OCR text to find dimension annotations."""
+        h, w = image_shape[:2]
+        img_size = max(h, w)
+
+        # Patterns: "4.5m", "4,500mm", "450cm", "4.5 m"
+        patterns = [
+            (r'(\d+\.?\d*)\s*m(?:etres?|eters?)?\b(?!m)', 1.0),      # metres
+            (r'(\d+\.?\d*)\s*cm\b', 0.01),                             # cm → m
+            (r'(\d{3,5})\s*mm\b', 0.001),                              # mm → m
+        ]
+
+        found_dims = []
+        for pattern, multiplier in patterns:
+            for match in re.finditer(pattern, text, re.IGNORECASE):
+                value_m = float(match.group(1)) * multiplier
+                if 0.5 <= value_m <= 50.0:  # sanity check: 0.5m to 50m
+                    found_dims.append(value_m)
+
+        if not found_dims:
+            return None
+
+        # Use median dimension as reference
+        ref_dim_m = float(np.median(found_dims))
+
+        # Assume the reference dimension spans ~40% of the image
+        ref_dim_px = img_size * 0.4
+        pixels_per_metre = ref_dim_px / ref_dim_m
+
+        return ScaleEstimate(
+            pixels_per_metre=pixels_per_metre,
+            confidence=0.75,
+            method="ocr",
+            notes=f"Detected dimension: {ref_dim_m:.2f}m from OCR",
+        )
+
+    def _estimate_from_rooms(self, vectorization_result) -> Optional[ScaleEstimate]:
+        """
+        Use known room size priors to estimate scale.
+        Compares detected room pixel areas to expected real-world areas.
+        """
+        scale_estimates = []
+
+        for room in vectorization_result.rooms:
+            class_name = room.class_name
+            if class_name not in ROOM_SIZE_PRIORS:
+                continue
+
+            min_m2, max_m2 = ROOM_SIZE_PRIORS[class_name]
+            mid_m2 = (min_m2 + max_m2) / 2.0
+            area_px = room.area
+
+            if area_px <= 0:
+                continue
+
+            # pixels_per_metre² = area_px / mid_m2
+            # pixels_per_metre = sqrt(area_px / mid_m2)
+            ppm = (area_px / mid_m2) ** 0.5
+            scale_estimates.append(ppm)
+
+        if not scale_estimates:
+            return None
+
+        # Use median to be robust against outliers
+        ppm = float(np.median(scale_estimates))
+
+        # Sanity check: 10–500 px/m is reasonable
+        if not (10 <= ppm <= 500):
+            return None
+
+        return ScaleEstimate(
+            pixels_per_metre=ppm,
+            confidence=0.55,
+            method="room_size",
+            notes=f"Estimated from {len(scale_estimates)} room(s)",
+        )
+
+    def _fallback_estimate(self, image: np.ndarray) -> ScaleEstimate:
+        """
+        Fallback: assume standard floor plan proportions.
+        A 1024px image typically represents a ~10-15m building footprint.
+        """
+        h, w = image.shape[:2]
+        img_size = max(h, w)
+
+        # Assume building footprint ≈ 12m on the longer axis
+        assumed_building_size_m = 12.0
+        ppm = img_size / assumed_building_size_m
+
+        return ScaleEstimate(
+            pixels_per_metre=ppm,
+            confidence=0.30,
+            method="fallback",
+            notes=f"Fallback: assumed {assumed_building_size_m}m building at {img_size}px",
+        )

src/geometry/wall_vectorizer.py

@@ -0,0 +1,294 @@
+"""
+wall_vectorizer.py
+------------------
+Converts YOLOv8 segmentation masks into clean 2D wall polygons.
+
+Pipeline per mask:
+  1. Binarize mask
+  2. Morphological cleanup (close gaps, remove noise)
+  3. Find contours
+  4. Approximate contours to simplified polygons (Douglas-Peucker)
+  5. Filter by area and aspect ratio
+  6. Return list of WallPolygon objects
+
+Usage:
+    from src.geometry.wall_vectorizer import WallVectorizer
+
+    vectorizer = WallVectorizer()
+    walls = vectorizer.extract(segmentation_result, image_shape)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+import cv2
+import numpy as np
+
+
+# ── Data structures ───────────────────────────────────────────────────────────
+
+@dataclass
+class WallPolygon:
+    """A single vectorized wall or room boundary polygon."""
+    class_id:   int
+    class_name: str
+    points:     list[tuple[int, int]]    # pixel coordinates (x, y)
+    area:       float                    # pixel area
+    bbox:       tuple[int, int, int, int]  # (x, y, w, h)
+    confidence: float = 1.0
+
+    @property
+    def is_wall(self) -> bool:
+        return self.class_id in (0, 1)  # OuterWall, InnerWall
+
+    @property
+    def is_room(self) -> bool:
+        return self.class_id in (6, 7, 8, 9, 10, 11, 12)
+
+    @property
+    def centroid(self) -> tuple[float, float]:
+        if not self.points:
+            return (0.0, 0.0)
+        xs = [p[0] for p in self.points]
+        ys = [p[1] for p in self.points]
+        return (sum(xs) / len(xs), sum(ys) / len(ys))
+
+    def to_numpy(self) -> np.ndarray:
+        """Return points as (N, 2) numpy array."""
+        return np.array(self.points, dtype=np.int32)
+
+
+@dataclass
+class VectorizationResult:
+    """All vectorized elements from one floor plan."""
+    walls:    list[WallPolygon] = field(default_factory=list)
+    rooms:    list[WallPolygon] = field(default_factory=list)
+    doors:    list[WallPolygon] = field(default_factory=list)
+    windows:  list[WallPolygon] = field(default_factory=list)
+    other:    list[WallPolygon] = field(default_factory=list)
+    image_shape: tuple[int, int] = (0, 0)
+
+    @property
+    def all_polygons(self) -> list[WallPolygon]:
+        return self.walls + self.rooms + self.doors + self.windows + self.other
+
+    @property
+    def summary(self) -> dict:
+        return {
+            "walls":   len(self.walls),
+            "rooms":   len(self.rooms),
+            "doors":   len(self.doors),
+            "windows": len(self.windows),
+            "other":   len(self.other),
+            "total":   len(self.all_polygons),
+        }
+
+
+# ── Vectorizer ────────────────────────────────────────────────────────────────
+
+class WallVectorizer:
+    """
+    Converts segmentation masks into clean 2D vector polygons.
+
+    Args:
+        epsilon_factor:   Douglas-Peucker approximation factor
+                          (fraction of arc length). Lower = more detail.
+        min_area:         Discard polygons smaller than this (px²).
+        morph_kernel:     Kernel size for morphological cleanup.
+        simplify_walls:   Extra simplification pass for wall polygons.
+    """
+
+    # Which class_ids map to which category (0-indexed, background excluded)
+    WALL_IDS    = {0, 1}          # OuterWall, InnerWall
+    DOOR_IDS    = {3}             # Door
+    WINDOW_IDS  = {2}             # Window
+    ROOM_IDS    = {6, 7, 8, 9, 10, 11, 12}  # room types
+
+    CLASS_NAMES = [
+        "OuterWall", "InnerWall", "Window", "Door", "Stairs",
+        "Railing", "Kitchen", "LivingRoom", "Bedroom", "Bathroom",
+        "Corridor", "Balcony", "Garage",
+    ]
+
+    def __init__(
+        self,
+        epsilon_factor: float = 0.008,
+        min_area: int = 200,
+        morph_kernel: int = 3,
+        simplify_walls: bool = True,
+    ):
+        self.epsilon_factor = epsilon_factor
+        self.min_area = min_area
+        self.morph_kernel = morph_kernel
+        self.simplify_walls = simplify_walls
+
+    def extract(
+        self,
+        segmentation_result,
+        image_shape: Optional[tuple] = None,
+    ) -> VectorizationResult:
+        """
+        Extract vector polygons from a SegmentationResult (Phase 2 output).
+
+        Args:
+            segmentation_result: FloorPlanPredictor result object.
+            image_shape:         (H, W) of the source image.
+
+        Returns:
+            VectorizationResult with categorized polygons.
+        """
+        if image_shape is None:
+            image_shape = segmentation_result.image_shape
+
+        h, w = image_shape[:2]
+        result = VectorizationResult(image_shape=(h, w))
+
+        for element in segmentation_result.elements:
+            if element.mask is None:
+                continue
+
+            polygons = self._mask_to_polygons(
+                mask=element.mask,
+                class_id=element.class_id,
+                class_name=element.class_name,
+                confidence=element.confidence,
+                is_wall=(element.class_id in self.WALL_IDS),
+            )
+
+            for poly in polygons:
+                if poly.class_id in self.WALL_IDS:
+                    result.walls.append(poly)
+                elif poly.class_id in self.DOOR_IDS:
+                    result.doors.append(poly)
+                elif poly.class_id in self.WINDOW_IDS:
+                    result.windows.append(poly)
+                elif poly.class_id in self.ROOM_IDS:
+                    result.rooms.append(poly)
+                else:
+                    result.other.append(poly)
+
+        return result
+
+    def extract_from_mask(
+        self,
+        mask: np.ndarray,
+        class_id: int,
+        class_name: str,
+        confidence: float = 1.0,
+    ) -> list[WallPolygon]:
+        """
+        Extract polygons directly from a binary mask array.
+        Useful for testing without a full SegmentationResult.
+        """
+        return self._mask_to_polygons(
+            mask=mask,
+            class_id=class_id,
+            class_name=class_name,
+            confidence=confidence,
+            is_wall=(class_id in self.WALL_IDS),
+        )
+
+    # ── Internal helpers ──────────────────────────────────────────────────────
+
+    def _mask_to_polygons(
+        self,
+        mask: np.ndarray,
+        class_id: int,
+        class_name: str,
+        confidence: float,
+        is_wall: bool,
+    ) -> list[WallPolygon]:
+        """Convert a binary mask to a list of simplified polygons."""
+
+        # Ensure binary uint8
+        binary = (mask > 127).astype(np.uint8) * 255
+
+        # Morphological cleanup
+        k = self.morph_kernel
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (k, k))
+        binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
+        binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
+
+        # Find external contours
+        contours, _ = cv2.findContours(
+            binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+        )
+
+        polygons = []
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            if area < self.min_area:
+                continue
+
+            # Douglas-Peucker simplification
+            epsilon = self.epsilon_factor * cv2.arcLength(contour, closed=True)
+
+            # Walls get extra simplification to remove noise
+            if is_wall and self.simplify_walls:
+                epsilon *= 1.5
+
+            approx = cv2.approxPolyDP(contour, epsilon, closed=True)
+
+            # Need at least 3 points for a valid polygon
+            if len(approx) < 3:
+                continue
+
+            points = [(int(pt[0][0]), int(pt[0][1])) for pt in approx]
+            x, y, w, h = cv2.boundingRect(contour)
+
+            polygons.append(WallPolygon(
+                class_id=class_id,
+                class_name=class_name,
+                points=points,
+                area=float(area),
+                bbox=(x, y, w, h),
+                confidence=confidence,
+            ))
+
+        # Sort by area descending (largest first)
+        polygons.sort(key=lambda p: p.area, reverse=True)
+        return polygons
+
+    def draw(
+        self,
+        image: np.ndarray,
+        result: VectorizationResult,
+        draw_labels: bool = True,
+    ) -> np.ndarray:
+        """
+        Draw vectorized polygons on an image for visualization.
+
+        Returns annotated BGR image.
+        """
+        if len(image.shape) == 2:
+            canvas = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        else:
+            canvas = image.copy()
+
+        colors = {
+            "wall":    (50,  50,  200),
+            "door":    (50,  200, 200),
+            "window":  (200, 180,  50),
+            "room":    (50,  180,  80),
+            "other":   (150, 150, 150),
+        }
+
+        def draw_poly(polys, color, label_prefix=""):
+            for poly in polys:
+                pts = np.array(poly.points, dtype=np.int32)
+                cv2.polylines(canvas, [pts], isClosed=True,
+                              color=color, thickness=2)
+                if draw_labels:
+                    cx, cy = int(poly.centroid[0]), int(poly.centroid[1])
+                    cv2.putText(canvas, poly.class_name,
+                                (cx, cy), cv2.FONT_HERSHEY_SIMPLEX,
+                                0.4, color, 1, cv2.LINE_AA)
+
+        draw_poly(result.walls,   colors["wall"])
+        draw_poly(result.doors,   colors["door"])
+        draw_poly(result.windows, colors["window"])
+        draw_poly(result.rooms,   colors["room"])
+        draw_poly(result.other,   colors["other"])
+
+        return canvas

src/preprocessing/binarizer.py

@@ -0,0 +1,122 @@
+"""
+binarizer.py
+------------
+Converts a grayscale floor plan image into a clean binary (black/white) image.
+
+Pipeline:
+  1. Gaussian blur  →  reduce sensor/scan noise
+  2. Adaptive threshold  →  handle uneven lighting across the page
+  3. Morphological close  →  fill tiny gaps in wall lines
+  4. Morphological open   →  remove isolated specks
+"""
+
+import cv2
+import numpy as np
+
+
+def binarize(
+    img: np.ndarray,
+    blur_kernel: int = 5,
+    block_size: int = 25,
+    c_offset: int = 10,
+    morph_kernel: int = 3,
+) -> np.ndarray:
+    """
+    Convert a grayscale image to a clean binary image.
+
+    Args:
+        img:          Grayscale uint8 numpy array.
+        blur_kernel:  Gaussian blur kernel size (must be odd).
+        block_size:   Neighbourhood size for adaptive threshold (must be odd, ≥3).
+        c_offset:     Constant subtracted from the mean in adaptive threshold.
+                      Higher = more aggressive (removes faint lines too).
+        morph_kernel: Kernel size for morphological cleanup.
+
+    Returns:
+        Binary image (0 = background, 255 = foreground/walls), uint8.
+    """
+    _validate_grayscale(img)
+
+    # 1. Gaussian blur to suppress scan noise
+    blurred = cv2.GaussianBlur(img, (blur_kernel, blur_kernel), 0)
+
+    # 2. Adaptive threshold — handles uneven illumination better than Otsu
+    #    THRESH_BINARY_INV: walls/lines become white (255) on black background
+    binary = cv2.adaptiveThreshold(
+        blurred,
+        maxValue=255,
+        adaptiveMethod=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        thresholdType=cv2.THRESH_BINARY_INV,
+        blockSize=block_size,
+        C=c_offset,
+    )
+
+    # 3. Morphological closing: fills small breaks in wall lines
+    close_kernel = cv2.getStructuringElement(
+        cv2.MORPH_RECT, (morph_kernel, morph_kernel)
+    )
+    binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, close_kernel)
+
+    # 4. Morphological opening: removes isolated noise specks
+    open_kernel = cv2.getStructuringElement(
+        cv2.MORPH_RECT, (morph_kernel, morph_kernel)
+    )
+    binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, open_kernel)
+
+    return binary
+
+
+def remove_small_components(
+    binary: np.ndarray, min_area: int = 100
+) -> np.ndarray:
+    """
+    Remove connected components smaller than min_area pixels.
+    Useful for eliminating text fragments and scan artifacts.
+
+    Args:
+        binary:   Binary image (uint8, values 0 or 255).
+        min_area: Components with fewer pixels than this are removed.
+
+    Returns:
+        Cleaned binary image.
+    """
+    _validate_grayscale(binary)
+
+    num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(
+        binary, connectivity=8
+    )
+
+    # Background is label 0 — skip it
+    cleaned = np.zeros_like(binary)
+    for label in range(1, num_labels):
+        area = stats[label, cv2.CC_STAT_AREA]
+        if area >= min_area:
+            cleaned[labels == label] = 255
+
+    return cleaned
+
+
+def enhance_contrast(img: np.ndarray) -> np.ndarray:
+    """
+    Apply CLAHE (Contrast Limited Adaptive Histogram Equalization).
+    Improves visibility of faint lines before thresholding.
+
+    Args:
+        img: Grayscale uint8 numpy array.
+
+    Returns:
+        Contrast-enhanced grayscale image.
+    """
+    _validate_grayscale(img)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    return clahe.apply(img)
+
+
+def _validate_grayscale(img: np.ndarray) -> None:
+    if img is None or not isinstance(img, np.ndarray):
+        raise TypeError("Input must be a numpy ndarray.")
+    if len(img.shape) != 2:
+        raise ValueError(
+            f"Expected a grayscale (2D) image, got shape {img.shape}. "
+            "Convert to grayscale first."
+        )

src/preprocessing/loader.py

@@ -0,0 +1,107 @@
+"""
+loader.py
+---------
+Handles loading floor plan images from disk.
+Supports: PNG, JPG, JPEG, BMP, TIFF, PDF (first page via PIL).
+Normalizes to a standard resolution while preserving aspect ratio.
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+from pathlib import Path
+
+
+SUPPORTED_FORMATS = {".png", ".jpg", ".jpeg", ".bmp", ".tiff", ".tif", ".pdf"}
+
+
+def load_image(image_path: str, target_size: int = 1024) -> np.ndarray:
+    """
+    Load a floor plan image and normalize it to a standard size.
+
+    Args:
+        image_path: Path to the input image file.
+        target_size: The longer dimension will be resized to this value.
+                     Aspect ratio is preserved.
+
+    Returns:
+        Grayscale numpy array of shape (H, W), dtype uint8.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        ValueError: If the file format is not supported.
+    """
+    path = Path(image_path)
+
+    if not path.exists():
+        raise FileNotFoundError(f"Image not found: {image_path}")
+
+    if path.suffix.lower() not in SUPPORTED_FORMATS:
+        raise ValueError(
+            f"Unsupported format '{path.suffix}'. "
+            f"Supported: {SUPPORTED_FORMATS}"
+        )
+
+    # PDF: extract first page as image
+    if path.suffix.lower() == ".pdf":
+        img = _load_pdf_page(path)
+    else:
+        img = _load_raster(path)
+
+    # Convert to grayscale if needed
+    if len(img.shape) == 3:
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+    # Resize to target_size along the longer dimension
+    img = _resize_keep_aspect(img, target_size)
+
+    return img
+
+
+def _load_raster(path: Path) -> np.ndarray:
+    """Load PNG/JPG/BMP/TIFF using OpenCV."""
+    img = cv2.imread(str(path), cv2.IMREAD_UNCHANGED)
+    if img is None:
+        raise IOError(f"OpenCV could not read image: {path}")
+    return img
+
+
+def _load_pdf_page(path: Path, page: int = 0, dpi: int = 200) -> np.ndarray:
+    """
+    Load the first page of a PDF as a numpy array using PIL.
+    Requires Pillow with PDF support.
+    """
+    try:
+        pil_img = Image.open(str(path))
+        pil_img.load()
+        # For multi-page PDFs, seek to desired page
+        if hasattr(pil_img, "n_frames") and pil_img.n_frames > page:
+            pil_img.seek(page)
+        pil_img = pil_img.convert("RGB")
+        return cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+    except Exception as e:
+        raise IOError(f"Failed to load PDF '{path}': {e}")
+
+
+def _resize_keep_aspect(img: np.ndarray, target_size: int) -> np.ndarray:
+    """
+    Resize image so its longer dimension equals target_size.
+    Uses INTER_AREA for downscaling (best quality for line drawings).
+    """
+    h, w = img.shape[:2]
+    if max(h, w) == target_size:
+        return img
+
+    scale = target_size / max(h, w)
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+
+    interpolation = cv2.INTER_AREA if scale < 1 else cv2.INTER_LINEAR
+    return cv2.resize(img, (new_w, new_h), interpolation=interpolation)
+
+
+def save_image(img: np.ndarray, output_path: str) -> None:
+    """Save a numpy array as an image file."""
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(output_path, img)
+    print(f"Saved: {output_path}")