Update app.py

app.py

@@ -1,108 +1,109 @@
-import gradio as gr
-import cv2
-import numpy as np
-from PIL import Image
+import os
 import subprocess
 import sys
 
-def install_dependencies():
+def install_requirements():
     try:
-        # Install OpenCV
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "opencv-python"])
-        # Install facemorpher
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "facemorpher"])
-        # Install Pillow if needed
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "Pillow"])
-        print("All dependencies installed successfully!")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "opencv-python", "numpy", "scipy", "matplotlib"])
+        print("Successfully installed OpenCV, numpy, scipy, and matplotlib.")
+        
+        try:
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "facemorpher"])
+            print("Successfully installed facemorpher.")
+        except subprocess.CalledProcessError as e:
+            print("Failed to install facemorpher:", e)
+            print("Attempting fallback: manually installing stasm and docopt.")
+            try:
+                subprocess.check_call([sys.executable, "-m", "pip", "install", "stasm", "docopt"])
+                print("Successfully installed stasm and docopt.")
+            except subprocess.CalledProcessError as e:
+                print("Fallback installation failed:", e)
+                print("Proceeding without facemorpher.")
+
     except subprocess.CalledProcessError as e:
-        print(f"Error occurred while installing dependencies: {e}")
+        print("Installation of core dependencies failed:", e)
 
-# Call the function to install dependencies
-install_dependencies()
+def create_and_run_main_py():
+    main_code = '''
+import os
+import cv2
+import numpy as np
+import time
 
-# Now you can import facemorpher and proceed with your code
-from facemorpher import FaceMorpher
+# Fallback implementation for morph_faces if facemorpher is not available
+try:
+    from facemorpher import morpher
+    use_facemorpher = True
+except ImportError:
+    print("facemorpher not found. Using fallback morphing.")
+    use_facemorpher = False
 
-# Your face morphing code goes here...
+    def morph_faces(img1_path, img2_path, alpha=0.5):
+        img1 = cv2.imread(img1_path)
+        img2 = cv2.imread(img2_path)
 
+        if img1 is None or img2 is None:
+            raise ValueError("Error reading input images.")
 
+        img1 = cv2.resize(img1, (img2.shape[1], img2.shape[0]))
+        return cv2.addWeighted(img1, alpha, img2, 1 - alpha, 0)
 
-# Load images function
-def load_image(path):
-    return cv2.imread(path)
+def get_phoneme_image(phoneme):
+    phoneme_dir = "phoneme_images"
+    phoneme_map = {
+        "AA": "aa.jpg",
+        "EE": "ee.jpg",
+        "OO": "oo.jpg",
+        "MM": "mm.jpg",
+        "WW": "ww.jpg",
+        "NA": "na.jpg"
+    }
 
-# Generate lipsync frame based on interpolation slider
-def generate_lipsync_frame(mm_image, target_image, morph_strength):
-    # Convert BGR to RGB (since OpenCV uses BGR, PIL uses RGB)
-    mm_image_rgb = cv2.cvtColor(mm_image, cv2.COLOR_BGR2RGB)
-    target_image_rgb = cv2.cvtColor(target_image, cv2.COLOR_BGR2RGB)
+    filename = phoneme_map.get(phoneme.upper())
+    if filename is None:
+        raise ValueError(f"Invalid phoneme: {phoneme}")
     
-    # Apply face morphing using facemorpher
-    # Morph between MM image and the target phoneme image based on the morph strength
-    frames = facemorpher.morph_images(mm_image_rgb, target_image_rgb, num_frames=20)
+    path = os.path.join(phoneme_dir, filename)
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Image for phoneme '{phoneme}' not found at {path}")
     
-    # Get the frame corresponding to morph_strength in the range [0.0 to 1.0]
-    frame_index = int(morph_strength * (len(frames) - 1))
-    return Image.fromarray(frames[frame_index])
+    return path
 
-# Function for the full lipsync process using sliders for each phoneme
-def lipsync_interface(mm_image, aa_image, ee_image, oo_image, ww_image, na_image, slider_aa, slider_oo, slider_ee, slider_ww, slider_na):
-    # List of phoneme images
-    phoneme_images = {
-        "AA": aa_image,
-        "EE": ee_image,
-        "OO": oo_image,
-        "WW": ww_image,
-        "NA": na_image
-    }
-    
-    # Load MM (Neutral) image
-    mm_image = load_image(mm_image.name)  # Load the image file
+def interpolate_faces(phoneme1, phoneme2, steps=10):
+    img1_path = get_phoneme_image(phoneme1)
+    img2_path = get_phoneme_image(phoneme2)
     
-    # Start with MM image and interpolate to other phonemes
-    result_image = mm_image
+    output_dir = "morph_output"
+    os.makedirs(output_dir, exist_ok=True)
     
-    if slider_aa > 0.0:
-        aa_image = load_image(phoneme_images["AA"].name)
-        result_image = generate_lipsync_frame(mm_image, aa_image, slider_aa)
+    for i in range(steps + 1):
+        alpha = i / steps
+        if use_facemorpher:
+            morpher.morpher(
+                img1_path, img2_path,
+                plot=True,
+                alpha=alpha,
+                out_folder=output_dir,
+                out_frames=1,
+                gif=False
+            )
+        else:
+            result = morph_faces(img1_path, img2_path, alpha)
+            frame_path = os.path.join(output_dir, f"frame_{i:02d}.jpg")
+            cv2.imwrite(frame_path, result)
+            print(f"Saved frame {i} at alpha {alpha:.2f} to {frame_path}")
+            time.sleep(0.1)
 
-    if slider_oo > 0.0:
-        oo_image = load_image(phoneme_images["OO"].name)
-        result_image = generate_lipsync_frame(result_image, oo_image, slider_oo)
-    
-    if slider_ee > 0.0:
-        ee_image = load_image(phoneme_images["EE"].name)
-        result_image = generate_lipsync_frame(result_image, ee_image, slider_ee)
-    
-    if slider_ww > 0.0:
-        ww_image = load_image(phoneme_images["WW"].name)
-        result_image = generate_lipsync_frame(result_image, ww_image, slider_ww)
-    
-    if slider_na > 0.0:
-        na_image = load_image(phoneme_images["NA"].name)
-        result_image = generate_lipsync_frame(result_image, na_image, slider_na)
+if __name__ == "__main__":
+    interpolate_faces("AA", "EE", steps=10)
+'''
 
-    return result_image
+    with open("main.py", "w") as f:
+        f.write(main_code)
 
-# Gradio interface setup
-iface = gr.Interface(
-    fn=lipsync_interface,
-    inputs=[
-        gr.inputs.Image(label="MM Image (Neutral)", type="file"),
-        gr.inputs.Image(label="AA Image", type="file"),
-        gr.inputs.Image(label="EE Image", type="file"),
-        gr.inputs.Image(label="OO Image", type="file"),
-        gr.inputs.Image(label="WW Image", type="file"),
-        gr.inputs.Image(label="NA Image", type="file"),
-        
-        gr.inputs.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Morph Strength AA"),
-        gr.inputs.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Morph Strength OO"),
-        gr.inputs.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Morph Strength EE"),
-        gr.inputs.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Morph Strength WW"),
-        gr.inputs.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Morph Strength NA"),
-    ],
-    outputs=gr.outputs.Image(label="Interpolated Lip-sync Frame"),
-    live=True
-)
+    print("main.py created. Running the script...")
+    os.system(f"{sys.executable} main.py")
 
-iface.launch()
+if __name__ == "__main__":
+    install_requirements()
+    create_and_run_main_py()