Update app.py

app.py

@@ -1,20 +1,27 @@
-import gradio as gr
 import cv2
 import numpy as np
 from keras.models import load_model
+from moviepy.editor import VideoFileClip
+import gradio as gr
 
-# Load the pre-trained model
+# Load the AI model
 model = load_model('model.h5')
 
 def process_frame(frame):
     # Resize the image to (128, 128)
-    resized_frame = cv2.resize(frame, (128, 128))  # Resize to 128x128
-    resized_frame = cv2.cvtColor(resized_frame, cv2.COLOR_BGR2RGB)  # Convert to RGB
-    img_array = np.array(resized_frame) / 255.0  # Normalize pixel values
-    img_array = img_array.reshape(1, 128, 128, 3)  # Reshape for model input
+    resized_frame = cv2.resize(frame, (128, 128))
+    resized_frame = cv2.cvtColor(resized_frame, cv2.COLOR_BGR2RGB)
+    img_array = np.array(resized_frame) / 255.0
+    img_array = img_array.reshape(1, 128, 128, 3)
     
     prediction = model.predict(img_array)  # Get prediction
-    return prediction
+
+    # Example logic to modify frame based on prediction
+    if prediction[0][0] > 0.5:  # Condition based on prediction
+        return frame  # Keep the original frame if the condition is met
+    else:
+        # Example modification: convert to grayscale
+        return cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
 def convert_video_to_dumpscare(video, sensitivity):
     output_frames = []
@@ -25,8 +32,7 @@ def convert_video_to_dumpscare(video, sensitivity):
     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     
-    # Define the codec and create a VideoWriter object
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Ensure this codec is supported
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
     out = cv2.VideoWriter('output_dumpscare.mp4', fourcc, fps, (width, height))
 
     while cap.isOpened():
@@ -34,30 +40,34 @@ def convert_video_to_dumpscare(video, sensitivity):
         if not ret:
             break
         
-        # Process each frame
-        prediction = process_frame(frame)  # You can modify frame based on prediction if needed
-        
-        # Write the original frame to the output video
-        out.write(frame)
+        modified_frame = process_frame(frame)  # Get modified frame
+        out.write(modified_frame)  # Write the modified frame to the output video
 
     cap.release()
     out.release()
-    
-    return 'output_dumpscare.mp4'  # Return the path to the saved video
 
+    # Add audio from the original video
+    original_video = VideoFileClip(video)
+    output_video = VideoFileClip('output_dumpscare.mp4')
+    final_video = output_video.set_audio(original_video.audio)
+    final_video.write_videofile('final_output_dumpscare.mp4', codec='libx264')
+
+    return 'final_output_dumpscare.mp4'
+
+# Gradio Interface
 def gradio_interface(video, sensitivity):
-    result = convert_video_to_dumpscare(video, sensitivity)
-    return result
+    output_video = convert_video_to_dumpscare(video, sensitivity)
+    return output_video
 
-# Create the Gradio interface
+# Create Gradio interface
 iface = gr.Interface(
     fn=gradio_interface,
     inputs=[
-        gr.Video(label="Import Video"),
-        gr.Slider(label="Sensitivity", minimum=0, maximum=100, step=1, value=50)
+        gr.Video(label="Input Video"),
+        gr.Slider(label="Sensitivity", minimum=0, maximum=100, step=1)
     ],
-    outputs=gr.File(label="Output Video")
+    outputs=gr.Video(label="Output Video")
 )
 
-# Launch the app
-iface.launch()
+if __name__ == "__main__":
+    iface.launch()