Update app.py

app.py

@@ -1,4 +1,4 @@
-from flask import Flask, render_template, request, send_file
+from flask import Flask, render_template, request, redirect, url_for, session, send_file
 import tensorflow as tf
 import numpy as np
 from PIL import Image
@@ -6,17 +6,35 @@ import pickle
 import io
 import os
 import matplotlib.pyplot as plt
+from reportlab.pdfgen import canvas
+from datetime import datetime
 import logging
 
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
 app = Flask(__name__)
+app.secret_key = "your-secret-key"  # Required for session handling
 
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Paths
 MODEL_PATH = "skin_lesion_model.h5"
 HISTORY_PATH = "training_history.pkl"
 PLOT_PATH = "/tmp/static/training_plot.png"
+IMG_SIZE = (224, 224)
+CONFIDENCE_THRESHOLD = 0.30
+
+# Label map
+label_map = {
+    0: "Melanoma",
+    1: "Melanocytic nevus",
+    2: "Basal cell carcinoma",
+    3: "Actinic keratosis",
+    4: "Benign keratosis",
+    5: "Dermatofibroma",
+    6: "Vascular lesion",
+    7: "Squamous cell carcinoma"
+}
 
 # Load model
 try:
@@ -26,50 +44,28 @@ except Exception as e:
     logger.error("Failed to load model: %s", str(e))
     raise
 
-# Load training history
+# Load and plot training history
+history_dict = {}
 if os.path.exists(HISTORY_PATH):
     try:
         with open(HISTORY_PATH, "rb") as f:
             history_dict = pickle.load(f)
-        logger.info("Loaded training history from %s", HISTORY_PATH)
-    except Exception as e:
-        logger.error("Failed to load training history: %s", str(e))
-        history_dict = {}
-else:
-    history_dict = {}
-    logger.warning("Training history file %s not found", HISTORY_PATH)
-
-# Generate plot
-if "accuracy" in history_dict and "val_accuracy" in history_dict:
-    try:
         os.makedirs("/tmp/static", exist_ok=True)
-        plt.plot(history_dict['accuracy'], label='Train Accuracy')
-        plt.plot(history_dict['val_accuracy'], label='Val Accuracy')
-        plt.xlabel('Epochs')
-        plt.ylabel('Accuracy')
-        plt.title('Training History')
-        plt.legend()
-        plt.grid(True)
-        plt.savefig(PLOT_PATH)
-        plt.close()
-        logger.info("Generated training history plot at %s", PLOT_PATH)
+        if "accuracy" in history_dict and "val_accuracy" in history_dict:
+            plt.plot(history_dict['accuracy'], label='Train Accuracy')
+            plt.plot(history_dict['val_accuracy'], label='Val Accuracy')
+            plt.xlabel('Epochs')
+            plt.ylabel('Accuracy')
+            plt.title('Training History')
+            plt.legend()
+            plt.grid(True)
+            plt.savefig(PLOT_PATH)
+            plt.close()
+            logger.info("Training plot saved at %s", PLOT_PATH)
     except Exception as e:
-        logger.error("Failed to generate training plot: %s", str(e))
-
-IMG_SIZE = (224, 224)
-CONFIDENCE_THRESHOLD = 0.30
-
-label_map = {
-    0: "Melanoma",
-    1: "Melanocytic nevus",
-    2: "Basal cell carcinoma",
-    3: "Actinic keratosis",
-    4: "Benign keratosis",
-    5: "Dermatofibroma",
-    6: "Vascular lesion",
-    7: "Squamous cell carcinoma"
-}
+        logger.error("Failed to load training history or plot: %s", str(e))
 
+# Preprocess uploaded image
 def preprocess_image(image_bytes):
     try:
         image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
@@ -78,56 +74,87 @@ def preprocess_image(image_bytes):
         image_array = np.expand_dims(image_array, axis=0)
         return image_array / 255.0
     except Exception as e:
-        logger.error("Failed to preprocess image: %s", str(e))
+        logger.error("Image preprocessing failed: %s", str(e))
         raise
 
+# Generate PDF report
+def generate_pdf(report_data, filepath):
+    c = canvas.Canvas(filepath)
+    c.setFont("Helvetica", 14)
+    c.drawString(50, 800, "Skin Lesion Diagnosis Report")
+    c.setFont("Helvetica", 12)
+    y = 770
+    for key, value in report_data.items():
+        c.drawString(50, y, f"{key.capitalize()}: {value}")
+        y -= 20
+    c.drawString(50, y - 20, f"Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    c.save()
+
 @app.route("/form", methods=["GET"])
 def form():
-    logger.info("Serving form page at /form")
     return render_template("form.html", history_plot="/training_plot.png")
 
 @app.route("/training_plot.png")
 def training_plot():
-    return send_file(PLOT_PATH, mimetype='image/png')
+    return send_file(PLOT_PATH, mimetype="image/png")
 
 @app.route("/predict", methods=["POST"])
 def predict():
-    logger.info("Received prediction request")
-
-    result = {}
     try:
         if "image" not in request.files:
             raise ValueError("⚠ No image uploaded.")
-
+        
         image = request.files["image"].read()
         img_array = preprocess_image(image)
         prediction = model.predict(img_array)[0]
         predicted_index = int(np.argmax(prediction))
         confidence = float(prediction[predicted_index])
 
+        name = request.form.get("name")
+        email = request.form.get("email")
+        gender = request.form.get("gender")
+        age = request.form.get("age")
+
         if confidence < CONFIDENCE_THRESHOLD:
-            result = {
-                "prediction": "Low confidence",
-                "confidence": f"{confidence * 100:.2f}%",
-                "message": "⚠ This image is not confidently recognized. Please upload a clearer image."
-            }
+            pred_label = "Low confidence"
+            msg = "⚠ This image is not confidently recognized. Please upload a clearer image."
         else:
-            result = {
-                "prediction": label_map.get(predicted_index, "Unknown"),
-                "confidence": f"{confidence * 100:.2f}%"
-            }
-
-        logger.info("Prediction result: %s", result["prediction"])
-        return render_template("form.html", result=result, history_plot="/training_plot.png")
+            pred_label = label_map.get(predicted_index, "Unknown")
+            msg = ""
+
+        session["report"] = {
+            "name": name,
+            "email": email,
+            "gender": gender,
+            "age": age,
+            "prediction": pred_label,
+            "confidence": f"{confidence * 100:.2f}%",
+            "message": msg
+        }
 
+        return redirect(url_for("result"))
     except Exception as e:
         logger.error("Prediction error: %s", str(e))
-        result = {
+        return render_template("form.html", history_plot="/training_plot.png", result={
             "prediction": "Error",
             "confidence": "N/A",
             "message": f"An error occurred: {str(e)}"
-        }
-        return render_template("form.html", result=result, history_plot="/training_plot.png")
+        })
+
+@app.route("/result")
+def result():
+    report = session.get("report", {})
+    return render_template("result.html", **report)
+
+@app.route("/download-report")
+def download_report():
+    report = session.get("report", {})
+    if not report:
+        return redirect(url_for("form"))
+    os.makedirs("/tmp/reports", exist_ok=True)
+    filepath = "/tmp/reports/report.pdf"
+    generate_pdf(report, filepath)
+    return send_file(filepath, as_attachment=True)
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)