Update app.py

app.py

@@ -5,144 +5,133 @@ from moviepy.editor import VideoFileClip, concatenate_videoclips
 import gradio as gr
 from tqdm import tqdm
 import os
+import logging
+from datetime import datetime
 
-# --- Model Loading ---
-# Ensure you have a 'model.h5' file in the same directory.
-# This model should be trained to output a value close to 1 for a jumpscare frame
-# and close to 0 for a non-jumpscare frame.
-MODEL_PATH = 'model.h5'
+# --- Configuration ---
+# These paths are relative to the root of your Hugging Face Space repo
+MODEL_PATH = 'model/model.h5' 
+OUTPUT_DIR = 'output/'
+os.makedirs(OUTPUT_DIR, exist_ok=True) # Create output dir if it doesn't exist
+
+# --- Setup Logging ---
+# This will help you debug issues in the Hugging Face logs
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- Load Model ---
 if not os.path.exists(MODEL_PATH):
-    raise FileNotFoundError(f"Model file not found at {MODEL_PATH}. Please ensure a trained model exists.")
+    error_msg = f"Model file not found at {MODEL_PATH}. Make sure you have uploaded your 'model.h5' to a 'model' directory in your Space."
+    logging.error(error_msg)
+    raise FileNotFoundError(error_msg)
+
 model = tf.keras.models.load_model(MODEL_PATH)
+logging.info("AI model loaded successfully.")
+
+# We need to know which index corresponds to 'jumpscare'.
+# Based on your training code, LabelBinarizer sorts alphabetically.
+# "jumpscare" comes before "normal", so it's likely index 0.
+# If it's the other way, change this to 1.
+JUMPSCARE_CLASS_INDEX = 0 
+logging.info(f"Assuming 'jumpscare' is class index {JUMPSCARE_CLASS_INDEX}. If predictions are wrong, change this value.")
 
 
 def predict_frame_is_jumpscare(frame, threshold):
-    """
-    Analyzes a single video frame and predicts if it's a jumpscare.
-    
-    Args:
-        frame (np.array): A single video frame in BGR format from OpenCV.
-        threshold (float): The sensitivity threshold (0.0 to 1.0) for the prediction.
-
-    Returns:
-        bool: True if the frame is predicted as a jumpscare, False otherwise.
-    """
-    # 1. Preprocess the frame for the model
-    # Convert BGR (OpenCV default) to RGB (model was likely trained on RGB)
+    """Analyzes a single video frame and predicts if it's a jumpscare."""
+    # Preprocess the frame for the model
     rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-    # Resize to the model's expected input size (e.g., 128x128)
     resized_frame = cv2.resize(rgb_frame, (128, 128))
-    # Normalize pixel values to be between 0 and 1
     img_array = np.array(resized_frame) / 255.0
-    # Add a batch dimension (model expects shape: 1, height, width, channels)
     img_array = np.expand_dims(img_array, axis=0)
-
-    # 2. Make a prediction
-    prediction = model.predict(img_array, verbose=0) # verbose=0 silences a lot of Keras logs
     
-    # 3. Return True/False based on the prediction and threshold
-    # We assume the model's output is a single value in prediction[0][0]
-    return prediction[0][0] > threshold
+    # Make a prediction. This will return a list of probabilities, e.g., [[0.9, 0.1]]
+    prediction = model.predict(img_array, verbose=0)
+    
+    #_CRITICAL_FIX_HERE_
+    # Instead of checking prediction[0][0], we get the probability for the specific "jumpscare" class.
+    jumpscare_probability = prediction[0][JUMPSCARE_CLASS_INDEX]
+    
+    return jumpscare_probability > threshold
 
 
 def generate_jumpscare_compilation(video_path, sensitivity, progress=gr.Progress()):
-    """
-    Analyzes a video, finds jumpscare segments, and creates a compilation.
-    
-    Args:
-        video_path (str): The file path to the input video.
-        sensitivity (int): An integer from 0 to 100 for detection sensitivity.
-        progress (gr.Progress): Gradio progress tracker.
-
-    Returns:
-        str or None: The file path to the output video, or None if no jumpscares are found.
-    """
-    # Convert sensitivity (0-100) to a model threshold (0.0-1.0)
-    threshold = sensitivity / 100.0
-    
-    # Use a lower FPS for analysis to speed things up. Jumpscares usually last
-    # for several frames, so we don't need to check every single one.
-    analysis_fps = 10 
-    
-    print("Loading video file...")
-    original_clip = VideoFileClip(video_path)
-    
-    jumpscare_segments = []
-    is_in_jumpscare_segment = False
-    segment_start_time = 0
-    
-    print(f"Analyzing video for jumpscares with threshold {threshold}...")
-    
-    # Use tqdm for a console progress bar and gr.Progress for the UI
-    total_frames = int(original_clip.duration * analysis_fps)
-    frame_iterator = original_clip.iter_frames(fps=analysis_fps)
-    
-    for i, frame in enumerate(tqdm(frame_iterator, total=total_frames, desc="Analyzing Frames")):
-        current_time = i / analysis_fps
-        progress(i / total_frames, desc=f"Analyzing... {int(current_time)}s / {int(original_clip.duration)}s")
+    """Analyzes a video, finds jumpscare segments, and creates a compilation."""
+    try:
+        # --- Initialization ---
+        threshold = sensitivity / 100.0
+        analysis_fps = 10
+        pre_scare_buffer = 1.0  # seconds to include before the scare
+        post_scare_buffer = 1.5 # seconds to include after the scare
+
+        logging.info(f"Starting analysis for video: {os.path.basename(video_path)}")
+        logging.info(f"Settings: Sensitivity={sensitivity}, Threshold={threshold}")
+
+        original_clip = VideoFileClip(video_path)
         
-        is_jumpscare = predict_frame_is_jumpscare(frame, threshold)
+        jumpscare_times = []
+        total_frames = int(original_clip.duration * analysis_fps)
         
-        # --- State machine to find continuous jumpscare segments ---
-        if is_jumpscare and not is_in_jumpscare_segment:
-            # Start of a new jumpscare segment
-            is_in_jumpscare_segment = True
-            segment_start_time = current_time
+        # --- Frame-by-Frame Analysis ---
+        progress(0, desc="Analyzing Frames...")
+        for i, frame in enumerate(tqdm(original_clip.iter_frames(fps=analysis_fps), total=total_frames, desc="Analyzing Frames")):
+            current_time = i / analysis_fps
+            progress(i / total_frames, desc=f"Analyzing... {int(current_time)}s / {int(original_clip.duration)}s")
+            
+            if predict_frame_is_jumpscare(frame, threshold):
+                jumpscare_times.append(current_time)
+                logging.info(f"Jumpscare detected at timestamp: {current_time:.2f}s")
+
+        # --- Segment Merging ---
+        if not jumpscare_times:
+            msg = "No jumpscares detected. Try a lower sensitivity value."
+            logging.warning(msg)
+            raise gr.Error(msg)
+
+        logging.info(f"Merging {len(jumpscare_times)} detected frames into continuous clips...")
+        merged_segments = []
+        if jumpscare_times:
+            start_time = end_time = jumpscare_times[0]
+            for t in jumpscare_times[1:]:
+                if t <= end_time + post_scare_buffer:
+                    end_time = t # Extend the segment
+                else:
+                    merged_segments.append((max(0, start_time - pre_scare_buffer), end_time + post_scare_buffer))
+                    start_time = end_time = t
+            merged_segments.append((max(0, start_time - pre_scare_buffer), end_time + post_scare_buffer))
+
+        # --- Video Creation ---
+        progress(0.9, desc="Stitching clips together...")
+        final_clips = [original_clip.subclip(start, min(end, original_clip.duration)) for start, end in merged_segments]
         
-        elif not is_jumpscare and is_in_jumpscare_segment:
-            # End of the current jumpscare segment
-            is_in_jumpscare_segment = False
-            # Add a small buffer to the end time to capture the full scare
-            segment_end_time = current_time + 0.5 
-            jumpscare_segments.append((segment_start_time, segment_end_time))
-
-    # If the video ends while in a jumpscare, close the last segment
-    if is_in_jumpscare_segment:
-        jumpscare_segments.append((segment_start_time, original_clip.duration))
-
-    # --- Create the final video ---
-    if not jumpscare_segments:
-        print("No jumpscares found.")
-        # We need to return a value that Gradio can handle.
-        # Returning None will cause an error. Instead, we can return a message.
-        # A better approach would be to update a gr.Text component, but for simplicity,
-        # we'll raise an error that Gradio can display.
-        raise gr.Error("No jumpscares were detected with the current sensitivity setting. Try a lower value.")
-
-    print(f"Found {len(jumpscare_segments)} jumpscare segments. Creating compilation...")
-    progress(0.9, desc="Stitching clips together...")
-
-    # Create subclips from the original video using the detected timestamps
-    final_clips = [original_clip.subclip(start, end) for start, end in jumpscare_segments]
-    
-    # Concatenate all the jumpscare clips into one video
-    final_video = concatenate_videoclips(final_clips)
-    
-    output_path = "fnaf_jumpscare_compilation.mp4"
-    # Write the final video file, including audio
-    final_video.write_videofile(output_path, codec="libx264", audio_codec="aac", temp_audiofile='temp-audio.m4a', remove_temp=True)
-    
-    # Close the clips to free up resources
-    original_clip.close()
-    for clip in final_clips:
-        clip.close()
-    
-    print(f"Compilation saved to {output_path}")
-    return output_path
+        final_video = concatenate_videoclips(final_clips, method="compose")
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_filename = f"jumpscare_compilation_{timestamp}.mp4"
+        output_path = os.path.join(OUTPUT_DIR, output_filename)
+        
+        logging.info(f"Writing final video to {output_path}")
+        final_video.write_videofile(output_path, codec="libx264", audio_codec="aac")
+        
+        original_clip.close()
+        final_video.close()
+        
+        logging.info("Process completed successfully.")
+        return output_path
 
+    except Exception as e:
+        logging.error(f"An error occurred: {e}", exc_info=True)
+        raise gr.Error(f"An unexpected error occurred. Check the logs for details. Error: {e}")
 
 # --- Gradio Interface ---
-# Create a Gradio interface for the function
 iface = gr.Interface(
     fn=generate_jumpscare_compilation,
     inputs=[
         gr.Video(label="Upload FNAF Video"),
-        gr.Slider(minimum=1, maximum=100, step=1, value=70, label="Detection Sensitivity", 
-                  info="Higher values mean the AI needs to be more certain it's a jumpscare. Lower values will detect more, but might have false positives.")
+        gr.Slider(minimum=1, maximum=99, step=1, value=80, label="Detection Sensitivity", 
+                  info="Higher values require more certainty from the AI. Lower values find more, but might have errors.")
     ],
     outputs=gr.Video(label="Jumpscare Compilation"),
-    title="AI FNAF Jumpscare Dump Generator",
-    description="Upload a video, and this tool will use an AI model to find all the jumpscares and compile them into a single video. This requires a `model.h5` file.",
+    title="🤖 AI FNAF Jumpscare Dump Generator",
+    description="Upload a video, and the AI will find all jumpscares and compile them. This app runs on a trained model.",
     allow_flagging="never"
 )