Create app.py

app.py

@@ -0,0 +1,921 @@
+import os
+import asyncio
+from typing import List, Dict, Any, Optional, Union
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import uvicorn
+import logging
+import json
+import re
+from io import BytesIO
+import math
+import fitz  # PyMuPDF
+from PIL import Image
+import google.generativeai as genai
+# version = 0.0.2
+# Configure logging 
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),  # Log to console
+        logging.FileHandler("floor_plan_api.log")  # Log to file
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Initialize API Key
+GOOGLE_API_KEY = os.environ.get('GOOGLE_API_KEY')
+if not GOOGLE_API_KEY:
+    logger.warning("GOOGLE_API_KEY environment variable not set!")
+else:
+    genai.configure(api_key=GOOGLE_API_KEY)
+
+# Create uploads directory
+os.makedirs("uploads", exist_ok=True)
+
+# Data models
+class FloorPlanQuery(BaseModel):
+    """
+    Query parameters for floor plan analysis
+    
+    Attributes:
+        description (str, optional): Additional description of the floor plan
+    """
+    description: Optional[str] = None
+
+class RoomQuery(BaseModel):
+    """
+    Query parameters for room search
+    
+    Attributes:
+        room_name (str): Name or partial name of the room to find
+        exact_match (bool): Whether to match the name exactly or do partial matching
+    """
+    room_name: str
+    exact_match: bool = False
+
+class PDF:
+    def __init__(self, filename, content_type):
+        self.filename = filename
+        self.content_type = content_type
+        self.id = re.sub(r'[^a-zA-Z0-9]', '_', filename)
+        self.processed = False
+        self.error = None
+        self.images = []
+        self.page_count = 0
+        self.file_type = "pdf" if content_type == "application/pdf" else "image"  # Added to support images
+        self.measurement_info = {
+            "scale": 100,  # Default scale 1:100
+            "ceiling_height": 2.4,  # Default ceiling height in meters
+            "room_dimensions": {}
+        }
+        self.analysis_result = None  # Will store the room analysis result
+        
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "filename": self.filename,
+            "content_type": self.content_type,
+            "file_type": self.file_type,  # Added to response
+            "processed": self.processed,
+            "error": self.error,
+            "page_count": self.page_count if self.file_type == "pdf" else None,
+            "image_count": len(self.images) if self.images else 0,
+            "measurement_info": self.measurement_info,
+            "has_analysis": self.analysis_result is not None,
+            "room_count": len(self.analysis_result) if self.analysis_result else 0
+        }
+
+# Floor Plan Processor Class
+class FloorPlanProcessor:
+    def __init__(self):
+        self.model = genai.GenerativeModel('gemini-1.5-pro-latest')
+        self.pdfs = {}  # Keep the original name for backward compatibility
+        # Define supported image formats
+        self.supported_image_formats = {
+            "image/jpeg": ".jpg", 
+            "image/png": ".png", 
+            "image/gif": ".gif", 
+            "image/bmp": ".bmp", 
+            "image/tiff": ".tiff",
+            "image/webp": ".webp"
+        }
+    
+    async def process_upload(self, file_content, filename, content_type):
+        """Process uploaded content based on file type"""
+        pdf_id = re.sub(r'[^a-zA-Z0-9]', '_', filename)
+        logger.info(f"Processing file {filename} (ID: {pdf_id}, Type: {content_type})")
+        
+        # Create PDF object (handles both PDFs and images)
+        pdf = PDF(filename, content_type)
+        self.pdfs[pdf_id] = pdf
+        
+        try:
+            # Save file to disk for persistence
+            extension = ".pdf" if content_type == "application/pdf" else self.supported_image_formats.get(content_type, ".unknown")
+            file_path = f"uploads/{pdf_id}{extension}"
+            with open(file_path, "wb") as f:
+                f.write(file_content)
+            logger.info(f"Saved file to {file_path}")
+            
+            # Process based on file type
+            if content_type == "application/pdf":
+                await self.extract_images_from_pdf(pdf, file_content)
+            elif content_type in self.supported_image_formats:
+                await self.process_image(pdf, file_content)
+            else:
+                raise ValueError(f"Unsupported content type: {content_type}")
+            
+            pdf.processed = True
+            logger.info(f"File {filename} (ID: {pdf_id}) processing completed successfully")
+            return pdf_id
+            
+        except Exception as e:
+            logger.error(f"Error processing file {filename}: {str(e)}", exc_info=True)
+            pdf.error = str(e)
+            return pdf_id
+    
+    async def process_image(self, pdf, file_content):
+        """Process an image file for floor plan analysis"""
+        try:
+            # Open image using PIL
+            img = Image.open(BytesIO(file_content))
+            logger.info(f"Processed image: {pdf.filename}, size: {img.width}x{img.height}")
+            
+            # Add to images list
+            pdf.images.append(img)
+            
+            # Extract measurement information (for now, use defaults)
+            # In a real implementation, you might want to try to extract this from image metadata
+            # or use AI to detect scale information from the image
+            pdf.measurement_info = {
+                "scale": 100,  # Default scale 1:100
+                "ceiling_height": 2.4,  # Default ceiling height in meters
+                "room_dimensions": {}
+            }
+            
+            logger.info(f"Image {pdf.filename} processing completed")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error processing image {pdf.filename}: {str(e)}", exc_info=True)
+            pdf.error = str(e)
+            return False
+    
+    async def extract_images_from_pdf(self, pdf, file_content):
+        """Extract images from PDF for floor plan analysis"""
+        try:
+            pdf_document = fitz.open(stream=file_content, filetype="pdf")
+            pdf.page_count = len(pdf_document)
+            logger.info(f"PDF has {pdf.page_count} pages")
+            
+            images = []
+            embedded_image_count = 0
+            rendered_page_count = 0
+            
+            for page_num in range(len(pdf_document)):
+                page = pdf_document[page_num]
+                logger.debug(f"Processing page {page_num+1}")
+                
+                # First try to get embedded images
+                image_list = page.get_images(full=True)
+                logger.debug(f"Found {len(image_list)} embedded images on page {page_num+1}")
+                
+                # If no embedded images, render the page as an image
+                if not image_list:
+                    logger.debug(f"No embedded images on page {page_num+1}, rendering as image")
+                    pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))
+                    img_bytes = pix.tobytes("png")
+                    img = Image.open(BytesIO(img_bytes))
+                    images.append(img)
+                    rendered_page_count += 1
+                else:
+                    # Extract embedded images
+                    for img_index, img_info in enumerate(image_list):
+                        xref = img_info[0]
+                        base_image = pdf_document.extract_image(xref)
+                        image_bytes = base_image["image"]
+                        img = Image.open(BytesIO(image_bytes))
+                        
+                        # Filter out very small images (likely icons or decorations)
+                        if img.width > 100 and img.height > 100:
+                            logger.debug(f"Extracted image from page {page_num+1}, size: {img.width}x{img.height}")
+                            images.append(img)
+                            embedded_image_count += 1
+                        else:
+                            logger.debug(f"Skipping small image ({img.width}x{img.height}) on page {page_num+1}")
+            
+            # If no images were found, render all pages as images
+            if not images:
+                logger.info(f"No usable images found in PDF, rendering all pages as images")
+                for page_num in range(len(pdf_document)):
+                    page = pdf_document[page_num]
+                    pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))
+                    img_bytes = pix.tobytes("png")
+                    img = Image.open(BytesIO(img_bytes))
+                    images.append(img)
+                    rendered_page_count += 1
+            
+            pdf.images = images
+            logger.info(f"Extracted {len(images)} images from PDF (embedded: {embedded_image_count}, rendered: {rendered_page_count})")
+            
+            # Extract measurement information
+            logger.info(f"Extracting measurement information from PDF")
+            pdf.measurement_info = await self.extract_measurement_info(pdf_document)
+            logger.info(f"Extracted measurement info: scale 1:{pdf.measurement_info['scale']}, ceiling height: {pdf.measurement_info['ceiling_height']}m")
+            if pdf.measurement_info["room_dimensions"]:
+                logger.info(f"Found dimensions for {len(pdf.measurement_info['room_dimensions'])} rooms")
+                for room, dims in pdf.measurement_info["room_dimensions"].items():
+                    logger.debug(f"Room '{room}': {dims['width']}m × {dims['length']}m")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error processing PDF {pdf.filename}: {str(e)}", exc_info=True)
+            pdf.error = str(e)
+            return False
+    
+    async def extract_measurement_info(self, pdf_document):
+        """Extract measurement information like scale and dimensions from PDF"""
+        try:
+            measurement_info = {
+                "scale": None,
+                "ceiling_height": None,
+                "room_dimensions": {}
+            }
+            
+            scale_patterns = [
+                r'(?i)scale\s*1\s*:\s*(\d+)',
+                r'(?i)målestokk\s*1\s*:\s*(\d+)',
+                r'(?i)skala\s*1\s*:\s*(\d+)',
+                r'1\s*:\s*(\d+)'
+            ]
+            
+            height_patterns = [
+                r'(?i)ceiling\s*height\s*[=:]?\s*(\d+[\.,]?\d*)\s*m',
+                r'(?i)takhøyde\s*[=:]?\s*(\d+[\.,]?\d*)\s*m',
+                r'(?i)høyde\s*[=:]?\s*(\d+[\.,]?\d*)\s*m',
+                r'(?i)romhøyde\s*[=:]?\s*(\d+[\.,]?\d*)\s*m',
+                r'(?i)h\s*[=:]?\s*(\d+[\.,]?\d*)\s*m'
+            ]
+            
+            room_dim_patterns = [
+                r'(?i)(stue|kjøkken|soverom|bad|gang|entré|kontor|bod).*?(\d+[\.,]?\d*)\s*[xX×]\s*(\d+[\.,]?\d*)',
+                r'(?i)(living|kitchen|bedroom|bathroom|hallway|entrance|office|storage).*?(\d+[\.,]?\d*)\s*[xX×]\s*(\d+[\.,]?\d*)'
+            ]
+            
+            for page_num in range(len(pdf_document)):
+                page = pdf_document[page_num]
+                text = page.get_text()
+                
+                # Look for scale information
+                if not measurement_info["scale"]:
+                    for pattern in scale_patterns:
+                        matches = re.findall(pattern, text)
+                        if matches:
+                            measurement_info["scale"] = int(matches[0])
+                            break
+                
+                # Look for ceiling height
+                if not measurement_info["ceiling_height"]:
+                    for pattern in height_patterns:
+                        matches = re.findall(pattern, text)
+                        if matches:
+                            height = matches[0].replace(',', '.')
+                            measurement_info["ceiling_height"] = float(height)
+                            break
+                
+                # Look for room dimensions
+                for pattern in room_dim_patterns:
+                    matches = re.findall(pattern, text)
+                    for match in matches:
+                        room_name = match[0].lower().strip()
+                        width = float(match[1].replace(',', '.'))
+                        length = float(match[2].replace(',', '.'))
+                        measurement_info["room_dimensions"][room_name] = {
+                            "width": width,
+                            "length": length
+                        }
+            
+            # Default values if not found
+            if not measurement_info["scale"]:
+                measurement_info["scale"] = 100  # Common scale for residential floor plans
+                
+            if not measurement_info["ceiling_height"]:
+                measurement_info["ceiling_height"] = 2.4  # Standard ceiling height in Norway
+                
+            return measurement_info
+        
+        except Exception as e:
+            logger.error(f"Error extracting measurement info: {e}")
+            return {
+                "scale": 100,
+                "ceiling_height": 2.4,
+                "room_dimensions": {}
+            }
+    
+    async def analyze_floor_plan(self, pdf_id, description=None):
+        """Analyze floor plan PDF and generate structured room data"""
+        pdf = self.pdfs.get(pdf_id)
+        if not pdf:
+            raise ValueError(f"PDF with ID {pdf_id} not found")
+        
+        if not pdf.images:
+            raise ValueError(f"No images found in PDF {pdf_id}")
+        
+        try:
+            # Create prompt for floor plan analysis with measurement info
+            prompt = self.create_prompt(description, pdf.measurement_info, pdf.file_type)
+            
+            # Call Gemini with the images and prompt
+            response = self.model.generate_content([prompt, *pdf.images])
+            
+            # Extract JSON from the response
+            response_text = response.text
+            
+            # Enhanced JSON extraction - try multiple approaches
+            parsed_json = None
+            
+            # Attempt 1: Try to parse the entire response
+            try:
+                parsed_json = json.loads(response_text.strip())
+                return self.validate_and_fix_measurements(parsed_json, pdf.measurement_info)
+            except json.JSONDecodeError:
+                pass  # Continue to next attempt
+            
+            # Attempt 2: Look for JSON between triple backticks
+            if "```" in response_text:
+                parts = response_text.split("```")
+                for i, part in enumerate(parts):
+                    part = part.strip()
+                    # Skip empty parts and parts that are just language identifiers
+                    if not part or part.lower() in ["json", "javascript"]:
+                        continue
+                    
+                    try:
+                        parsed_json = json.loads(part)
+                        return self.validate_and_fix_measurements(parsed_json, pdf.measurement_info)
+                    except json.JSONDecodeError:
+                        continue
+            
+            # Attempt 3: Try to repair common JSON issues
+            try:
+                # Replace single quotes with double quotes
+                fixed_text = response_text.replace("'", '"')
+                # Fix missing quotes around property names
+                fixed_text = re.sub(r'(\s*)(\w+)(\s*):', r'\1"\2"\3:', fixed_text)
+                # Try to extract JSON again
+                match = re.search(r'\[.*\]', fixed_text, re.DOTALL)
+                if match:
+                    json_str = match.group(0)
+                    parsed_json = json.loads(json_str)
+                    return self.validate_and_fix_measurements(parsed_json, pdf.measurement_info)
+            except (json.JSONDecodeError, AttributeError):
+                pass
+            
+            # If we've reached here, no valid JSON was found
+            # As a last resort, try to generate a basic room structure
+            logger.warning(f"Could not extract valid JSON from model response for PDF {pdf_id}. Attempting to generate fallback data.")
+            
+            # Create a default room structure if we have measurement info
+            if pdf.measurement_info:
+                fallback_room = {
+                    "name": "Main Room",
+                    "name_no": "Hovedrom",
+                    "area_m2": 25.0,
+                    "position": "center",
+                    "dimensions_m": {
+                        "width": 5.0,
+                        "length": 5.0
+                    },
+                    "windows": 2,
+                    "window_positions": ["south wall", "east wall"],
+                    "doors": 1,
+                    "door_positions": ["north wall"],
+                    "connected_rooms": [],
+                    "has_external_access": True,
+                    "ceiling_height_m": pdf.measurement_info.get("ceiling_height", 2.4),
+                    "furniture": [],
+                    "estimated": True
+                }
+                
+                # Add a fallback explanation in the logs
+                logger.error(f"Generated fallback room data for PDF {pdf_id} due to JSON parsing issues.")
+                logger.error(f"Original model response: {response_text[:500]}...")
+                
+                # Return the fallback data
+                return [fallback_room]
+            
+            # If all else fails, raise an error
+            logger.error(f"Failed to extract room data from model response: {response_text[:500]}...")
+            raise ValueError("Could not extract valid JSON from model response")
+                
+        except Exception as e:
+            logger.error(f"Error analyzing floor plan {pdf_id}: {str(e)}")
+            raise e
+    
+    def create_prompt(self, floor_plan_description=None, measurement_info=None, file_type="pdf"):
+        """Create the prompt for Gemini - with Norwegian context and measurement instructions"""
+        # Add measurement information to the prompt if available
+        measurement_context = ""
+        if measurement_info:
+            measurement_context = f"""
+**Important Measurement Information:**
+* The floor plan uses a scale of 1:{measurement_info['scale']}
+* The standard ceiling height is {measurement_info['ceiling_height']} meters
+"""
+            if measurement_info["room_dimensions"]:
+                measurement_context += "* Known room dimensions (width × length in meters):\n"
+                for room, dims in measurement_info["room_dimensions"].items():
+                    measurement_context += f"  - {room}: {dims['width']} × {dims['length']} meters\n"
+        
+        # Add file type specific context
+        file_type_context = ""
+        if file_type == "image":
+            file_type_context = """
+**Note:** This floor plan was provided as an image file, not a PDF. The system may not have been able to extract text-based measurement information. Please pay extra attention to visual cues like scale bars, dimensions, and room labels that might be present in the image.
+"""
+        
+        prompt = f"""You are an expert architectural assistant. I am providing a {file_type} floor plan of a house from Norway. The floor plan is likely to contain Norwegian text and terminology. Your job is to analyze the layout and extract **complete room-level information** in **structured JSON format** that I can directly use to build a 3D model.
+{measurement_context}
+{file_type_context}
+        
+Please return the following **JSON structure**, including estimates and spatial relationships:
+[
+  {{
+    "name": "Room name", 
+    "name_no": "Norwegian room name (if present)",
+    "area_m2": 0.0, 
+    "position": "approximate location (e.g., north, south-east corner)", 
+    "dimensions_m": {{ 
+      "width": 0.0, 
+      "length": 0.0 
+    }}, 
+    "windows": 0, 
+    "window_positions": ["north wall", "east wall"], 
+    "doors": 0, 
+    "door_positions": ["interior", "to terrace"], 
+    "connected_rooms": ["Room A", "Room B"], 
+    "has_external_access": true, 
+    "ceiling_height_m": 2.4, 
+    "furniture": ["sofa", "kitchen island"], 
+    "estimated": false 
+  }}
+]
+
+**Instructions:**
+* Include **all rooms**, including utility spaces (garage, hallway, terrace, storage, laundry, etc.).
+* Recognize Norwegian room names and provide both Norwegian (name_no) and English (name) versions.
+* Calculate area_m2 accurately as width × length. Double-check this calculation for all rooms.
+* If any values are not labeled, **estimate them** based on layout scale and set `"estimated": true`.
+* Try to determine the **direction/position** of each room (e.g., "northwest corner", "center").
+* Count and identify **doors and windows**, and specify on which **wall** they are located.
+* Include `"has_external_access": true` if a room connects directly outside (e.g., terrace, garage, entrance).
+* Optionally include `"furniture"` if visible or labeled in the plan.
+* Use the ceiling height of {measurement_info["ceiling_height"] if measurement_info else 2.4}m if not otherwise specified.
+* **VERY IMPORTANT: Only return the JSON array. Do not add explanations, preambles, or any text before or after the JSON array. Do not include markdown code blocks.**
+
+**Common Norwegian architectural terms:**
+* Stue = Living room
+* Kjøkken = Kitchen
+* Soverom = Bedroom
+* Bad = Bathroom
+* Toalett = Toilet
+* Gang = Hallway
+* Entré = Entrance
+* Garderobe = Wardrobe
+* Balkong = Balcony
+* Terrasse = Terrace
+* Kontor = Office
+* Vaskerom = Laundry room
+* Bod = Storage room
+* Garasje = Garage
+* Trapp = Stairs
+* Spisestue = Dining room
+        """
+        
+        if floor_plan_description:
+            prompt += f"\n\nAdditional information about the floor plan: {floor_plan_description}"
+        
+        return prompt
+    
+    def validate_and_fix_measurements(self, json_data, measurement_info=None):
+        """Validate and fix measurement values in the JSON results"""
+        try:
+            if isinstance(json_data, str):
+                data = json.loads(json_data)
+            else:
+                data = json_data
+                
+            if not isinstance(data, list):
+                return json_data
+            
+            default_ceiling_height = measurement_info.get("ceiling_height", 2.4) if measurement_info else 2.4
+            
+            for room in data:
+                # Fix ceiling height
+                if room.get("ceiling_height_m") is None or room.get("ceiling_height_m") <= 0:
+                    room["ceiling_height_m"] = default_ceiling_height
+                    room["estimated"] = True
+                    
+                # Check dimensions and area
+                if "dimensions_m" in room:
+                    width = room["dimensions_m"].get("width", 0)
+                    length = room["dimensions_m"].get("length", 0)
+                    
+                    # If we have dimensions but they're invalid, try to fix them
+                    if width <= 0 or length <= 0:
+                        # Check if we have area to calculate dimensions
+                        if room.get("area_m2", 0) > 0:
+                            # Approximate dimensions using a square root (assuming square-ish room)
+                            side = math.sqrt(room["area_m2"])
+                            room["dimensions_m"]["width"] = round(side, 1)
+                            room["dimensions_m"]["length"] = round(side, 1)
+                            room["estimated"] = True
+                        else:
+                            # Set reasonable defaults
+                            room["dimensions_m"]["width"] = 3.0
+                            room["dimensions_m"]["length"] = 3.0
+                            room["area_m2"] = 9.0
+                            room["estimated"] = True
+                    else:
+                        # Recalculate area based on dimensions
+                        calculated_area = width * length
+                        current_area = room.get("area_m2", 0)
+                        
+                        # If area is missing or significantly different, update it
+                        if current_area <= 0 or abs(current_area - calculated_area) > 0.5:
+                            room["area_m2"] = round(calculated_area, 1)
+                            
+                # If we have area but no dimensions, calculate them
+                elif "area_m2" in room and room["area_m2"] > 0:
+                    # Approximate dimensions using a square root (assuming square-ish room)
+                    side = math.sqrt(room["area_m2"])
+                    room["dimensions_m"] = {
+                        "width": round(side, 1),
+                        "length": round(side, 1)
+                    }
+                    room["estimated"] = True
+                    
+                # Check if we have room dimensions in our measurement info
+                if measurement_info and "room_dimensions" in measurement_info:
+                    room_name_lower = room.get("name", "").lower()
+                    room_name_no_lower = room.get("name_no", "").lower()
+                    
+                    # Check both English and Norwegian names
+                    for name in [room_name_lower, room_name_no_lower]:
+                        if name in measurement_info["room_dimensions"]:
+                            known_dims = measurement_info["room_dimensions"][name]
+                            room["dimensions_m"] = {
+                                "width": known_dims["width"],
+                                "length": known_dims["length"]
+                            }
+                            room["area_m2"] = round(known_dims["width"] * known_dims["length"], 1)
+                            room["estimated"] = False
+                            break
+            
+            return data
+            
+        except Exception as e:
+            logger.error(f"Error validating measurements: {e}")
+            return json_data
+
+# Initialize FastAPI
+# Initialize FastAPI with Swagger UI configuration
+app = FastAPI(
+    title="Floor Plan Analysis API",
+    description="API for analyzing floor plans in PDF or image format and extracting structured room data",
+    version="1.0.0",
+    docs_url="/",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json",
+    openapi_tags=[
+        {"name": "status", "description": "API status endpoints"},
+        {"name": "pdfs", "description": "PDF management endpoints"},  # Keep original tags
+        {"name": "analysis", "description": "Floor plan analysis endpoints"},
+    ]
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"]
+)
+
+# Initialize processor
+processor = FloorPlanProcessor()
+
+# API endpoints
+@app.get("/status", tags=["status"])
+async def get_status():
+    """
+    Get the current status of the API and count of processed PDFs
+    
+    Returns:
+        dict: Status information including running state and PDF count
+    """
+    return {
+        "status": "running",
+        "pdfs_count": len(processor.pdfs)
+    }
+
+@app.get("/pdfs", tags=["pdfs"])
+async def get_pdfs():
+    """
+    List all uploaded PDFs and their metadata
+    
+    Returns:
+        dict: List of all PDFs with their metadata
+    """
+    return {
+        "pdfs": [pdf.to_dict() for pdf in processor.pdfs.values()]
+    }
+
+@app.get("/pdf/{pdf_id}", tags=["pdfs"])
+async def get_pdf(pdf_id: str):
+    """
+    Get information about a specific PDF by ID
+    
+    Args:
+        pdf_id (str): The ID of the PDF to retrieve
+        
+    Returns:
+        dict: PDF metadata including processing status and measurement information
+        
+    Raises:
+        HTTPException: 404 if PDF not found
+    """
+    if pdf_id not in processor.pdfs:
+        raise HTTPException(status_code=404, detail="PDF not found")
+    
+    return processor.pdfs[pdf_id].to_dict()
+
+@app.post("/upload", tags=["pdfs"])
+async def upload_pdf(file: UploadFile = File(...)):
+    """
+    Upload a floor plan (PDF or image) for processing
+    
+    The file will be processed to extract images and measurement information.
+    The system will detect scales, dimensions, and prepare the floor plan for analysis.
+    Supports PDF files and common image formats (JPG, PNG, GIF, BMP, TIFF, WebP).
+    
+    Args:
+        file (UploadFile): The file to upload (PDF, JPG, PNG, etc.)
+        
+    Returns:
+        dict: Upload confirmation with PDF ID and basic information
+        
+    Raises:
+        HTTPException: 400 if file type is not supported
+    """
+    # Validate file content type
+    content_type = file.content_type.lower()
+    supported_types = ["application/pdf"] + list(processor.supported_image_formats.keys())
+    
+    if content_type not in supported_types:
+        logger.warning(f"Rejected unsupported file type: {content_type} for file {file.filename}")
+        return JSONResponse(
+            status_code=400, 
+            content={
+                "error": "Unsupported file type", 
+                "supported_types": ", ".join(supported_types)
+            }
+        )
+    
+    logger.info(f"Received upload request for file: {file.filename} ({content_type})")
+    
+    try:
+        # Read file content
+        file_content = await file.read()
+        file_size = len(file_content)
+        logger.info(f"Read file content, size: {file_size} bytes")
+        
+        # Process file
+        pdf_id = await processor.process_upload(file_content, file.filename, content_type)
+        pdf_info = processor.pdfs[pdf_id].to_dict()
+        
+        logger.info(f"File processed successfully, assigned ID: {pdf_id}")
+        logger.info(f"PDF info: {json.dumps(pdf_info)}")
+        
+        return {
+            "message": "PDF uploaded successfully",
+            "pdf_id": pdf_id,
+            "pdf_info": pdf_info
+        }
+    except Exception as e:
+        logger.error(f"Error processing upload for {file.filename}: {str(e)}", exc_info=True)
+        return JSONResponse(
+            status_code=500,
+            content={"error": f"Error processing upload: {str(e)}"}
+        )
+
+@app.post("/analyze/{pdf_id}", tags=["analysis"])
+async def analyze_pdf(pdf_id: str, query: FloorPlanQuery = None):
+    """
+    Analyze a floor plan PDF and extract room information
+    
+    This endpoint analyzes a previously uploaded floor plan PDF and extracts 
+    detailed room-level information using AI. The analysis includes room dimensions,
+    positions, doors, windows, and connections between rooms.
+    
+    Args:
+        pdf_id (str): The ID of the PDF to analyze
+        query (FloorPlanQuery, optional): Additional information about the floor plan
+            
+    Returns:
+        dict: Analysis results including measurement information and room data
+        
+    Raises:
+        HTTPException: 404 if PDF not found
+        HTTPException: 400 if PDF is still processing or doesn't contain images
+        HTTPException: 500 if analysis fails
+    """
+    if pdf_id not in processor.pdfs:
+        raise HTTPException(status_code=404, detail="PDF not found")
+    
+    pdf = processor.pdfs[pdf_id]
+    
+    # Check if PDF is processed
+    if not pdf.processed:
+        return JSONResponse(
+            status_code=400, 
+            content={"error": "PDF is still being processed"}
+        )
+    
+    # Check if PDF has images for floor plan analysis
+    if not pdf.images:
+        return JSONResponse(
+            status_code=400, 
+            content={"error": "This PDF doesn't contain images suitable for floor plan analysis"}
+        )
+    
+    try:
+        description = query.description if query else None
+        logger.info(f"Analyzing floor plan {pdf_id} with description: {description}")
+        
+        # If the API call takes too long, it might time out for the client
+        # Use a shorter timeout for model response
+        result = await asyncio.wait_for(
+            processor.analyze_floor_plan(pdf_id, description),
+            timeout=120  # 2 minute timeout
+        )
+        
+        # Store the analysis result in the PDF object for later retrieval
+        pdf.analysis_result = result
+        
+        logger.info(f"Successfully analyzed floor plan {pdf_id}, found {len(result)} rooms")
+        
+        return {
+            "message": "Floor plan analyzed successfully",
+            "pdf_id": pdf_id,
+            "measurement_info": pdf.measurement_info,
+            "rooms": result
+        }
+    except asyncio.TimeoutError:
+        logger.error(f"Timeout while analyzing floor plan {pdf_id}")
+        return JSONResponse(
+            status_code=504,  # Gateway Timeout
+            content={"error": "Analysis timed out. The process took too long to complete."}
+        )
+    except Exception as e:
+        logger.error(f"Error analyzing floor plan {pdf_id}: {str(e)}")
+        
+        # Return more detailed error information
+        error_details = {
+            "error": f"Error analyzing floor plan: {str(e)}",
+            "error_type": type(e).__name__,
+            "pdf_id": pdf_id
+        }
+        
+        if hasattr(e, '__dict__'):
+            # Include additional error attributes if available
+            for key, value in e.__dict__.items():
+                if isinstance(value, (str, int, float, bool, type(None))):
+                    error_details[f"error_{key}"] = value
+        
+        return JSONResponse(
+            status_code=500,
+            content=error_details
+        )
+
+@app.post("/room/{pdf_id}", tags=["analysis"])
+async def find_room(pdf_id: str, query: RoomQuery):
+    """
+    Find a specific room in a floor plan by name
+    
+    This endpoint searches for a room by name in a previously analyzed floor plan.
+    It can perform exact matching or partial matching based on the query parameters.
+    
+    Args:
+        pdf_id (str): The ID of the analyzed PDF to search
+        query (RoomQuery): Room search parameters
+            room_name (str): Name or partial name of the room to find
+            exact_match (bool): Whether to match the name exactly or do partial matching
+            
+    Returns:
+        dict: Room information if found, or error message
+        
+    Raises:
+        HTTPException: 404 if PDF not found or room not found
+    """
+    if pdf_id not in processor.pdfs:
+        logger.error(f"PDF not found: {pdf_id}")
+        raise HTTPException(status_code=404, detail="PDF not found")
+    
+    pdf = processor.pdfs[pdf_id]
+    
+    # Check if the PDF has been analyzed
+    if not hasattr(pdf, "analysis_result") or not pdf.analysis_result:
+        logger.error(f"PDF {pdf_id} has not been analyzed yet")
+        raise HTTPException(
+            status_code=400, 
+            content={"error": "PDF has not been analyzed yet. Please call /analyze/{pdf_id} first."}
+        )
+    
+    logger.info(f"Searching for room '{query.room_name}' in PDF {pdf_id} (exact_match={query.exact_match})")
+    
+    # Search for room by name (case insensitive)
+    found_rooms = []
+    room_name_lower = query.room_name.lower()
+    
+    for room in pdf.analysis_result:
+        english_name = room.get("name", "").lower()
+        norwegian_name = room.get("name_no", "").lower()
+        
+        if query.exact_match:
+            # Exact match (case insensitive)
+            if english_name == room_name_lower or norwegian_name == room_name_lower:
+                found_rooms.append(room)
+        else:
+            # Partial match (case insensitive)
+            if room_name_lower in english_name or room_name_lower in norwegian_name:
+                found_rooms.append(room)
+    
+    if not found_rooms:
+        logger.warning(f"No rooms found matching '{query.room_name}' in PDF {pdf_id}")
+        raise HTTPException(
+            status_code=404, 
+            content={"error": f"No rooms found matching '{query.room_name}'"}
+        )
+    
+    # If only one room found, return it directly
+    if len(found_rooms) == 1:
+        logger.info(f"Found exactly one room matching '{query.room_name}': {found_rooms[0].get('name')}")
+        return {
+            "message": f"Room found: {found_rooms[0].get('name')}",
+            "pdf_id": pdf_id,
+            "room": found_rooms[0]
+        }
+    
+    # Multiple rooms found
+    logger.info(f"Found {len(found_rooms)} rooms matching '{query.room_name}'")
+    room_names = [f"{room.get('name')} ({room.get('name_no', '')})" for room in found_rooms]
+    
+    return {
+        "message": f"Found {len(found_rooms)} rooms matching '{query.room_name}'",
+        "pdf_id": pdf_id,
+        "rooms": found_rooms,
+        "room_names": room_names
+    }
+
+# Create necessary directories and startup logic
+@app.on_event("startup")
+async def startup_event():
+    """Initialize necessary directories and settings on startup"""
+    # Create necessary directories
+    for directory in ["uploads", "logs"]:
+        try:
+            os.makedirs(directory, exist_ok=True)
+            logger.info(f"Created directory: {directory}")
+        except Exception as e:
+            logger.error(f"Failed to create directory {directory}: {str(e)}")
+    
+    # Check API key configuration
+    if GOOGLE_API_KEY:
+        logger.info("GOOGLE_API_KEY environment variable is set")
+    else:
+        logger.warning("GOOGLE_API_KEY environment variable is not set! The API will not function correctly.")
+    
+    # Print API information
+    logger.info("\n===== Floor Plan Analysis API =====")
+    logger.info(f"Starting server with Gemini API: {'CONFIGURED' if GOOGLE_API_KEY else 'NOT CONFIGURED'}")
+    logger.info(f"Documentation: http://localhost:7860/")
+    logger.info(f"Status: http://localhost:7860/status")
+    logger.info(f"Upload: http://localhost:7860/upload")
+    logger.info("==============================\n")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Log when the application is shutting down"""
+    logger.info("Application shutting down")
+
+# Start the application if this file is run directly
+if __name__ == "__main__":
+    logger.info("Starting Floor Plan Analysis API server")
+    uvicorn.run(app, host="0.0.0.0", port=7860)