Update app.py

app.py

@@ -1,62 +1,46 @@
+
 import streamlit as st
 import ezdxf
 import io
 import pandas as pd
 import matplotlib.pyplot as plt
 from fpdf import FPDF
+from tempfile import NamedTemporaryFile
 import matplotlib.patches as patches
 import tempfile
-import math
-from io import BytesIO
+import io
 
-# Constants for estimation
-BRICK_VOLUME_CFT = (9 / 12) * (4.5 / 12) * (3 / 12)  # Brick Volume in Cubic Feet
+# Constants
+BRICK_VOLUME_CFT = (9/12) * (4.5/12) * (3/12)
 CEMENT_SAND_RATIO = 1 / 6
 SAND_RATIO = 5 / 6
-CEMENT_DENSITY_KG_PER_CFT = 1440 / 35.3147  # Cement Density in KG per Cubic Foot
-CEMENT_BAG_WEIGHT_KG = 50  # Weight of Cement Bag in KG
-DEFAULT_WALL_THICKNESS = 0.75  # Default wall thickness in feet
+CEMENT_DENSITY_KG_PER_CFT = 1440 / 35.3147
+CEMENT_BAG_WEIGHT_KG = 50
+DEFAULT_WALL_THICKNESS = 0.75
 
-# Streamlit Setup
 st.set_page_config(page_title="Building Estimator from CAD", layout="wide")
 st.title("🏗️ Auto Estimation from AutoCAD (.dxf) Drawing")
 
 uploaded_file = st.file_uploader("Upload your DXF file", type=["dxf"])
 
-# Function to Extract Geometry from DXF
 @st.cache_data
 def extract_geometry(file_bytes):
     try:
-        # Use BytesIO to read the uploaded file bytes properly
-        file_stream = BytesIO(file_bytes)  # Convert bytes to a file-like object
-        doc = ezdxf.read(file_stream)
+        # Convert file bytes into a file-like object
+        file_stream = io.BytesIO(file_bytes)
+        doc = ezdxf.read(file_stream)  # Use the correct function to read from the byte stream
     except Exception as e:
         st.error(f"Error reading DXF file: {e}")
-        return [], 0.75, [], [], [], []
+        return [], 0.75, [], 1, [], []
 
     msp = doc.modelspace()
     rooms = []
     room_shapes = []
-    doors = []
-    windows = []
+    openings = []
+    floors = 1
     wall_thickness = DEFAULT_WALL_THICKNESS
     wall_pairs = []
 
-    # Detecting walls (parallel lines that represent wall edges)
-    wall_lines = []
-    for entity in msp:
-        if entity.dxftype() == "LINE":
-            wall_lines.append(entity)
-
-    # Check for parallel lines representing a wall (detect double lines)
-    for i, line1 in enumerate(wall_lines):
-        for line2 in wall_lines[i + 1:]:
-            if are_lines_parallel(line1, line2):
-                # Calculate the distance between the two parallel lines
-                wall_thickness = calculate_wall_thickness(line1, line2)
-                wall_pairs.append((line1, line2, wall_thickness))
-
-    # Process rooms, doors, and windows from entities
     for entity in msp:
         if entity.dxftype() == "TEXT":
             content = entity.dxf.text.lower()
@@ -65,54 +49,42 @@ def extract_geometry(file_bytes):
                     wall_thickness = float(content.split(":")[1].strip())
                 except:
                     continue
+            elif "floor" in content:
+                try:
+                    floors = int(content.split(":")[1].strip())
+                except:
+                    continue
 
         elif entity.dxftype() == "LWPOLYLINE":
-            # Check if it's a closed polyline representing a room
-            if entity.closed:
+            if entity.closed and len(entity) == 4:
                 points = entity.get_points()
                 x_vals = [p[0] for p in points]
                 y_vals = [p[1] for p in points]
-                width = abs(max(x_vals) - min(x_vals)) / 12  # Convert to feet
-                height = abs(max(y_vals) - min(y_vals)) / 12  # Convert to feet
-                if width > 2 and height > 2:  # Make sure it's a room-like area
-                    rooms.append((width, height, 10))  # Add room with length, width, and height (default 10 ft)
+                length = abs(max(x_vals) - min(x_vals)) / 12
+                width = abs(max(y_vals) - min(y_vals)) / 12
+                height = 10
+                if length > 2 and width > 2:
+                    rooms.append((length, width, height))
                     room_shapes.append((min(x_vals), min(y_vals), max(x_vals), max(y_vals)))
+                else:
+                    openings.append(("opening", length, height))
 
         elif entity.dxftype() == "LINE":
-            # Check for doors or windows (typically represented as lines in DXF)
-            if entity.dxf.layer.lower() == "doors":
-                doors.append(("door", entity.dxf.start.x, entity.dxf.start.y))
-            elif entity.dxf.layer.lower() == "windows":
-                windows.append(("window", entity.dxf.start.x, entity.dxf.start.y))
-
-    return rooms, wall_thickness, doors, windows, room_shapes, wall_pairs
-
-
-# Function to Check if Lines are Parallel
-def are_lines_parallel(line1, line2):
-    dx1, dy1 = line1.dxf.end.x - line1.dxf.start.x, line1.dxf.end.y - line1.dxf.start.y
-    dx2, dy2 = line2.dxf.end.x - line2.dxf.start.x, line2.dxf.end.y - line2.dxf.start.y
-    # Check if the direction vectors are nearly parallel (with some tolerance)
-    tolerance = 0.1
-    return abs(dx1 * dy2 - dy1 * dx2) < tolerance
+            # Process lines for walls
+            start_point = entity.dxf.start
+            end_point = entity.dxf.end
+            distance = ((end_point.x - start_point.x) ** 2 + (end_point.y - start_point.y) ** 2) ** 0.5
+            if distance >= 9:  # If the line represents a wall, assuming threshold distance for walls
+                wall_pairs.append((start_point, end_point))
 
+    return rooms, wall_thickness, openings, floors, room_shapes, wall_pairs
 
-# Function to Calculate the Thickness Between Two Parallel Lines
-def calculate_wall_thickness(line1, line2):
-    x1, y1 = line1.dxf.start.x, line1.dxf.start.y
-    x2, y2 = line2.dxf.start.x, line2.dxf.start.y
-    # Calculate distance between the two lines using the distance formula
-    distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
-    return distance / 12  # Convert to feet
-
-
-# Estimation Function
-def estimate(rooms, wall_thickness, doors, windows):
+def estimate(rooms, wall_thickness, openings, floors):
     wall_volume = sum(2 * (l + w) * h * wall_thickness for l, w, h in rooms)
-    opening_volume = sum(l * h * wall_thickness for _, l, h in doors + windows)
-    net_volume = wall_volume - opening_volume
+    opening_volume = sum(l * h * wall_thickness for _, l, h in openings)
+    beam_volume = sum((l + 1) * 0.75 * 0.75 for _, l, _ in openings)
+    net_volume = (wall_volume - opening_volume - beam_volume) * floors
 
-    # Estimating the number of bricks
     number_of_bricks = round((net_volume / BRICK_VOLUME_CFT) * 1.05)
     mortar_volume = net_volume * 0.25
     cement_volume = mortar_volume * CEMENT_SAND_RATIO
@@ -123,6 +95,7 @@ def estimate(rooms, wall_thickness, doors, windows):
     return number_of_bricks, sand_volume, cement_bags, {
         "Wall Volume (cft)": wall_volume,
         "Opening Volume (cft)": opening_volume,
+        "Beam Volume (cft)": beam_volume,
         "Net Volume (cft)": net_volume,
         "Mortar Volume (cft)": mortar_volume,
         "Cement Volume (cft)": cement_volume,
@@ -131,97 +104,89 @@ def estimate(rooms, wall_thickness, doors, windows):
         "Brick Volume (cft)": BRICK_VOLUME_CFT
     }
 
+def draw_plan_image(room_shapes):
+    fig, ax = plt.subplots()
+    for x0, y0, x1, y1 in room_shapes:
+        width = x1 - x0
+        height = y1 - y0
+        rect = patches.Rectangle((x0, y0), width, height, linewidth=1, edgecolor='black', facecolor='none')
+        ax.add_patch(rect)
+        ax.text(x0 + width / 2, y0 - 2, f"{round(width / 12, 1)} ft", ha='center', fontsize=8)
+        ax.text(x1 + 2, y0 + height / 2, f"{round(height / 12, 1)} ft", va='center', fontsize=8, rotation=90)
+    ax.set_aspect('equal')
+    ax.axis('off')
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+    fig.savefig(temp_file.name, bbox_inches='tight')
+    plt.close(fig)
+    return temp_file.name
 
-# Function to Generate PDF with Estimation
 def generate_pdf(data_dict, calc_details, room_shapes):
     image_path = draw_plan_image(room_shapes)
+
     pdf = FPDF()
     pdf.add_page()
     pdf.set_font("Arial", 'B', size=14)
     pdf.cell(200, 10, "Estimation Report", ln=True, align='C')
     pdf.ln(5)
 
-    # Add Summary of Quantities
     pdf.set_font("Arial", 'B', size=12)
     pdf.cell(200, 10, "Summary of Quantities", ln=True)
     pdf.set_font("Arial", '', size=11)
     for key, value in data_dict.items():
         pdf.cell(200, 10, f"{key}: {value}", ln=True)
 
-    # Add Calculations with Formulas
     pdf.ln(8)
     pdf.set_font("Arial", 'B', size=12)
     pdf.cell(200, 10, "Step-by-Step Calculations with Formulas", ln=True)
+
     pdf.set_font("Arial", '', size=10)
     pdf.multi_cell(0, 8, f"""
 1. Wall Volume = 2 × (L + W) × H × t = {round(calc_details['Wall Volume (cft)'], 2)} cft
 2. Opening Volume = L × H × t = {round(calc_details['Opening Volume (cft)'], 2)} cft
-3. Net Volume = Wall - Opening = {round(calc_details['Net Volume (cft)'], 2)} cft
-4. Bricks = Net Volume / Brick Volume × 1.05 = {data_dict['Bricks Required']}
-5. Mortar = Net Volume × 0.25 = {round(calc_details['Mortar Volume (cft)'], 2)} cft
-6. Cement = Mortar × 1/6 = {round(calc_details['Cement Volume (cft)'], 2)} cft
-7. Sand = Mortar × 5/6 = {round(calc_details['Sand Volume (cft)'], 2)} cft
-8. Cement Bags = Cement / Bag Volume = {data_dict['Cement Bags']}
+3. Beam Volume = (L+1) × 0.75 × 0.75 = {round(calc_details['Beam Volume (cft)'], 2)} cft
+4. Net Volume = (Wall - Opening - Beam) × Floors = {round(calc_details['Net Volume (cft)'], 2)} cft
+5. Brick Volume = 9" × 4.5" × 3" = {round(calc_details['Brick Volume (cft)'], 4)} cft
+6. Bricks = Net Volume / Brick Vol × 1.05 = {data_dict['Bricks Required']}
+7. Mortar = Net Volume × 0.25 = {round(calc_details['Mortar Volume (cft)'], 2)} cft
+8. Cement = Mortar × 1/6 = {round(calc_details['Cement Volume (cft)'], 2)} cft
+9. Sand = Mortar × 5/6 = {round(calc_details['Sand Volume (cft)'], 2)} cft
+10. Cement Bags = Cement / Bag Volume = {data_dict['Cement Bags']}
     """)
 
-    # Add 2D Plan with Dimensions
     pdf.ln(5)
     pdf.set_font("Arial", 'B', size=12)
     pdf.cell(200, 10, "2D Plan with Dimensions (in ft)", ln=True)
     pdf.image(image_path, x=10, y=None, w=180)
 
-    # Export to PDF
     tmp = NamedTemporaryFile(delete=False, suffix=".pdf")
     pdf.output(tmp.name)
     return tmp.name
 
-
-# Function to Draw Plan Image
-def draw_plan_image(room_shapes):
+def plot_rooms(shapes):
     fig, ax = plt.subplots()
-    for x0, y0, x1, y1 in room_shapes:
-        width = x1 - x0
-        height = y1 - y0
-        rect = patches.Rectangle((x0, y0), width, height, linewidth=1, edgecolor='black', facecolor='none')
+    for x0, y0, x1, y1 in shapes:
+        width = (x1 - x0)
+        height = (y1 - y0)
+        rect = plt.Rectangle((x0, y0), width, height, fill=False, edgecolor='blue', linewidth=2)
         ax.add_patch(rect)
-        ax.text(x0 + width / 2, y0 - 2, f"{round(width / 12, 1)} ft", ha='center', fontsize=8)
-        ax.text(x1 + 2, y0 + height / 2, f"{round(height / 12, 1)} ft", va='center', fontsize=8)
-    
-    ax.set_aspect('equal', 'box')
-    ax.set_title("2D Room Layout")
-    ax.set_xlabel("X (ft)")
-    ax.set_ylabel("Y (ft)")
-    plt.axis('off')
-    
-    img_path = "/tmp/room_layout.png"
-    plt.savefig(img_path)
-    plt.close()
-    return img_path
-
-
-# Main function to handle Streamlit interface
-if uploaded_file is not None:
-    file_bytes = uploaded_file.read()
+    ax.set_title("🗏️ 2D Floor Plan")
+    ax.set_aspect("equal")
+    ax.axis("off")
+    st.pyplot(fig)
 
-    try:
-        rooms, wall_thickness, doors, windows, room_shapes, wall_pairs = extract_geometry(file_bytes)
-        st.write(f"Found {len(rooms)} rooms, {len(doors)} doors, {len(windows)} windows.")
-        
-        if rooms:
-            number_of_bricks, sand_volume, cement_bags, calc_details = estimate(rooms, wall_thickness, doors, windows)
-
-            st.write(f"Estimated Bricks Required: {number_of_bricks}")
-            st.write(f"Estimated Cement Bags: {cement_bags}")
-            st.write(f"Estimated Sand Volume (cft): {sand_volume}")
+if uploaded_file:
+    file_bytes = uploaded_file.read()
+    rooms, wall_thickness, doors, windows, room_shapes, wall_pairs = extract_geometry(file_bytes)
 
-            pdf_file = generate_pdf({
-                "Bricks Required": number_of_bricks,
-                "Cement Bags": cement_bags,
-                "Sand Volume (cft)": sand_volume
-            }, calc_details, room_shapes)
+    if rooms:
+        st.subheader("🧱 Estimation Result")
+        number_of_bricks, sand_volume, cement_bags, calc_details = estimate(rooms, wall_thickness, doors, 1)
+        st.write(f"Number of Bricks: {number_of_bricks}")
+        st.write(f"Sand Volume (cft): {round(sand_volume, 2)}")
+        st.write(f"Cement Bags Required: {cement_bags}")
 
-            with open(pdf_file, "rb") as f:
-                st.download_button("Download Estimation PDF", f, file_name="estimation_report.pdf")
+        plot_rooms(room_shapes)
 
-    except Exception as e:
-        st.error(f"Error: {str(e)}")
+        st.subheader("📄 Export")
+        pdf_file = generate_pdf({"Bricks Required": number_of_bricks, "Cement Bags": cement_bags}, calc_details, room_shapes)
+        st.download_button("Download PDF Report", pdf_file, file_name="estimation_report.pdf")