Update app.py

app.py

@@ -1,41 +1,10 @@
 import cv2
 import numpy as np
+from PIL import Image
 import gradio as gr
-from pdf2image import convert_from_path
-import os
-import tempfile
-import logging
-
-# Set up logging to debug.log
-logging.basicConfig(
-    filename='debug.log',
-    level=logging.DEBUG,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
 
 # Function to calculate materials based on blueprint dimensions
 def calculate_materials_from_dimensions(wall_area, foundation_area):
-    """
-    Calculate required materials (cement, bricks, steel) based on wall and foundation areas.
-    Args:
-        wall_area (float): Wall area in square meters.
-        foundation_area (float): Foundation area in square meters.
-    Returns:
-        dict: Material quantities (cement in kg, bricks in units, steel in kg).
-    Raises:
-        ValueError: If areas are negative or invalid.
-    """
-    logger.debug(f"Calculating materials for wall_area={wall_area}, foundation_area={foundation_area}")
-    
-    # Validate inputs
-    if not isinstance(wall_area, (int, float)) or not isinstance(foundation_area, (int, float)):
-        logger.error("Invalid area type: wall_area and foundation_area must be numeric")
-        raise ValueError("Wall and foundation areas must be numeric")
-    if wall_area < 0 or foundation_area < 0:
-        logger.error("Negative areas provided: wall_area=%s, foundation_area=%s", wall_area, foundation_area)
-        raise ValueError("Wall and foundation areas must be non-negative")
-
     materials = {
         "cement": 0,
         "bricks": 0,
@@ -46,182 +15,83 @@ def calculate_materials_from_dimensions(wall_area, foundation_area):
     if wall_area > 0:
         materials['cement'] += wall_area * 10  # 10 kg cement per m² for walls
         materials['bricks'] += wall_area * 500  # 500 bricks per m² for walls
-        materials['steel'] += wall_area * 2    # 2 kg steel per m² for walls
-        logger.debug("Wall materials: cement=%s kg, bricks=%s, steel=%s kg",
-                     materials['cement'], materials['bricks'], materials['steel'])
+        materials['steel'] += wall_area * 2  # 2 kg steel per m² for walls
 
     # Foundation calculations (in m²)
     if foundation_area > 0:
         materials['cement'] += foundation_area * 20  # 20 kg cement per m² for foundation
         materials['bricks'] += foundation_area * 750  # 750 bricks per m² for foundation
-        materials['steel'] += foundation_area * 5     # 5 kg steel per m² for foundation
-        logger.debug("Foundation materials added: cement=%s kg, bricks=%s, steel=%s kg",
-                     materials['cement'], materials['bricks'], materials['steel'])
+        materials['steel'] += foundation_area * 5  # 5 kg steel per m² for foundation
 
-    logger.info("Material calculation complete: %s", materials)
     return materials
 
-# Function to process the blueprint from a PDF
-def process_blueprint(pdf_path, blueprint_width_m=27, blueprint_height_m=9.78, poppler_path=None):
-    """
-    Process a PDF blueprint to estimate construction materials.
-    Args:
-        pdf_path (str): Path to the PDF file.
-        blueprint_width_m (float): Blueprint width in meters (default: 27).
-        blueprint_height_m (float): Blueprint height in meters (default: 9.78).
-        poppler_path (str, optional): Path to poppler binaries.
-    Returns:
-        dict: Formatted material estimates or error message.
-    """
-    logger.info("Starting blueprint processing for PDF: %s", pdf_path)
-    
-    # Validate inputs
-    if not os.path.exists(pdf_path):
-        logger.error("PDF file does not exist: %s", pdf_path)
-        return {"error": f"PDF file not found: {pdf_path}"}
-    if not isinstance(blueprint_width_m, (int, float)) or not isinstance(blueprint_height_m, (int, float)):
-        logger.error("Invalid blueprint dimensions: width=%s, height=%s", blueprint_width_m, blueprint_height_m)
-        return {"error": "Blueprint width and height must be numeric"}
-    if blueprint_width_m <= 0 or blueprint_height_m <= 0:
-        logger.error("Invalid blueprint dimensions: width=%s, height=%s", blueprint_width_m, blueprint_height_m)
-        return {"error": "Blueprint width and height must be positive"}
-
-    try:
-        # Convert PDF to images
-        logger.debug("Converting PDF to image with poppler_path=%s", poppler_path)
-        images = convert_from_path(
-            pdf_path,
-            first_page=1,
-            last_page=1,
-            poppler_path=poppler_path
-        )
-        if not images:
-            logger.error("No images extracted from PDF")
-            return {"error": "No images extracted from the PDF"}
-
-        logger.info("Successfully extracted %d image(s) from PDF", len(images))
-
-        # Save the first page as a temporary image
-        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
-            images[0].save(temp_file.name, 'PNG')
-            temp_image_path = temp_file.name
-            logger.debug("Saved temporary image to: %s", temp_image_path)
-
-        # Verify temporary file exists
-        if not os.path.exists(temp_image_path):
-            logger.error("Temporary image file not created: %s", temp_image_path)
-            return {"error": "Failed to create temporary image file"}
-
-        # Open the image with OpenCV
-        image = cv2.imread(temp_image_path)
-        if image is None:
-            logger.error("Failed to load image from: %s", temp_image_path)
-            return {"error": "Could not load the image from PDF"}
-
-        logger.info("Loaded image with dimensions: %s", image.shape)
-
-        # Clean up temporary file
-        os.unlink(temp_image_path)
-        logger.debug("Deleted temporary image file: %s", temp_image_path)
-
-        # Convert to grayscale for easier processing
-        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        logger.debug("Converted image to grayscale")
-
-        # Apply edge detection to find lines (walls)
-        edges = cv2.Canny(gray, 50, 150, apertureSize=3)
-        logger.debug("Applied Canny edge detection")
-
-        # Use Hough Transform to detect lines (walls)
-        lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=100, minLineLength=50, maxLineGap=10)
-        logger.debug("Detected %s lines with Hough Transform", len(lines) if lines is not None else 0)
-
-        # Calculate total wall length (in pixels)
-        total_wall_length_pixels = 0
-        if lines is not None:
-            for line in lines:
-                x1, y1, x2, y2 = line[0]
-                length = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
-                total_wall_length_pixels += length
-                logger.debug("Line from (%d,%d) to (%d,%d), length=%f pixels", x1, y1, x2, y2, length)
-        else:
-            logger.warning("No lines detected in the blueprint")
-
-        logger.info("Total wall length in pixels: %f", total_wall_length_pixels)
-
-        # Get image dimensions
-        image_height, image_width = image.shape[:2]
-        logger.debug("Image dimensions: width=%d, height=%d pixels", image_width, image_height)
-
-        # Calculate pixel-to-meter ratio
-        pixel_to_meter_width = blueprint_width_m / image_width
-        pixel_to_meter_height = blueprint_height_m / image_height
-        pixel_to_meter = (pixel_to_meter_width + pixel_to_meter_height) / 2
-        logger.debug("Pixel-to-meter ratios: width=%f, height=%f, average=%f",
-                     pixel_to_meter_width, pixel_to_meter_height, pixel_to_meter)
-
-        # Convert wall length to meters
-        total_wall_length_m = total_wall_length_pixels * pixel_to_meter
-        logger.info("Total wall length in meters: %f", total_wall_length_m)
-
-        # Estimate wall area (assume wall height of 3 m)
-        wall_height_m = 3  # Hardcoded assumption; may need adjustment
-        wall_area = total_wall_length_m * wall_height_m
-        logger.info("Wall area: %f m² (wall length=%f m, height=%f m)",
-                    wall_area, total_wall_length_m, wall_height_m)
-
-        # Estimate foundation area (10% of total blueprint area)
-        total_area = blueprint_width_m * blueprint_height_m
-        foundation_area = total_area * 0.1  # Hardcoded assumption
-        logger.info("Total area: %f m², Foundation area: %f m²", total_area, foundation_area)
-
-        # Calculate materials
-        materials = calculate_materials_from_dimensions(wall_area, foundation_area)
-        logger.info("Raw material estimates: %s", materials)
-
-        # Format the output
-        formatted_materials = {
-            "cement": f"{materials['cement']:.2f} kg",
-            "bricks": f"{materials['bricks']:.0f} units",
-            "steel": f"{materials['steel']:.2f} kg"
-        }
-        logger.info("Formatted material estimates: %s", formatted_materials)
-
-        return formatted_materials
-
-    except Exception as e:
-        # Customize error message for poppler-related issues
-        error_msg = str(e)
-        if "Unable to get page count" in error_msg:
-            error_msg = (
-                "Poppler is not installed or not in PATH. "
-                "Please install poppler-utils:\n"
-                "- Windows: Download from https://github.com/oschwartz10612/poppler-windows and add to PATH.\n"
-                "- Linux: Run 'sudo apt-get install poppler-utils'.\n"
-                "- Mac: Run 'brew install poppler'.\n"
-                "Alternatively, specify poppler_path in the input (e.g., C:/poppler/bin)."
-            )
-        logger.error("Processing failed: %s", error_msg)
-        return {"error": f"Failed to process PDF: {error_msg}"}
+# Function to process the blueprint and extract dimensions
+def process_blueprint(image_path):
+    # Open the image
+    image = cv2.imread(image_path)
+    if image is None:
+        raise ValueError("Could not load the image")
+
+    # Convert to grayscale for easier processing
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+    # Apply edge detection to find lines (walls)
+    edges = cv2.Canny(gray, 50, 150, apertureSize=3)
+
+    # Use Hough Transform to detect lines (walls)
+    lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=100, minLineLength=50, maxLineGap=10)
+
+    # Calculate total wall length (in pixels)
+    total_wall_length_pixels = 0
+    if lines is not None:
+        for line in lines:
+            x1, y1, x2, y2 = line[0]
+            length = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+            total_wall_length_pixels += length
+
+    # From the blueprint, we know the dimensions (27 m × 9.78 m)
+    # We also need to estimate the pixel-to-meter scale
+    image_height, image_width = image.shape[:2]
+    blueprint_width_m = 27  # From the blueprint (27 m)
+    blueprint_height_m = 9.78  # From the blueprint (9.78 m)
+
+    # Calculate pixel-to-meter ratio
+    pixel_to_meter_width = blueprint_width_m / image_width
+    pixel_to_meter_height = blueprint_height_m / image_height
+    pixel_to_meter = (pixel_to_meter_width + pixel_to_meter_height) / 2  # Average for simplicity
+
+    # Convert wall length to meters
+    total_wall_length_m = total_wall_length_pixels * pixel_to_meter
+
+    # Estimate wall area (assume wall height of 3 m for simplicity)
+    wall_height_m = 3  # Standard room height
+    wall_area = total_wall_length_m * wall_height_m
+
+    # Estimate foundation area (based on the blueprint's total area)
+    total_area = blueprint_width_m * blueprint_height_m  # 27 m × 9.78 m
+    foundation_area = total_area * 0.1  # Assume 10% of the total area is foundation
+
+    # Calculate materials
+    materials = calculate_materials_from_dimensions(wall_area, foundation_area)
+
+    # Format the output
+    formatted_materials = {
+        "cement": f"{materials['cement']:.2f} kg",
+        "bricks": f"{materials['bricks']:.0f} units",
+        "steel": f"{materials['steel']:.2f} kg"
+    }
+
+    return formatted_materials
 
 # Set up Gradio interface
 interface = gr.Interface(
     fn=process_blueprint,
-    inputs=[
-        gr.File(file_types=[".pdf"], label="Upload Blueprint PDF"),
-        gr.Number(label="Blueprint Width (meters)", value=27),
-        gr.Number(label="Blueprint Height (meters)", value=9.78),
-        gr.Text করুনbox(label="Poppler Path (optional)", placeholder="e.g., C:/poppler/bin")
-    ],
+    inputs=gr.Image(type="filepath", label="Upload Blueprint Image"),
     outputs=gr.JSON(label="Material Estimates"),
     title="Blueprint Material Estimator",
-    description=(
-        "Upload a PDF containing a blueprint to estimate construction materials. "
-        "Specify blueprint dimensions and optionally provide the path to poppler binaries if not in PATH."
-    )
+    description="Upload a blueprint image to estimate construction materials."
 )
 
 # Launch the interface
 if __name__ == "__main__":
-    logger.info("Launching Gradio interface")
     interface.launch(share=False)