Add updated files from main repo

FILM.py

@@ -19,15 +19,20 @@ Adjust 'fps' and 'num_recursions' parameters as needed
 """
 import os
 import tensorflow as tf
-import tensorflow_hub as hub
 import cv2
 import numpy as np
 from glob import glob
 from datetime import datetime
 import time
+import sys
 
-# Load the FILM model
-model = hub.load('https://tfhub.dev/google/film/1')
+def load_film_model():
+    """Loads the FILM model only when called explicitly."""
+    print("Loading FILM model...")
+    import tensorflow_hub as hub
+    model = hub.load('https://tfhub.dev/google/film/1')
+    print("FILM model loaded successfully.")
+    return model
 
 def preprocess_image(image_path):
     """Load and preprocess an image for the FILM model."""
@@ -38,7 +43,7 @@ def preprocess_image(image_path):
 
 class Interpolator:
     """Wrapper class for the FILM model to perform frame interpolation."""
-    def __init__(self, align=64):
+    def __init__(self, model, align=64):
         self._model = model
         self._align = align
 
@@ -53,33 +58,43 @@ def _recursive_generator(frame1, frame2, num_recursions, interpolator):
     if num_recursions == 0:
         yield frame1 # exit condition
     else:
-        dt_value = np.full(shape=(1,), fill_value=0.5, dtype=np.float32)
+        time = np.full(shape=(1,), fill_value=0.5, dtype=np.float32)
         mid_frame = interpolator(
-            np.expand_dims(frame1, axis=0), np.expand_dims(frame2, axis=0), dt_value)[0]
+            np.expand_dims(frame1, axis=0), np.expand_dims(frame2, axis=0), time)[0]
         yield from _recursive_generator(frame1, mid_frame, num_recursions - 1, interpolator) # 1st half
         yield from _recursive_generator(mid_frame, frame2, num_recursions - 1, interpolator) # 2nd half
 
 def interpolate_recursively(frames, num_recursions, interpolator):
     """Apply recursive interpolation to a list of input frames."""
     n = len(frames)
-    if n == 0:
-        raise ValueError("No input frames found.")
     for i in range(1, n):
         yield from _recursive_generator(frames[i - 1], frames[i], num_recursions, interpolator)
     yield frames[-1]
 
 def process_keyframes(input_folder, output_folder, fps=30, num_recursions=3):
     """Process keyframes to create an interpolated video, using functions above"""
+    # Check if input folder exists
+    if not os.path.exists(input_folder):
+        print(f"Error: Input folder '{input_folder}' does not exist.")
+        return False
+    
+    # Check if input folder contains PNG files
     keyframes = sorted(glob(os.path.join(input_folder, '*.png')))
     if not keyframes:
-        raise ValueError(f"No PNG keyframes found in {input_folder}")
-
-    # Ensure the output folder exists
-    os.makedirs(output_folder, exist_ok=True)
+        print(f"Error: No PNG files found in '{input_folder}'.")
+        return False
+        
+    # Create output folder if it doesn't exist
+    if not os.path.exists(output_folder):
+        print(f"Creating output folder: '{output_folder}'")
+        os.makedirs(output_folder)
+    
+    # Only load the FILM model when needed
+    model = load_film_model()
     
     frames = [preprocess_image(frame).numpy() for frame in keyframes]
     
-    interpolator = Interpolator()
+    interpolator = Interpolator(model)
     interpolated_frames = list(interpolate_recursively(frames, num_recursions, interpolator))
     
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") # For unique output..
@@ -97,14 +112,25 @@ def process_keyframes(input_folder, output_folder, fps=30, num_recursions=3):
     
     out.release()
     print(f'Video created with {len(interpolated_frames)} frames: {output_video}')
+    return True
 
-# Usage
-# input_folder = 'sample_keyframes'
-# output_folder = 'FILM_Results'
-
-# start_time = time.time()
-# process_keyframes(input_folder, output_folder, fps=30, num_recursions=3)
-# end_time = time.time()
-
-# total_execution_time = end_time - start_time
-# print(f'Total script execution time: {total_execution_time:.2f} seconds')
+# Main execution
+if __name__ == "__main__":
+    # Usage
+    input_folder = 'results/Trump_Biden_New'
+    output_folder = 'FILM_Results'
+    
+    print(f"Starting FILM video interpolation process...")
+    print(f"Input folder: {input_folder}")
+    print(f"Output folder: {output_folder}")
+    
+    start_time = time.time()
+    success = process_keyframes(input_folder, output_folder, fps=30, num_recursions=3)
+    end_time = time.time()
+    
+    if success:
+        total_execution_time = end_time - start_time
+        print(f'Total script execution time: {total_execution_time:.2f} seconds')
+    else:
+        print("Interpolation process failed. Please check the error messages above.")
+        sys.exit(1)

Image-Morpher/main.py

@@ -11,11 +11,11 @@ import time
 import logging
 import gc
 
-os.environ["HF_HOME"] = "/app/hf_cache"
-os.environ["DIFFUSERS_CACHE"] = "/app/hf_cache"
-os.environ["TORCH_HOME"] = "/app/torch_cache"
-os.environ["TRANSFORMERS_CACHE"] = "/app/hf_cache"
-os.environ["HF_DATASETS_CACHE"] = "/app/hf_cache/datasets"
+# os.environ["HF_HOME"] = "/app/hf_cache"
+# os.environ["DIFFUSERS_CACHE"] = "/app/hf_cache"
+# os.environ["TORCH_HOME"] = "/app/torch_cache"
+# os.environ["TRANSFORMERS_CACHE"] = "/app/hf_cache"
+# os.environ["HF_DATASETS_CACHE"] = "/app/hf_cache/datasets"
 
 logs_folder = "logs"
 os.makedirs(logs_folder, exist_ok=True)
@@ -102,8 +102,8 @@ args = parser.parse_args()
 os.makedirs(args.output_path, exist_ok=True)
 
 # Clear any existing PyTorch GPU allocations
-torch.cuda.empty_cache()
-gc.collect()
+# torch.cuda.empty_cache()
+# gc.collect()
 
 # Set environment variable for memory allocation
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"

app.py

@@ -1,6 +1,3 @@
-"""
-Cleaned up version, Close-to-Final UI features and functionality logic. 
-"""
 import os
 import sys
 import subprocess
@@ -11,8 +8,6 @@ from io import BytesIO
 import streamlit as st
 from PIL import Image
 
-print(subprocess.check_output(["nvidia-smi"]).decode())
-
 # Set Streamlit page configuration (centered content via CSS)
 st.set_page_config(
     page_title="Metamorph: DiffMorpher + LCM-LoRA + FILM",
@@ -21,14 +16,26 @@ st.set_page_config(
 )
 
 def save_uploaded_file(uploaded_file, dst_path):
+    """Save an uploaded file to a destination path."""
     with open(dst_path, "wb") as f:
         f.write(uploaded_file.getbuffer())
 
 def get_img_as_base64(img):
+    """Convert PIL Image to base64 for embedding in HTML."""
     buffered = BytesIO()
     img.save(buffered, format="PNG")
     return base64.b64encode(buffered.getvalue()).decode("utf-8")
 
+def ensure_scripts_exist():
+    """Check if the required script files exist."""
+    required_scripts = ["run_morphing.py", "FILM.py"]
+    missing_scripts = [script for script in required_scripts if not os.path.exists(script)]
+    
+    if missing_scripts:
+        error_msg = f"Missing required script(s): {', '.join(missing_scripts)}"
+        return False, error_msg
+    return True, ""
+
 def main():
     # ---------------- CUSTOM CSS FOR A PROFESSIONAL, DARK THEME ----------------
     st.markdown(
@@ -118,6 +125,13 @@ def main():
         unsafe_allow_html=True
     )
 
+    # Check if required scripts exist
+    scripts_exist, error_msg = ensure_scripts_exist()
+    if not scripts_exist:
+        st.error(error_msg)
+        st.error("Please make sure all required scripts are in the same directory as this Streamlit app.")
+        return
+
     # ---------------- HEADER & LOGO ----------------
     logo_path = "metamorphLogo_nobg.png"
     if os.path.exists(logo_path):
@@ -132,8 +146,8 @@ def main():
                 """,
                 unsafe_allow_html=True
             )
-        except Exception:
-            pass
+        except Exception as e:
+            st.warning(f"Logo could not be loaded: {e}")
 
     st.markdown("<h1 class='header-title'>Metamorph Web App</h1>", unsafe_allow_html=True)
     st.markdown(
@@ -155,14 +169,12 @@ def main():
         st.markdown("#### Image A")
         uploaded_image_A = st.file_uploader("Upload your first image", type=["png", "jpg", "jpeg"], key="imgA")
         if uploaded_image_A is not None:
-            # use_container_width instead of use_column_width
             st.image(uploaded_image_A, caption="Preview - Image A", use_container_width=True)
         prompt_A = st.text_input("Prompt for Image A (optional)", value="", key="promptA")
     with col_imgB:
         st.markdown("#### Image B")
         uploaded_image_B = st.file_uploader("Upload your second image", type=["png", "jpg", "jpeg"], key="imgB")
         if uploaded_image_B is not None:
-            # use_container_width instead of use_column_width
             st.image(uploaded_image_B, caption="Preview - Image B", use_container_width=True)
         prompt_B = st.text_input("Prompt for Image B (optional)", value="", key="promptB")
 
@@ -198,12 +210,12 @@ def main():
     # Determine preset defaults based on selection
     if preset_option.startswith("Maximum quality"):
         # "Maximum quality, highest inference time 🏆"
-        preset_model = "Base Stable Diffusion V2-1 (No LCM-LoRA support)"
+        preset_model = "Base Stable Diffusion V2-1"
         preset_film = True
         preset_lcm = False
     elif preset_option.startswith("Medium quality"):
         # "Medium quality, medium inference time ⚖️"
-        preset_model = "Base Stable Diffusion V2-1 (No LCM-LoRA support)"
+        preset_model = "Base Stable Diffusion V2-1"
         preset_film = False
         preset_lcm = False
     elif preset_option.startswith("Low quality"):
@@ -230,7 +242,7 @@ def main():
         options_list = [
             "Base Stable Diffusion V1-5",
             "Dreamshaper-7 (fine-tuned SD V1-5)",
-            "Base Stable Diffusion V2-1 (No LCM-LoRA support)"
+            "Base Stable Diffusion V2-1"
         ]
         default_model = preset_model if preset_model is not None else "Base Stable Diffusion V1-5"
         default_index = options_list.index(default_model)
@@ -241,23 +253,28 @@ def main():
         with col_left:
             st.markdown("##### Keyframe Generator Parameters")
             num_frames = st.number_input("Number of keyframes (2–50)", min_value=2, max_value=50, value=16)
-            # Removed disabling for SD V2-1 so that LCM-LoRA can be enabled for it as well.
+            # Note: LCM compatibility check updated
             lcm_default = preset_lcm if preset_lcm is not None else False
+    
             enable_lcm_lora = st.checkbox(
-                "Enable LCM-LoRA (accelerated inference, slight decrease in quality)",
-                value=lcm_default
+                "Enable LCM-LoRA",
+                value=lcm_default,
+                help="Accelerates inference with slight quality decrease"
             )
-            use_adain = st.checkbox("Use AdaIN", value=True)
-            use_reschedule = st.checkbox("Use reschedule sampling", value=True)
+            
+            use_adain = st.checkbox("Use AdaIN", value=True, help="Adaptive Instance Normalization for improved generation")
+            use_reschedule = st.checkbox("Use reschedule sampling", value=True, help="Better sampling strategy")
             keyframe_duration = st.number_input("Keyframe Duration (seconds, only if not using FILM)", min_value=0.01, max_value=5.0, value=0.1, step=0.01)
+        
         # Right Column: Inter-frame Interpolator Parameters (FILM)
         with col_right:
             st.markdown("<div class='right-column-divider'>", unsafe_allow_html=True)
             st.markdown("##### Inter-frame Interpolator Parameters")
             default_use_film = preset_film if preset_film is not None else True
-            use_film = st.checkbox("Use FILM interpolation", value=default_use_film)
-            film_fps = st.number_input("FILM FPS (1–120)", min_value=1, max_value=120, value=30)
-            film_recursions = st.number_input("FILM recursion passes (1–6)", min_value=1, max_value=6, value=3)
+            use_film = st.checkbox("Use FILM interpolation", value=default_use_film, help="Frame Interpolation for Large Motion - creates smooth transitions")
+            film_fps = st.number_input("FILM FPS (1–120)", min_value=1, max_value=120, value=30, help="Output video frames per second")
+            film_recursions = st.number_input("FILM recursion passes (1–6)", min_value=1, max_value=6, value=3, 
+                                             help="Higher values create more intermediate frames (smoother but slower)")
             st.markdown("</div>", unsafe_allow_html=True)
 
     st.markdown("<hr>", unsafe_allow_html=True)
@@ -265,98 +282,124 @@ def main():
     # ---------------- SECTION 3: EXECUTE MORPH PIPELINE ----------------
     st.subheader("3. Generate Morphing Video")
     st.markdown("Once satisfied with your inputs, click below to start the process.")
+    
     if st.button("Run Morphing Pipeline", key="run_pipeline"):
+        # Validate inputs
         if not (uploaded_image_A and uploaded_image_B):
             st.error("Please upload both images before running the morphing pipeline.")
             return
 
-        # Check that the pipeline script exists
-        if not os.path.exists("run_morphing.py"):
-            st.error("Pipeline script 'run_morphing.py' not found in the current directory.")
-            return
-
+        # Create a temporary directory for processing
         with tempfile.TemporaryDirectory() as temp_dir:
             try:
+                # Save uploaded images to temp directory
                 imgA_path = os.path.join(temp_dir, "imageA.png")
                 imgB_path = os.path.join(temp_dir, "imageB.png")
                 save_uploaded_file(uploaded_image_A, imgA_path)
                 save_uploaded_file(uploaded_image_B, imgB_path)
-            except Exception as e:
-                st.error(f"Error saving uploaded images: {e}")
-                return
-
-            output_dir = os.path.join(temp_dir, "morph_results")
-            film_output_dir = os.path.join(temp_dir, "film_output")
-            os.makedirs(output_dir, exist_ok=True)
-            os.makedirs(film_output_dir, exist_ok=True)
-
-            # Convert seconds to milliseconds
-            duration_ms = int(keyframe_duration * 1000)
-
-            # Build the CLI command
-            # Here you can add a mapping if you want to convert display names to actual model identifiers.
-            # For this example, we assume model_option is already a valid model identifier,
-            # or use a conditional similar to before.
-            actual_model_path = (
-                "lykon/dreamshaper-7" if model_option == "Dreamshaper-7 (fine-tuned SD V1-5)" 
-                else "sd-legacy/stable-diffusion-v1-5" if model_option == "Base Stable Diffusion V1-5" 
-                else "stabilityai/stable-diffusion-2-1-base"
-            )
-
-            cmd = [
-                sys.executable, "run_morphing.py",
-                "--model_path", actual_model_path,
-                "--image_path_0", imgA_path,
-                "--image_path_1", imgB_path,
-                "--prompt_0", prompt_A,
-                "--prompt_1", prompt_B,
-                "--output_path", output_dir,
-                "--film_output_folder", film_output_dir,
-                "--num_frames", str(num_frames),
-                "--duration", str(duration_ms)
-            ]
-            if enable_lcm_lora:
-                cmd.append("--use_lcm")
-            if use_adain:
-                cmd.append("--use_adain")
-            if use_reschedule:
-                cmd.append("--use_reschedule")
-            if use_film:
-                cmd.append("--use_film")
-            cmd.extend(["--film_fps", str(film_fps)])
-            cmd.extend(["--film_num_recursions", str(film_recursions)])
-
-            st.info("Initializing pipeline. Please wait...")
-            try:
-                subprocess.run(cmd, check=True)
-            except subprocess.CalledProcessError as e:
-                st.error(f"Error running pipeline: {e}")
-                return
-
-            # Check for output file in FILM folder first; if not, then in output_dir
-            possible_outputs = [f for f in os.listdir(film_output_dir) if f.endswith(".mp4")]
-            if not possible_outputs:
-                possible_outputs = [f for f in os.listdir(output_dir) if f.endswith(".mp4")]
-
-            if possible_outputs:
-                final_video_path = os.path.join(
-                    film_output_dir if os.listdir(film_output_dir) else output_dir,
-                    possible_outputs[0]
+                
+                # Create output directories
+                output_dir = os.path.join(temp_dir, "morph_results")
+                film_output_dir = os.path.join(temp_dir, "film_output")
+                os.makedirs(output_dir, exist_ok=True)
+                os.makedirs(film_output_dir, exist_ok=True)
+                
+                # Convert seconds to milliseconds for duration
+                duration_ms = int(keyframe_duration * 1000)
+                
+                # Map UI model names to actual model paths
+                actual_model_path = (
+                    "lykon/dreamshaper-7" if model_option == "Dreamshaper-7 (fine-tuned SD V1-5)" 
+                    else "stabilityai/stable-diffusion-2-1-base" if model_option == "Base Stable Diffusion V2-1"
+                    else "sd-legacy/stable-diffusion-v1-5"  # Default to SD V1-5
                 )
-                st.success("Morphing complete! 🎉")
-                st.video(final_video_path)
-                try:
-                    with open(final_video_path, "rb") as f:
-                        st.download_button(
-                            "Download Result Video",
-                            data=f.read(),
-                            file_name="morph_result.mp4",
-                            mime="video/mp4"
-                        )
-                except Exception as e:
-                    st.error(f"Error reading output video: {e}")
-            else:
-                st.warning("No .mp4 output found. Check logs for details.")
+                
+                # Build the command for run_morphing.py
+                cmd = [
+                    sys.executable, "run_morphing.py",
+                    "--model_path", actual_model_path,
+                    "--image_path_0", imgA_path,
+                    "--image_path_1", imgB_path,
+                    "--prompt_0", prompt_A,
+                    "--prompt_1", prompt_B,
+                    "--output_path", output_dir,
+                    "--film_output_folder", film_output_dir,
+                    "--num_frames", str(num_frames),
+                    "--duration", str(duration_ms)
+                ]
+                
+                # Add optional flags
+                if enable_lcm_lora:
+                    cmd.append("--use_lcm")
+                if use_adain:
+                    cmd.append("--use_adain")
+                if use_reschedule:
+                    cmd.append("--use_reschedule")
+                if use_film:
+                    cmd.append("--use_film")
+                
+                # Add film parameters
+                cmd.extend(["--film_fps", str(film_fps)])
+                cmd.extend(["--film_num_recursions", str(film_recursions)])
+                
+                # Run the pipeline
+                st.info("Initializing pipeline. This may take a few minutes...")
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                # Update progress status
+                for i in range(1, 11):
+                    status_text.text(f"Step {i}/10: {'Preparing images' if i <= 2 else 'Generating keyframes' if i <= 6 else 'Interpolating frames' if i <= 9 else 'Finalizing video'}")
+                    progress_bar.progress(i * 10)
+                    
+                    if i == 3:  # Start actual processing
+                        try:
+                            subprocess.run(cmd, check=True)
+                        except subprocess.CalledProcessError as e:
+                            st.error(f"Error running morphing pipeline: {e}")
+                            return
+                        break
+                
+                # Set progress to 100% when done
+                progress_bar.progress(100)
+                status_text.text("Processing complete!")
+                
+                # Check for output video
+                video_found = False
+                
+                # First check FILM output directory if FILM was used
+                if use_film:
+                    possible_outputs = [f for f in os.listdir(film_output_dir) if f.endswith(".mp4")]
+                    if possible_outputs:
+                        final_video_path = os.path.join(film_output_dir, possible_outputs[0])
+                        video_found = True
+                
+                # If not found in FILM dir, check regular output dir
+                if not video_found:
+                    possible_outputs = [f for f in os.listdir(output_dir) if f.endswith(".mp4")]
+                    if possible_outputs:
+                        final_video_path = os.path.join(output_dir, possible_outputs[0])
+                        video_found = True
+                
+                if video_found:
+                    st.success("Morphing complete! 🎉")
+                    st.video(final_video_path)
+                    try:
+                        with open(final_video_path, "rb") as f:
+                            video_bytes = f.read()
+                            st.download_button(
+                                "Download Result Video",
+                                data=video_bytes,
+                                file_name="metamorph_result.mp4",
+                                mime="video/mp4"
+                            )
+                    except Exception as e:
+                        st.error(f"Error preparing video for download: {e}")
+                else:
+                    st.warning("No output video was generated. Check logs for details.")
+                    
+            except Exception as e:
+                st.error(f"An error occurred during processing: {e}")
 
 if __name__ == "__main__":
     main()

run_morphing.py

@@ -3,11 +3,10 @@ import sys
 import time
 import subprocess
 import argparse
-
-from FILM import process_keyframes
-
 import multiprocessing as mp
-mp.set_start_method("spawn", force=True)
+
+# Don't import FILM module globally - we'll import the specific function when needed
+mp.set_start_method("spawn", force=True) # see if buggy
 
 def parse_arguments():
     parser = argparse.ArgumentParser(
@@ -98,10 +97,10 @@ def parse_arguments():
     )
     parser.add_argument(
         "--film_output_folder", type=str, default="./FILM_Results",
-        help="Folder where FILM’s final interpolated video is saved (default: %(default)s)"
+        help="Folder where FILM's final interpolated video is saved (default: %(default)s)"
     )
     parser.add_argument(
-        "--film_fps", type=int, default=40,
+        "--film_fps", type=int, default=30,
         help="FPS for the final video - 'Pseudo-Playback-Speed', since total frames are same (default: %(default)s)"
     )
     parser.add_argument(
@@ -191,6 +190,22 @@ def create_simple_video_from_keyframes(keyframes_folder, output_folder, fps=40):
     out.release()
     print(f"[INFO] Basic morphing video saved at: {out_video_path}")
 
+def run_film_interpolation(input_folder, output_folder, fps, num_recursions):
+    """
+    Import and run FILM processing only when needed.
+    This function is called only if args.use_film is True.
+    """
+    # Import the process_keyframes function from FILM.py only when needed
+    from FILM import process_keyframes
+    
+    # Now run the FILM processing
+    return process_keyframes(
+        input_folder=input_folder,
+        output_folder=output_folder,
+        fps=fps,
+        num_recursions=num_recursions
+    )
+
 def main():
     args = parse_arguments()
     overall_start_time = time.time()
@@ -199,22 +214,27 @@ def main():
     run_diffmorpher(args)
 
     # 2) Determine the folder containing the keyframes
-    # If user didn’t explicitly give `--film_input_folder`, use `args.output_path`
+    # If user didn't explicitly give `--film_input_folder`, use `args.output_path`
     keyframes_folder = args.film_input_folder if args.film_input_folder else args.output_path
 
     # 3) If user wants to use FILM, perform high-quality interpolation on the keyframes
     if args.use_film:
         print("[INFO] Running FILM to enhance the keyframes...")
         start_film_time = time.time()
-        # from FILM.py:
-        process_keyframes(
+        
+        # Call the wrapper function that imports FILM only when needed
+        success = run_film_interpolation(
             input_folder=keyframes_folder,
             output_folder=args.film_output_folder,
             fps=args.film_fps,
             num_recursions=args.film_num_recursions
         )
+        
         end_film_time = time.time()
-        print(f"[INFO] FILM interpolation completed in {end_film_time - start_film_time:.2f} seconds.")
+        if success:
+            print(f"[INFO] FILM interpolation completed in {end_film_time - start_film_time:.2f} seconds.")
+        else:
+            print("[ERROR] FILM interpolation failed. See above for details.")
     else:
         # 4) If user does NOT want FILM, create a simple .mp4 from the keyframes
         print("[INFO] Skipping FILM interpolation. Creating a basic video from DiffMorpher keyframes...")