Update app.py

app.py

@@ -11,49 +11,34 @@ import json
 import re
 from io import BytesIO
 import math
+import time
 import fitz  # PyMuPDF
 from PIL import Image
 import google.generativeai as genai
-# version = 0.0.3
-# Configure logging 
+
+# version = 0.0.5 - High Accuracy Mode for Paid Plans
 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
+        logging.StreamHandler(),
+        logging.FileHandler("floor_plan_api.log")
     ]
 )
 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
 
@@ -66,20 +51,20 @@ class PDF:
         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.file_type = "pdf" if content_type == "application/pdf" else "image"
         self.measurement_info = {
-            "scale": 100,  # Default scale 1:100
-            "ceiling_height": 2.4,  # Default ceiling height in meters
+            "scale": 100,
+            "ceiling_height": 2.4,
             "room_dimensions": {}
         }
-        self.analysis_result = None  # Will store the room analysis result
+        self.analysis_result = None
         
     def to_dict(self):
         return {
             "id": self.id,
             "filename": self.filename,
             "content_type": self.content_type,
-            "file_type": self.file_type,  # Added to response
+            "file_type": self.file_type,
             "processed": self.processed,
             "error": self.error,
             "page_count": self.page_count if self.file_type == "pdf" else None,
@@ -89,12 +74,10 @@ class PDF:
             "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-2.5-pro')
-        self.pdfs = {}  # Keep the original name for backward compatibility
-        # Define supported image formats
+        self.pdfs = {}
         self.supported_image_formats = {
             "image/jpeg": ".jpg", 
             "image/png": ".png", 
@@ -105,23 +88,19 @@ class FloorPlanProcessor:
         }
     
     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:
@@ -139,34 +118,23 @@ class FloorPlanProcessor:
             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
+                "scale": 100,
+                "ceiling_height": 2.4,
                 "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)
@@ -178,39 +146,26 @@ class FloorPlanProcessor:
             
             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))
@@ -222,15 +177,7 @@ class FloorPlanProcessor:
             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:
@@ -239,7 +186,6 @@ class FloorPlanProcessor:
             return False
     
     async def extract_measurement_info(self, pdf_document):
-        """Extract measurement information like scale and dimensions from PDF"""
         try:
             measurement_info = {
                 "scale": None,
@@ -258,8 +204,6 @@ class FloorPlanProcessor:
                 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 = [
@@ -271,7 +215,6 @@ class FloorPlanProcessor:
                 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)
@@ -279,7 +222,6 @@ class FloorPlanProcessor:
                             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)
@@ -288,7 +230,6 @@ class FloorPlanProcessor:
                             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:
@@ -300,25 +241,17 @@ class FloorPlanProcessor:
                             "length": length
                         }
             
-            # Default values if not found
             if not measurement_info["scale"]:
-                measurement_info["scale"] = 100  # Common scale for residential floor plans
-                
+                measurement_info["scale"] = 100
             if not measurement_info["ceiling_height"]:
-                measurement_info["ceiling_height"] = 2.4  # Standard ceiling height in Norway
+                measurement_info["ceiling_height"] = 2.4
                 
             return measurement_info
-        
         except Exception as e:
             logger.error(f"Error extracting measurement info: {e}")
-            return {
-                "scale": 100,
-                "ceiling_height": 2.4,
-                "room_dimensions": {}
-            }
+            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")
@@ -326,184 +259,291 @@ class FloorPlanProcessor:
         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
+        logger.info(f"\n{'='*70}")
+        logger.info(f"HIGH ACCURACY Analysis: {pdf_id}")
+        logger.info(f"Total images: {len(pdf.images)}")
+        logger.info(f"Using: gemini-2.5-pro (Maximum Quality)")
+        logger.info(f"{'='*70}\n")
+        
+        best_images = self._select_best_images(pdf.images, max_images=3)
+        high_quality_images = [self._prepare_high_quality_image(img) for img in best_images]
+        
+        logger.info(f"Using {len(high_quality_images)} high-quality images")
+        for idx, img in enumerate(high_quality_images):
+            logger.info(f"  Image {idx+1}: {img.size[0]}x{img.size[1]} pixels")
+        
+        max_retries = 3
+        for attempt in range(max_retries):
             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
+                logger.info(f"\nAttempt {attempt + 1}/{max_retries}")
+                
+                result = await self._analyze_with_max_quality(
+                    high_quality_images,
+                    pdf.measurement_info,
+                    description,
+                    pdf.file_type,
+                    timeout=600,
+                    attempt=attempt
+                )
+                
+                if result and len(result) > 0:
+                    logger.info(f"✓ SUCCESS: Found {len(result)} rooms")
+                    return result
                     
-                    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
-                }
+            except asyncio.TimeoutError:
+                logger.warning(f"Attempt {attempt + 1} timed out")
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(5)
+                    continue
+                    
+            except Exception as e:
+                error_str = str(e)
+                logger.warning(f"Attempt {attempt + 1} failed: {error_str[:200]}")
                 
-                # 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]}...")
+                retryable = ['504', '503', '429', 'timeout', 'deadline', 'overloaded']
+                if any(k in error_str.lower() for k in retryable):
+                    if attempt < max_retries - 1:
+                        wait_time = 10 * (attempt + 1)
+                        logger.info(f"Waiting {wait_time}s before retry...")
+                        await asyncio.sleep(wait_time)
+                        continue
                 
-                # Return the fallback data
-                return [fallback_room]
+                raise
+        
+        logger.warning("All attempts exhausted, generating fallback")
+        return self._generate_fallback(pdf.measurement_info)
+    
+    def _select_best_images(self, images, max_images=3):
+        if len(images) <= max_images:
+            return images
+        
+        scored = []
+        for img in images:
+            width, height = img.size
+            area = width * height
+            aspect_ratio = max(width, height) / min(width, height)
             
-            # 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
+            score = area
+            if 0.5 <= aspect_ratio <= 2.5:
+                score *= 1.5
+            
+            scored.append((score, img))
+        
+        scored.sort(reverse=True, key=lambda x: x[0])
+        return [img for _, img in scored[:max_images]]
+    
+    def _prepare_high_quality_image(self, image, max_size=2048):
+        if image.mode not in ('RGB', 'L'):
+            image = image.convert('RGB')
+        
+        width, height = image.size
+        
+        if width > max_size or height > max_size:
+            ratio = max_size / max(width, height)
+            new_width = int(width * ratio)
+            new_height = int(height * ratio)
+            image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+            logger.info(f"Resized: {width}x{height} → {new_width}x{new_height}")
+        
+        return image
+    
+    async def _analyze_with_max_quality(self, images, measurement_info, description, 
+                                       file_type, timeout, attempt=0):
+        prompt = self.create_prompt(description, measurement_info, file_type)
+        
+        temperature = 0.2 if attempt == 0 else 0.3
+        max_tokens = 16384 if attempt == 0 else 12288
+        
+        start_time = time.time()
+        loop = asyncio.get_event_loop()
+        
+        def make_request():
+            return self.model.generate_content(
+                [prompt] + images,
+                generation_config={
+                    "temperature": temperature,
+                    "max_output_tokens": max_tokens,
+                    "top_p": 0.95,
+                    "top_k": 40,
+                },
+                safety_settings={
+                    'HARASSMENT': 'BLOCK_NONE',
+                    'HATE_SPEECH': 'BLOCK_NONE',
+                    'SEXUALLY_EXPLICIT': 'BLOCK_NONE',
+                    'DANGEROUS_CONTENT': 'BLOCK_NONE'
+                },
+                request_options={'timeout': timeout}
+            )
+        
+        response = await asyncio.wait_for(
+            loop.run_in_executor(None, make_request),
+            timeout=timeout + 30
+        )
+        
+        elapsed = time.time() - start_time
+        logger.info(f"Response in {elapsed:.1f}s ({len(response.text)} chars)")
+        
+        parsed = self._extract_json_comprehensive(response.text)
+        
+        if parsed and len(parsed) > 0:
+            validated = self.validate_and_fix_measurements(parsed, measurement_info)
+            logger.info(f"Validated {len(validated)} rooms")
+            return validated
+        
+        return None
+    
+    def _extract_json_comprehensive(self, text):
+        if not text:
+            return None
+        
+        text = text.strip()
+        text = re.sub(r'```(?:json|javascript)?\s*\n?', '', text)
+        text = text.strip('`').strip()
+        
+        try:
+            data = json.loads(text)
+            if isinstance(data, list) and len(data) > 0:
+                return data
+        except json.JSONDecodeError:
+            pass
+        
+        patterns = [
+            r'\[\s*\{[\s\S]*?\}\s*\]',
+            r'\[[\s\S]*?\]',
+        ]
+        
+        for pattern in patterns:
+            matches = list(re.finditer(pattern, text))
+            for match in sorted(matches, key=lambda m: len(m.group(0)), reverse=True):
+                try:
+                    data = json.loads(match.group(0))
+                    if isinstance(data, list) and len(data) > 0:
+                        return data
+                except json.JSONDecodeError:
+                    continue
+        
+        try:
+            fixed = re.sub(r',\s*}', '}', text)
+            fixed = re.sub(r',\s*]', ']', fixed)
+            match = re.search(r'\[[\s\S]*\]', fixed)
+            if match:
+                data = json.loads(match.group(0))
+                if isinstance(data, list):
+                    return data
+        except:
+            pass
+        
+        return None
+    
+    def _generate_fallback(self, measurement_info):
+        ceiling = measurement_info.get('ceiling_height', 2.4)
+        
+        return [
+            {
+                "name": "Living Room", "name_no": "Stue",
+                "area_m2": 28.0, "position": "main",
+                "dimensions_m": {"width": 5.6, "length": 5.0},
+                "windows": 2, "window_positions": ["south", "east"],
+                "doors": 2, "door_positions": ["to kitchen", "to hallway"],
+                "connected_rooms": ["Kitchen", "Hallway"],
+                "has_external_access": False,
+                "ceiling_height_m": ceiling,
+                "furniture": [],
+                "estimated": True,
+                "note": "Fallback data"
+            },
+            {
+                "name": "Kitchen", "name_no": "Kjøkken",
+                "area_m2": 12.0, "position": "adjacent",
+                "dimensions_m": {"width": 3.0, "length": 4.0},
+                "windows": 1, "window_positions": ["north"],
+                "doors": 1, "door_positions": ["to living room"],
+                "connected_rooms": ["Living Room"],
+                "has_external_access": False,
+                "ceiling_height_m": ceiling,
+                "furniture": [],
+                "estimated": True,
+                "note": "Fallback data"
+            },
+            {
+                "name": "Bedroom", "name_no": "Soverom",
+                "area_m2": 15.0, "position": "private",
+                "dimensions_m": {"width": 3.75, "length": 4.0},
+                "windows": 1, "window_positions": ["west"],
+                "doors": 1, "door_positions": ["to hallway"],
+                "connected_rooms": ["Hallway"],
+                "has_external_access": False,
+                "ceiling_height_m": ceiling,
+                "furniture": [],
+                "estimated": True,
+                "note": "Fallback data"
+            },
+            {
+                "name": "Bathroom", "name_no": "Bad",
+                "area_m2": 6.0, "position": "private",
+                "dimensions_m": {"width": 2.0, "length": 3.0},
+                "windows": 0, "window_positions": [],
+                "doors": 1, "door_positions": ["to hallway"],
+                "connected_rooms": ["Hallway"],
+                "has_external_access": False,
+                "ceiling_height_m": ceiling,
+                "furniture": [],
+                "estimated": True,
+                "note": "Fallback data"
+            }
+        ]
     
     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
+**Measurement Information:**
+* Scale: 1:{measurement_info['scale']}
+* Ceiling height: {measurement_info['ceiling_height']}m
 """
             if measurement_info["room_dimensions"]:
-                measurement_context += "* Known room dimensions (width × length in meters):\n"
+                measurement_context += "* Known dimensions:\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.
-"""
+                    measurement_context += f"  - {room}: {dims['width']} × {dims['length']}m\n"
         
-        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.
+        prompt = f"""You are an expert architectural assistant analyzing a Norwegian floor plan. Extract complete room information as JSON.
 {measurement_context}
-{file_type_context}
-        
-Please return the following **JSON structure**, including estimates and spatial relationships:
+
+Return this JSON structure:
 [
   {{
     "name": "Room name", 
-    "name_no": "Norwegian room name (if present)",
+    "name_no": "Norwegian name",
     "area_m2": 0.0, 
-    "position": "approximate location (e.g., north, south-east corner)", 
-    "dimensions_m": {{ 
-      "width": 0.0, 
-      "length": 0.0 
-    }}, 
+    "position": "location", 
+    "dimensions_m": {{"width": 0.0, "length": 0.0}}, 
     "windows": 0, 
-    "window_positions": ["north wall", "east wall"], 
+    "window_positions": ["wall"], 
     "doors": 0, 
-    "door_positions": ["interior", "to terrace"], 
-    "connected_rooms": ["Room A", "Room B"], 
-    "has_external_access": true, 
+    "door_positions": ["location"], 
+    "connected_rooms": ["Room"], 
+    "has_external_access": false, 
     "ceiling_height_m": 2.4, 
-    "furniture": ["sofa", "kitchen island"], 
+    "furniture": [], 
     "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.**
+Instructions:
+* Include ALL rooms (Stue, Kjøkken, Soverom, Bad, Gang, Entré, Terrasse, etc.)
+* Calculate area_m2 = width × length
+* Set estimated=true if values are approximated
+* Return ONLY the JSON array, no other text
 
-**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
-        """
+Norwegian terms: Stue=Living room, Kjøkken=Kitchen, Soverom=Bedroom, Bad=Bathroom, Gang=Hallway
+"""
         
         if floor_plan_description:
-            prompt += f"\n\nAdditional information about the floor plan: {floor_plan_description}"
+            prompt += f"\n\nContext: {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)
@@ -513,46 +553,36 @@ Please return the following **JSON structure**, including estimates and spatial
             if not isinstance(data, list):
                 return json_data
             
-            default_ceiling_height = measurement_info.get("ceiling_height", 2.4) if measurement_info else 2.4
+            default_ceiling = 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["ceiling_height_m"] = default_ceiling
                     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),
@@ -560,12 +590,10 @@ Please return the following **JSON structure**, including estimates and spatial
                     }
                     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]
@@ -580,26 +608,17 @@ Please return the following **JSON structure**, including estimates and spatial
             return data
             
         except Exception as e:
-            logger.error(f"Error validating measurements: {e}")
+            logger.error(f"Error validating: {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",
+    title="Floor Plan API - High Accuracy",
+    description="Maximum accuracy floor plan analysis with gemini-2.5-pro",
+    version="1.0.5",
     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"},
-    ]
+    redoc_url="/redoc"
 )
 
-# Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -608,239 +627,137 @@ app.add_middleware(
     allow_headers=["*"]
 )
 
-# Initialize processor
 processor = FloorPlanProcessor()
 
-# API endpoints
-@app.get("/status", tags=["status"])
+@app.get("/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)
+        "pdfs_count": len(processor.pdfs),
+        "model": "gemini-2.5-pro",
+        "mode": "high_accuracy"
     }
 
-@app.get("/pdfs", tags=["pdfs"])
+@app.get("/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()]
-    }
+    return {"pdfs": [pdf.to_dict() for pdf in processor.pdfs.values()]}
 
-@app.get("/pdf/{pdf_id}", tags=["pdfs"])
+@app.get("/pdf/{pdf_id}")
 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"])
+@app.post("/upload")
 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())
+    supported = ["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}")
+    if content_type not in supported:
         return JSONResponse(
             status_code=400, 
-            content={
-                "error": "Unsupported file type", 
-                "supported_types": ", ".join(supported_types)
-            }
+            content={"error": "Unsupported file type", "supported_types": ", ".join(supported)}
         )
     
-    logger.info(f"Received upload request for file: {file.filename} ({content_type})")
+    logger.info(f"Upload: {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",
+            "message": "File 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)}"}
-        )
+        logger.error(f"Upload error: {str(e)}", exc_info=True)
+        return JSONResponse(status_code=500, content={"error": str(e)})
 
-@app.post("/analyze/{pdf_id}", tags=["analysis"])
+@app.post("/analyze/{pdf_id}")
 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"}
-        )
+        return JSONResponse(status_code=400, content={"error": "PDF still processing"})
     
-    # 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"}
-        )
+        return JSONResponse(status_code=400, content={"error": "No images found"})
     
     try:
         description = query.description if query else None
-        logger.info(f"Analyzing floor plan {pdf_id} with description: {description}")
+        start_time = time.time()
         
-        # 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
+            timeout=1200
         )
         
-        # Store the analysis result in the PDF object for later retrieval
+        elapsed = time.time() - start_time
         pdf.analysis_result = result
         
-        logger.info(f"Successfully analyzed floor plan {pdf_id}, found {len(result)} rooms")
+        is_fallback = any(
+            room.get("estimated") and "fallback" in room.get("note", "").lower()
+            for room in result
+        )
         
         return {
-            "message": "Floor plan analyzed successfully",
+            "message": "Analysis complete" + (" - fallback" if is_fallback else " - high accuracy"),
             "pdf_id": pdf_id,
             "measurement_info": pdf.measurement_info,
-            "rooms": result
+            "rooms": result,
+            "analysis_time_seconds": round(elapsed, 1),
+            "is_estimated": is_fallback,
+            "quality": "fallback" if is_fallback else "high_accuracy"
         }
+        
     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)}")
+        fallback = processor._generate_fallback(pdf.measurement_info)
+        pdf.analysis_result = fallback
         
-        # Return more detailed error information
-        error_details = {
-            "error": f"Error analyzing floor plan: {str(e)}",
-            "error_type": type(e).__name__,
-            "pdf_id": pdf_id
+        return {
+            "message": "Timeout - using fallback",
+            "pdf_id": pdf_id,
+            "rooms": fallback,
+            "is_estimated": True,
+            "quality": "fallback"
         }
         
-        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
+    except Exception as e:
+        logger.error(f"Analysis error: {str(e)}", exc_info=True)
         
-        return JSONResponse(
-            status_code=500,
-            content=error_details
-        )
+        try:
+            fallback = processor._generate_fallback(pdf.measurement_info)
+            return {
+                "message": "Error - using fallback",
+                "pdf_id": pdf_id,
+                "rooms": fallback,
+                "is_estimated": True,
+                "error": str(e)
+            }
+        except:
+            return JSONResponse(
+                status_code=500,
+                content={"error": str(e), "pdf_id": pdf_id}
+            )
 
-@app.post("/room/{pdf_id}", tags=["analysis"])
+@app.post("/room/{pdf_id}")
 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."}
+            content={"error": "PDF not analyzed yet. 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()
     
@@ -849,32 +766,25 @@ async def find_room(pdf_id: str, query: RoomQuery):
         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 {
@@ -884,11 +794,8 @@ async def find_room(pdf_id: str, query: RoomQuery):
         "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)
@@ -896,26 +803,25 @@ async def startup_event():
         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")
+        logger.info("GOOGLE_API_KEY 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.warning("GOOGLE_API_KEY not set!")
+    
+    logger.info("\n" + "="*60)
+    logger.info("Floor Plan Analysis API - HIGH ACCURACY MODE")
+    logger.info("="*60)
+    logger.info(f"Model: gemini-2.5-pro")
+    logger.info(f"Max Analysis Time: 20 minutes")
+    logger.info(f"Image Quality: 2048px")
+    logger.info(f"Retries: 3 per analysis")
     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")
+    logger.info("="*60 + "\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")
+    logger.info("Starting Floor Plan Analysis API (High Accuracy Mode)")
     uvicorn.run(app, host="0.0.0.0", port=7860)