Update src/pages/2_ArealAI

src/pages/2_ArealAI

@@ -0,0 +1,176 @@
+import streamlit as st
+import cv2
+import numpy as np
+import tempfile
+import os
+from PIL import Image
+import matplotlib.pyplot as plt
+from ultralytics import YOLO
+import io
+import pymupdf
+import hashlib
+from utils.object_detection import detect_resize_walls, remove_interior_walls
+from utils.segmentation import predict_segments, fill_segments, segmentation_to_binary
+from utils.plotting import plot_results_streamlit
+
+
+
+MODEL_SEG_PATH = os.path.join(os.path.dirname(__file__), "../models/segment/bra_bta/best.pt")
+MODEL_OBJ_PATH = os.path.join(os.path.dirname(__file__), "../models/detect/walls/best.pt")
+
+model_seg = YOLO(MODEL_SEG_PATH)
+model_obj = YOLO(MODEL_OBJ_PATH)
+
+
+def file_hash(file_obj):
+    file_obj.seek(0)
+    content = file_obj.read()
+    file_obj.seek(0)  
+    return hashlib.md5(content).hexdigest()
+
+def draw_bbox(img, bbox, wall_id, color=(0, 0, 255), thickness=2):
+    x1, y1, x2, y2 = bbox
+    cv2.rectangle(img, (x1, y1), (x2, y2), color, thickness)
+    center_x = int((x1 + x2) / 2)
+    text_y = y1 - 10  
+    text_y = max(text_y, 30)
+
+   
+    cv2.putText(
+        img, str(wall_id), (center_x - 20, text_y),
+        fontFace=cv2.FONT_HERSHEY_SIMPLEX,
+        fontScale=2.5,
+        color=(0, 0, 0),
+        thickness=4,
+        lineType=cv2.LINE_AA
+    )
+
+    return img
+
+
+def calculate_BRA(pixels_per_meter, filled_masks):
+    """Calculate the total area of the building and display the steps"""
+    results = []
+
+    for i, mask in enumerate(filled_masks):
+        pixel_area = np.sum(mask > 0)
+        sqm_area = pixel_area / (pixels_per_meter ** 2)
+
+        results.append({
+            "Plan": f"Plan {i+1}",
+            "Pixel Area": pixel_area,
+            "Pixels per meter": pixels_per_meter,
+            "Area (m²)": sqm_area
+        })
+
+        st.markdown(f"""
+        ### Calculation for Plan {i+1}
+        - **Pixel area**: `{pixel_area}` pixels  
+        - **Pixels per meter**: `{pixels_per_meter:.2f}` px/m  
+        - **BRA** = pixel_area / (pixels_per_meter²)  
+        - **Result**: **{sqm_area:.2f} m²**
+        """)
+
+    return results
+
+
+
+
+st.title("Usable Floorplan (BRA) Area Calculation")
+st.write(
+    """
+    This module analyzes floorplan drawings and calculates the building's usable floor area (BRA) using AI-based segmentation.
+
+    Upload a simple floorplan drawing, then select a **reference wall** for which the **real-world length is known**. This reference is used to scale the drawing and estimate the area in square meters.
+
+    **Note**: This tool is best suited for clean, top-down floorplan images with visible walls. Complex or cluttered drawings may produce inaccurate results.
+    """
+)
+
+st.subheader("Upload a floorplan drawing")
+
+uploaded_files = st.file_uploader(
+    "Upload",
+    type=["jpg", "png", "jpeg", "pdf"],
+    accept_multiple_files=True
+)
+
+if uploaded_files:
+
+    for idx, uploaded_file in enumerate(uploaded_files):
+        
+        file_type = uploaded_file.type
+
+        if file_type == "application/pdf":
+            pdf_bytes = uploaded_file.read()
+            doc = pymupdf.open(stream=pdf_bytes, filetype="pdf")
+        
+            page = doc.load_page(0)
+            pix = page.get_pixmap(dpi=300)
+            image = Image.open(io.BytesIO(pix.tobytes("png")))
+        else:
+            image = Image.open(uploaded_file)
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp_file:
+            image.save(tmp_file.name, format="JPEG")
+            image_path = tmp_file.name
+
+        with st.sidebar:
+            st.image(image, caption=f"Uploaded Image", use_container_width=True)
+    
+
+        results = predict_segments(model_seg, image_path)
+        masks_resized = segmentation_to_binary(results)
+        original_image = cv2.imread(image_path)
+
+        # Generate a unique cache key per image
+        wall_cache_key = f"walls_{file_hash(uploaded_file)}"
+
+        if wall_cache_key not in st.session_state:
+            detected_boxes = detect_resize_walls(image_path, model_obj)
+            filtered_bboxes = remove_interior_walls(masks_resized, detected_boxes)
+            st.session_state[wall_cache_key] = filtered_bboxes
+        else:
+            filtered_bboxes = st.session_state[wall_cache_key]
+
+        
+        img_with_ids = cv2.imread(image_path)
+        wall_data = []
+
+        for idx, bbox in enumerate(filtered_bboxes):
+            x1, y1, x2, y2 = bbox
+            length_x = x2 - x1
+            length_y = y2 - y1
+            wall_data.append({"id": idx, "bbox": bbox, "length_x": length_x, "length_y": length_y})
+            img_with_ids = draw_bbox(img_with_ids, bbox, wall_id=idx)
+
+        st.image(img_with_ids, caption="Click on the ID below to select your reference wall")
+
+        filled_masks = [fill_segments(mask, filtered_bboxes) for mask in masks_resized]
+
+
+        wall_options = [f"Wall {w['id']}: {w['length_x']}px x {w['length_y']}px" for w in wall_data]
+        selected_wall_label = st.selectbox("Select a reference wall by ID", wall_options)
+        selected_wall = wall_data[wall_options.index(selected_wall_label)]
+
+        longest_side_px = max(selected_wall["length_x"], selected_wall["length_y"])
+
+        line_length_meters = st.number_input("Enter the known length of the wall (in meters):", min_value=0.1, step=0.1)
+
+        run_detection = st.button("Calculate usable floor area BRA")
+
+        if run_detection:
+            if line_length_meters > 0:
+                pixels_per_meter = longest_side_px / line_length_meters
+                
+                calculate_BRA(pixels_per_meter, filled_masks)
+
+     
+            st.subheader("Segmented Area")
+        
+            fig = plot_results_streamlit(image_path, filled_masks)
+            st.pyplot(fig)
+
+            
+
+