Modifed code to not save in directory

app.py

@@ -4,6 +4,9 @@ import numpy as np
 from keras.models import load_model
 import cv2
 import os
+from io import BytesIO
+from PIL import Image
+import base64
 
 # Define paths for the models
 MODEL_PATHS = {
@@ -14,100 +17,80 @@ MODEL_PATHS = {
 }
 
 
-def extract_face(image_path, output_path="./static/cropped_face.jpg"):
+def convert_image_to_base64(image):
+    # Convert PIL image to Base64
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")
+    return base64.b64encode(buffered.getvalue()).decode()
+
+
+def extract_face(img_array):
     # Load the Haar cascade for face detection
     cascade_path = os.path.join(
         cv2.data.haarcascades, "haarcascade_frontalface_default.xml")
     face_cascade = cv2.CascadeClassifier(cascade_path)
 
-    # Read the image in grayscale mode
-    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
-
-    if img is None:
-        print("Could not read the image.")
-        return "No face detected."
-
-    # Save the grayscale image
-    gray_output_path = "gray_" + output_path
-    cv2.imwrite(gray_output_path, img)
-    print(f"Grayscale image saved as {gray_output_path}")
-
     # Detect faces in the grayscale image
     faces = face_cascade.detectMultiScale(
-        img, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+        img_array, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
 
-    # Check if a face is detected
     if len(faces) == 0:
-        print("No face detected.")
-        return "No face detected."
+        return "No face detected.", None
 
     # Extract the first detected face (assuming there's only one face)
     x, y, w, h = faces[0]
-    face = img[y:y+h, x:x+w]
+    face = img_array[y:y+h, x:x+w]
 
     # Resize the face to 48x48 pixels
     face_resized = cv2.resize(face, (48, 48))
-
-    # Save the cropped and resized grayscale face
-    cv2.imwrite(output_path, face_resized)
-    print(f"Face extracted, resized to 48x48, and saved as {output_path}")
+    return "Face detected.", face_resized
 
 
-def preprocess_image(image_path, model_name, target_size=(48, 48)):
-    # Load the image in grayscale
-    image = load_img(image_path, color_mode='grayscale',
-                     target_size=target_size)
-    image = img_to_array(image)  # Convert to array
-    image = image / 255.0  # Normalize pixel values
+def preprocess_image(img_array, model_name, target_size=(48, 48)):
+    # Convert image array to grayscale
+    image = cv2.cvtColor(img_array, cv2.COLOR_BGR2GRAY)
+    image = cv2.resize(image, target_size)
+    image = img_to_array(image) / 255.0  # Normalize pixel values
 
     # Repeat channels if model is not base_cnn
     if model_name != "Scratch CNN Model":
-        image = np.repeat(image, 3, axis=-1)
+        image = np.repeat(image[..., np.newaxis], 3, axis=-1)
 
     # Add batch dimension
     image = np.expand_dims(image, axis=0)
     return image
 
 
-def predict_emotion(image_path, model, model_name, emotion_list):
-    image = preprocess_image(image_path, model_name)
-    prediction = model.predict(image)
+def predict_emotion(face_array, model, model_name, emotion_list):
+    processed_face = preprocess_image(face_array, model_name)
+    prediction = model.predict(processed_face)
     predicted_emotion = emotion_list[np.argmax(prediction)]
     return predicted_emotion
 
 
-def draw_bounding_box(image_path, output_path="./static/face_with_bounding_box.jpg"):
-    # Load the Haar cascade for face detection
-    cascade_path = os.path.join(
-        cv2.data.haarcascades, "haarcascade_frontalface_default.xml")
-    face_cascade = cv2.CascadeClassifier(cascade_path)
-
-    # Read the image
-    img = cv2.imread(image_path)
-    if img is None:
-        print("Could not read the image.")
-        return "No face detected."
+def getResult(selected_option, image):
+    # Load image in memory
+    img = Image.open(BytesIO(image.read()))
+    img_array = np.array(img.convert('RGB'))
 
-    # Convert the image to grayscale for face detection
-    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    # Load the model based on the selected option
+    model_path = MODEL_PATHS[selected_option]
+    model = load_model(model_path)
 
-    # Detect faces in the grayscale image
-    faces = face_cascade.detectMultiScale(
-        gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+    # Process the image
+    result, face_array = extract_face(img_array)
+    if result == "No face detected.":
+        return result, [], None
 
-    # Check if a face is detected
-    if len(faces) == 0:
-        print("No face detected.")
-        return "No face detected."
+    # Predict emotion on the extracted face
+    predicted_emotion = predict_emotion(
+        face_array, model, selected_option, emotion_list)
 
-    # Draw a bounding box around the first detected face
-    x, y, w, h = faces[0]
-    cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)
+    # Convert images to Base64 for embedding in HTML
+    bounding_box_image = convert_image_to_base64(img)
+    cropped_face_image = convert_image_to_base64(Image.fromarray(face_array))
 
-    # Save the image with the bounding box
-    cv2.imwrite(output_path, img)
-    print(f"Image with bounding box saved as {output_path}")
-    return f"Image with bounding box saved as {output_path}"
+    return "The predicted emotion is:", [bounding_box_image, cropped_face_image], predicted_emotion
 
 
 app = Flask(__name__)
@@ -115,43 +98,18 @@ emotion_list = ['angry', 'disgust', 'fear',
                 'happy', 'neutral', 'sad', 'surprise']
 
 
-def getResult(selected_option, image):
-    image.save("./static/image.jpg")
-    model_path = MODEL_PATHS[selected_option]
-    model = load_model(model_path)
-
-    bounding_face_result = draw_bounding_box("./static/image.jpg")
-    if bounding_face_result == "No face detected.":
-        return bounding_face_result, [], None
-
-    extract_face_result = extract_face(
-        "./static/image.jpg", output_path="./static/cropped_face.jpg")
-    if extract_face_result == "No face detected.":
-        return extract_face_result, [], None
-
-    image_path = './static/cropped_face.jpg'
-    predicted_emotion = predict_emotion(
-        image_path, model, selected_option, emotion_list)
-
-    images = [url_for('static', filename='face_with_bounding_box.jpg'),
-              url_for('static', filename='cropped_face.jpg')]
-
-    return "The predicted emotion is:", images, predicted_emotion
-
-
 @app.route('/', methods=['GET', 'POST'])
 def index():
     result = None
     images = []
     predicted_emotion = None
-
-    dropdown_options = ["Select a model", "Scratch CNN Model", "ImageNet Model",
-                        "MobileNet Model", "VGG16 Model"]
+    dropdown_options = ["Select a model", "Scratch CNN Model",
+                        "ImageNet Model", "MobileNet Model", "VGG16 Model"]
 
     if request.method == 'POST':
         selected_option = request.form.get('option')
         image = request.files.get('image')
-        if selected_option != "Select a model":
+        if selected_option != "Select a model" and image:
             result, images, predicted_emotion = getResult(
                 selected_option, image)
         return render_template('index.html', result=result, dropdown_options=dropdown_options, images=images, predicted_emotion=predicted_emotion, model_name=selected_option)

templates/index.html

@@ -37,18 +37,17 @@
         </form>
 
         <div class="image-section">
-            {% for img in images %}
+            {% if images %}
             <div class="image-container">
-                <img src="{{ img }}" alt="Image {{ loop.index }}" class="form-image">
-                <p>
-                    {{
-                    img.split('/').pop().split('.')[0].replace('_', ' ').capitalize()
-                    }}
-                </p>
+                <img src="data:image/jpeg;base64,{{ images[0] }}" alt="Bounding Box Image" class="form-image">
+                <p>Face with Bounding Box</p>
             </div>
-            {% endfor %}
+            <div class="image-container">
+                <img src="data:image/jpeg;base64,{{ images[1] }}" alt="Bounding Box Image" class="form-image">
+                <p>Cropped Face</p>
+            </div>
+            {% endif %}
         </div>
-
         <!-- Loading overlay -->
         <div class="loading-overlay" id="loadingOverlay" style="display: none;">
             <div class="spinner"></div>