Update app.py

app.py

@@ -1,69 +1,83 @@
-import gradio as gr
 import cv2
 import numpy as np
+import gradio as gr
 from moviepy.editor import VideoFileClip
-from moviepy.video.fx.all import lum_contrast
+import tempfile
+
+# Helper function to adjust brightness
+def adjust_brightness(frame, brightness_value):
+    return cv2.convertScaleAbs(frame, alpha=1, beta=brightness_value)
 
-def process_video(video_path, frame_diff_value, brightness_value):
-    # Load the video using OpenCV
-    cap = cv2.VideoCapture(video_path)
+# Helper function to overlay frames with opacity
+def overlay_frames(frame1, frame2, opacity=0.5):
+    return cv2.addWeighted(frame1, opacity, frame2, 1 - opacity, 0)
+
+# Main function to process video
+def process_video(video, frame_diff, brightness_value):
+    # Read the video file
+    input_path = video.name
+    cap = cv2.VideoCapture(input_path)
     
     # Get video properties
+    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    fps = int(cap.get(cv2.CAP_PROP_FPS))
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    
-    # Create a VideoWriter object for the output
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Codec for MP4
-    out_path = "output_video.mp4"
-    out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
     
+    # Create a temporary output file
+    output_path = tempfile.mktemp(suffix=".mp4")
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+
     frames = []
 
-    # Read all frames into memory
+    # Read all frames
     while True:
         ret, frame = cap.read()
         if not ret:
             break
         frames.append(frame)
-    
-    # Process frames with frame difference
-    V3_frames = []
-    for f in range(frame_diff_value, total_frames - frame_diff_value):
-        # Original frame and its previous frame
+
+    # Process the frames
+    for f in range(frame_diff, frame_count - frame_diff):
+        # Invert pixels for frame f - frame_diff
+        prev_frame = 255 - frames[f - frame_diff]
         current_frame = frames[f]
-        previous_frame = frames[f - frame_diff_value]
         
-        # Invert the previous frame
-        previous_frame_inverted = 255 - previous_frame
+        # Overlay frames with 50/50 opacity
+        overlayed_frame = overlay_frames(prev_frame, current_frame, opacity=0.5)
         
-        # Blend current frame with inverted previous frame (50/50 opacity)
-        blended_frame = cv2.addWeighted(current_frame, 0.5, previous_frame_inverted, 0.5, 0)
+        # Adjust brightness
+        bright_frame = adjust_brightness(overlayed_frame, brightness_value)
         
-        # Append blended frame to new video frames list
-        V3_frames.append(blended_frame)
+        # Write the processed frame
+        out.write(bright_frame)
 
-    # Adjust brightness using moviepy for the entire video
-    V3_clip = VideoFileClip(out_path)
-    V3_clip = lum_contrast(V3_clip, contrast=1, luminosity=brightness_value)  # Adjust brightness
-    
-    # Save the modified video
-    V3_clip.write_videofile("output_with_brightness.mp4", codec='libx264')
-
-    # Release the video writer and capture
     cap.release()
     out.release()
 
-    return "output_with_brightness.mp4"
+    return output_path
 
 # Gradio interface
-inputs = [
-    gr.Video(label="Upload Video"), 
-    gr.Slider(0, 50, label="Frame Difference", value=10), 
-    gr.Slider(0, 100, label="Brightness", value=50)
-]
+def video_motion_amplify(video, frame_diff_value, brightness_value):
+    # Process the video
+    output_video_path = process_video(video, frame_diff_value, brightness_value)
+    
+    # Return the output video path
+    return output_video_path
 
-outputs = gr.Video(label="Processed Video")
+# Gradio Interface
+interface = gr.Interface(
+    fn=video_motion_amplify,
+    inputs=[
+        gr.inputs.Video(type="file"),
+        gr.inputs.Slider(minimum=0, maximum=50, step=1, label="Frame Difference Value"),
+        gr.inputs.Slider(minimum=-100, maximum=100, step=1, label="Brightness Value"),
+    ],
+    outputs=gr.outputs.Video(type="file"),
+    title="Motion Amplification using Frame Difference",
+    description="This app amplifies motion in a video by overlaying frames based on frame difference and adjusting brightness."
+)
 
-gr.Interface(fn=process_video, inputs=inputs, outputs=outputs, title="Motion Amplification Using Frame Difference").launch()
+# Launch the interface
+interface.launch()