Update app.py

app.py

@@ -1,83 +1,66 @@
+import gradio as gr
 import cv2
 import numpy as np
-import gradio as gr
-from moviepy.editor import VideoFileClip
-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_difference, brightness_value):
+    # Read the video
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return "Error: Unable to open video."
 
-# 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))
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
     
-    # 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))
+    # Create a VideoWriter object to write the output video
+    output_path = "output_video.mp4"
+    out = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (frame_width, frame_height))
 
+    # Initialize a list to store frames for frame shifting
     frames = []
-
-    # Read all frames
+    
     while True:
         ret, frame = cap.read()
         if not ret:
             break
-        frames.append(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]
-        
-        # Overlay frames with 50/50 opacity
-        overlayed_frame = overlay_frames(prev_frame, current_frame, opacity=0.5)
-        
-        # Adjust brightness
-        bright_frame = adjust_brightness(overlayed_frame, brightness_value)
-        
-        # Write the processed frame
-        out.write(bright_frame)
+        # Invert the pixel values of the frame
+        inverted_frame = cv2.bitwise_not(frame)
+        frames.append((frame, inverted_frame))
 
     cap.release()
-    out.release()
 
-    return output_path
+    # Process video by applying frame difference and overlaying
+    num_frames = len(frames)
+    for i in range(num_frames):
+        # Get the original and shifted frames
+        orig_frame = frames[i][0]
+        shifted_index = (i + frame_difference) % num_frames
+        shifted_frame = frames[shifted_index][1]  # Use the inverted frame of shifted frame
 
-# Gradio Interface
-def video_motion_amplify(video, frame_diff_value, brightness_value):
-    # Process the video
-    output_video_path = process_video(video, frame_diff_value, brightness_value)
+        # Overlay the frames with 50% opacity
+        overlay_frame = cv2.addWeighted(orig_frame, 0.5, shifted_frame, 0.5, 0)
+
+        # Increase the brightness
+        overlay_frame = np.clip(overlay_frame * brightness_value, 0, 255).astype(np.uint8)
+
+        # Write the resulting frame to the output video
+        out.write(overlay_frame)
+
+    out.release()
     
-    # Return the output video path
-    return output_video_path
+    return output_path
 
-# Gradio Interface with updated components
-interface = gr.Interface(
-    fn=video_motion_amplify,
+# Gradio Interface
+iface = gr.Interface(
+    fn=process_video,
     inputs=[
-        gr.Video(label="Input Video"),
-        gr.Slider(minimum=0, maximum=50, step=1, label="Frame Difference Value"),
-        gr.Slider(minimum=-100, maximum=100, step=1, label="Brightness Value"),
+        gr.Video(label="Input Video"),  # Video input
+        gr.Slider(0, 50, value=1, label="Frame Difference"),  # Frame difference input
+        gr.Slider(0.0, 1.0, value=1.0, label="Brightness Adjustment"),  # Brightness adjustment input
     ],
-    outputs=gr.Video(label="Output Video"),
-    title="Motion Amplification using Frame Difference",
-    description="This app amplifies motion in a video by overlaying frames based on frame difference and adjusting brightness."
+    outputs=gr.Video(label="Output Video"),  # Video output
+    title="Motion Amplification with Frame Difference"
 )
 
-# Launch the interface
-interface.launch()
+iface.launch()