Update app.py

app.py

@@ -1,60 +1,58 @@
-import cv2
 import gradio as gr
+import cv2
 import numpy as np
-from keras.models import load_model
+import tensorflow as tf
 
-# Load your trained model
-model = load_model('model.h5')
+# Load your model
+model = tf.keras.models.load_model('model.h5')  # No path needed if it's in the same directory
 
+# Function to resize frames
+def resize_frame(frame, size=(64, 64)):
+    return cv2.resize(frame, size)
+
+# Function to process each frame
 def process_frame(frame):
-    img = cv2.resize(frame, (64, 64))  # Adjust size based on your model input
-    img = img.astype('float32') / 255.0
+    # Resize the frame
+    resized_frame = resize_frame(frame)
+
+    # Normalize and prepare the frame for the model
+    img = resized_frame.astype('float32') / 255.0
     img = np.expand_dims(img, axis=0)
+    img = img.reshape(1, -1)  # Flatten to match the input shape
 
     prediction = model.predict(img)
     return prediction[0][1]  # Assuming category 1 is jumpscare
 
+# Function to convert video to dumpscare
 def convert_video_to_dumpscare(video_path, sensitivity):
-    try:
-        cap = cv2.VideoCapture(video_path)
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    cap = cv2.VideoCapture(video_path)
+    jumpscare_frames = []
 
-        output_path = 'output_dumpscare.mp4'
-        out = cv2.VideoWriter(output_path, fourcc, fps, (int(cap.get(3)), int(cap.get(4))))
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        prediction = process_frame(frame)
+        if prediction > sensitivity:  # Adjust this threshold as needed
+            jumpscare_frames.append(frame)
 
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
+    cap.release()
 
-            if process_frame(frame) > sensitivity:
-                out.write(frame)
+    # Here you can save jumpscare frames or create a new video
+    return "Dumpscare video created successfully!"  # Change this as needed
 
-        cap.release()
-        out.release()
-        return output_path
+# Gradio interface
+def gradio_interface(video, sensitivity):
+    result = convert_video_to_dumpscare(video, sensitivity)
+    return result
 
-    except Exception as e:
-        return f"Error processing video: {str(e)}"
+with gr.Blocks() as demo:
+    gr.Markdown("## Video Dumpscare Generator")
+    video_input = gr.Video(label="Upload Video")
+    sensitivity_input = gr.Slider(minimum=0, maximum=1, label="Sensitivity", value=0.5)
+    submit_btn = gr.Button("Cut Video")
+    output_text = gr.Textbox(label="Output")
 
-# Gradio interface function
-def gradio_interface(video, sensitivity):
-    if video is None:
-        return "Please upload a video."
-    return convert_video_to_dumpscare(video, sensitivity)  # Use video directly
-
-# Set up Gradio app
-iface = gr.Interface(
-    fn=gradio_interface,
-    inputs=[
-        gr.Video(label="Import Video"),  # Removed type argument
-        gr.Slider(minimum=0.0, maximum=1.0, value=0.5, label="Sensitivity"),
-    ],
-    outputs=gr.Video(label="Output Dumpscare Video"),
-    title="Dumpscare Video Converter",
-    description="Upload a video, set sensitivity, and click 'Cut' to process the video.",
-)
-
-# Launch the interface
-iface.launch()
+    submit_btn.click(gradio_interface, inputs=[video_input, sensitivity_input], outputs=output_text)
+
+demo.launch()