Update app.py

app.py

@@ -3,104 +3,84 @@ import ezdxf
 import io
 import pandas as pd
 import matplotlib.pyplot as plt
-import matplotlib.patches as patches
 from fpdf import FPDF
-from tempfile import NamedTemporaryFile
+import matplotlib.patches as patches
 import tempfile
-import numpy as np
 
-# Constants
-BRICK_VOLUME_CFT = (9/12) * (4.5/12) * (3/12)
+# Constants for estimation
+BRICK_VOLUME_CFT = (9 / 12) * (4.5 / 12) * (3 / 12)  # Brick Volume in Cubic Feet
 CEMENT_SAND_RATIO = 1 / 6
 SAND_RATIO = 5 / 6
-CEMENT_DENSITY_KG_PER_CFT = 1440 / 35.3147
-CEMENT_BAG_WEIGHT_KG = 50
-DEFAULT_WALL_HEIGHT = 10  # ft
+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
 
+# 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):
-    doc = ezdxf.read(file_bytes)
-    msp = doc.modelspace()
+    try:
+        # Try to open the file as ASCII first
+        doc = ezdxf.read(io.TextIOWrapper(file_bytes, encoding='utf-8', errors='ignore'))
+    except Exception as e:
+        try:
+            # If ASCII fails, attempt to read as binary DXF
+            doc = ezdxf.read(file_bytes)
+        except Exception as ex:
+            st.error(f"Error reading DXF file: {ex}")
+            return [], 0.75, [], [], []
 
-    lines = []
-    polylines = []
-    texts = []
-
-    for e in msp:
-        if e.dxftype() == "LINE":
-            lines.append(((e.dxf.start.x, e.dxf.start.y), (e.dxf.end.x, e.dxf.end.y)))
-        elif e.dxftype() == "LWPOLYLINE":
-            polylines.append(e)
-        elif e.dxftype() == "TEXT":
-            texts.append(e.dxf.text.lower())
-
-    wall_segments = []
-    used = set()
-    tolerance = 0.1  # ft
-
-    # Group close parallel lines as walls
-    for i, (start1, end1) in enumerate(lines):
-        for j, (start2, end2) in enumerate(lines):
-            if i >= j:
-                continue
-            if np.allclose([start1[0], end1[0]], [start2[0], end2[0]], atol=tolerance) or \
-               np.allclose([start1[1], end1[1]], [start2[1], end2[1]], atol=tolerance):
-                dist = np.linalg.norm(np.array(start1) - np.array(start2))
-                if 0.6 < dist < 1:  # Between 7in to 12in (i.e. wall thickness)
-                    wall_segments.append((start1, end1, start2, end2))
-                    used.add(i)
-                    used.add(j)
-
-    wall_thicknesses = []
+    msp = doc.modelspace()
     rooms = []
     room_shapes = []
-    for p in polylines:
-        if p.closed:
-            pts = p.get_points()
-            xs = [pt[0] for pt in pts]
-            ys = [pt[1] for pt in pts]
-            min_x, max_x = min(xs), max(xs)
-            min_y, max_y = min(ys), max(ys)
-            l = (max_x - min_x) / 12
-            w = (max_y - min_y) / 12
-            if l > 1 and w > 1:
-                rooms.append((round(l, 2), round(w, 2), DEFAULT_WALL_HEIGHT))
-                room_shapes.append((min_x, min_y, max_x, max_y))
-
     doors = []
     windows = []
-    for p in polylines:
-        if p.closed:
-            pts = p.get_points()
-            xs = [pt[0] for pt in pts]
-            ys = [pt[1] for pt in pts]
-            min_x, max_x = min(xs), max(xs)
-            min_y, max_y = min(ys), max(ys)
-            l = (max_x - min_x) / 12
-            h = (max_y - min_y) / 12
-            if 2 <= l <= 5 and 6 <= h <= 8:
-                doors.append((l, h))
-            elif 2 <= l <= 6 and 2 <= h <= 5:
-                windows.append((l, h))
-
-    wall_thickness = 0.75  # default
-    if wall_segments:
-        pt1, _, pt2, _ = wall_segments[0]
-        wall_thickness = round(np.linalg.norm(np.array(pt1) - np.array(pt2)) / 12, 2)
+    wall_thickness = DEFAULT_WALL_THICKNESS
+
+    # Loop through entities in the model space
+    for entity in msp:
+        if entity.dxftype() == "TEXT":
+            content = entity.dxf.text.lower()
+            if "wall thickness" in content:
+                try:
+                    wall_thickness = float(content.split(":")[1].strip())
+                except:
+                    continue
+
+        elif entity.dxftype() == "LWPOLYLINE":
+            # Check if it's a closed polyline representing a room
+            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]
+                length = abs(max(x_vals) - min(x_vals)) / 12  # Convert to feet
+                width = abs(max(y_vals) - min(y_vals)) / 12  # Convert to feet
+                if length > 2 and width > 2:
+                    rooms.append((length, width, 10))  # Add room with length, width, and height (default 10 ft)
+                    room_shapes.append((min(x_vals), min(y_vals), max(x_vals), max(y_vals)))
+
+        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
 
+
+# Estimation Function
 def estimate(rooms, wall_thickness, doors, windows):
     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)
-    beam_volume = sum((l + 1) * 0.75 * 0.75 for l, h in doors + windows)
-    net_volume = wall_volume - opening_volume - beam_volume
+    opening_volume = sum(l * h * wall_thickness for _, l, h in doors + windows)
+    net_volume = wall_volume - opening_volume
 
+    # 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
@@ -111,7 +91,6 @@ 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,
@@ -120,107 +99,96 @@ 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
-
-def generate_pdf(data_dict, calc_details, room_shapes, doors, windows):
+# 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', 14)
+    pdf.set_font("Arial", 'B', size=14)
     pdf.cell(200, 10, "Estimation Report", ln=True, align='C')
     pdf.ln(5)
 
-    pdf.set_font("Arial", 'B', 12)
+    # Add Summary of Quantities
+    pdf.set_font("Arial", 'B', size=12)
     pdf.cell(200, 10, "Summary of Quantities", ln=True)
-    pdf.set_font("Arial", '', 11)
+    pdf.set_font("Arial", '', size=11)
     for key, value in data_dict.items():
         pdf.cell(200, 10, f"{key}: {value}", ln=True)
 
-    pdf.set_font("Arial", 'B', 12)
-    pdf.cell(200, 10, "Doors", ln=True)
-    pdf.set_font("Arial", '', 11)
-    for i, (l, h) in enumerate(doors, 1):
-        pdf.cell(200, 10, f"Door {i}: {l} ft x {h} ft", ln=True)
-
-    pdf.set_font("Arial", 'B', 12)
-    pdf.cell(200, 10, "Windows", ln=True)
-    pdf.set_font("Arial", '', 11)
-    for i, (l, h) in enumerate(windows, 1):
-        pdf.cell(200, 10, f"Window {i}: {l} ft x {h} ft", ln=True)
-
-    pdf.ln(6)
-    pdf.set_font("Arial", 'B', 12)
+    # 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", '', 10)
+    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. Beam Volume = (L+1) × 0.75 × 0.75 = {round(calc_details['Beam Volume (cft)'], 2)} cft
-4. Net Volume = Wall - Opening - Beam = {round(calc_details['Net Volume (cft)'], 2)} cft
-5. Brick Volume = 9in × 4.5in × 3in = {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']}
+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']}
     """)
+
+    # 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
 
-# --- App Main Logic ---
+# Function to Draw Plan Image
+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
+
+
+# Streamlit logic to display results
 if uploaded_file:
     file_bytes = io.BytesIO(uploaded_file.read())
     rooms, wall_thickness, doors, windows, room_shapes = extract_geometry(file_bytes)
 
-    st.success(f"✔️ Found {len(rooms)} room(s), {len(doors)} door(s), {len(windows)} window(s)")
-    st.write(f"📏 Wall Thickness (from drawing): {wall_thickness:.2f} ft")
+    st.success(f"✔️ Parsed {len(rooms)} rooms, {len(doors)} doors, and {len(windows)} windows.")
+    st.write(f"📏 Wall Thickness: {wall_thickness} ft")
 
+    # Estimate the materials
     bricks, sand, cement, calc_details = estimate(rooms, wall_thickness, doors, windows)
 
-    st.subheader("📐 Room Dimensions")
-    st.dataframe(pd.DataFrame(rooms, columns=["Length (ft)", "Width (ft)", "Height (ft)"]))
-
-    st.subheader("🚪 Doors")
-    st.dataframe(pd.DataFrame(doors, columns=["Width (ft)", "Height (ft)"]))
+    # Display Room Dimensions
+    st.subheader("📊 Room Dimensions")
+    df_rooms = pd.DataFrame(rooms, columns=["Length (ft)", "Width (ft)", "Height (ft)"])
+    st.dataframe(df_rooms)
 
-    st.subheader("🪟 Windows")
-    st.dataframe(pd.DataFrame(windows, columns=["Width (ft)", "Height (ft)"]))
-
-    st.subheader("📊 Estimation Results")
-    df_result = pd.DataFrame({
-        "Item": ["Bricks", "Sand (cft)", "Cement (bags)"],
-        "Quantity": [bricks, round(sand, 2), cement]
-    })
-    st.dataframe(df_result)
+    # Display Estimation Results
+    st.subheader("🧱 Estimation Result")
+    st.write(f"Total Bricks Required: {bricks}")
+    st.write(f"Total Sand Volume: {sand} cft")
+    st.write(f"Total Cement Bags: {cement}")
 
+    # Generate and provide download link for the PDF
     st.subheader("📄 Export")
-    col1, col2 = st.columns(2)
-    with col1:
-        st.download_button("⬇️ Download Excel", df_result.to_csv(index=False).encode(), "estimates.csv", "text/csv")
-    with col2:
-        pdf_path = generate_pdf({
-            "Bricks Required": f"{bricks:,}",
-            "Sand Volume": f"{sand:.2f} cft",
-            "Cement Bags": f"{cement} bags"
-        }, calc_details, room_shapes, doors, windows)
-        with open(pdf_path, "rb") as f:
-            st.download_button("⬇️ Download PDF", f.read(), "estimates.pdf", "application/pdf")
+    pdf_file = generate_pdf(
+        {"Bricks Required": bricks, "Sand Volume (cft)": sand, "Cement Bags": cement},
+        calc_details,
+        room_shapes
+    )
+    with open(pdf_file, "rb") as f:
+        st.download_button("Download Estimation Report", f, file_name="Estimation_Report.pdf")
+