Upload 4 files

README.md

@@ -1,14 +1,102 @@
+
+# Face Swapping App by Adil Khan
+
+Welcome to the **Face Swapping App** repository! This application leverages **Streamlit** and **OpenCV**, powered by **InsightFace**, to perform seamless face swapping on images and videos. Whether you want to swap faces in pictures or videos, this app provides a simple and efficient solution.
+
+---
+
+## Features
+
+- **Image Face Swap**: Effortlessly swap faces between a source and target image.
+- **Video Face Swap**: Apply face swapping across all frames of a target video using a source face image.
+- **High Precision**: Built on **InsightFace** deep learning models for accurate face detection and swapping.
+- **User-Friendly Interface**: Interact with the app through a sleek and intuitive **Streamlit** interface.
+
+---
+
+## How It Works
+
+1. **Image Face Swapping**:
+   - Detects faces in both the source and target images.
+   - Replaces the target face with the source face using the `inswapper_128.onnx` model.
+   
+2. **Video Face Swapping**:
+   - Processes each frame of the video to detect and swap faces to match the source face.
+
+---
+
+## Installation
+
+Follow these steps to get started:
+
+1. **Clone the repository**:
+   ```bash
+   git clone https://github.com/AdiKhanOfficial/face-swap-app.git
+   cd face-swap-app
+   ```
+
+2. **Install dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Run the app**:
+   - For the Streamlit interface:
+     ```bash
+     streamlit run app.py
+     ```
+   - Or, simply run:
+     ```bash
+     python run.py
+     ```
+
+---
+
+## Requirements
+
+- **Python 3.9**  
+- **Streamlit**  
+- **OpenCV**  
+- **InsightFace**
+
+**Download Links**:
+- [Python 3.9](https://www.python.org/downloads/release/python-390/)
+- [InSwapper Model (`inswapper_128.onnx`)](https://cdn.adikhanofficial.com/python/insightface/models/inswapper_128.onnx)
+
 ---
-title: Face Swap App
-emoji: 🐠
-colorFrom: blue
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.40.2
-app_file: app.py
-pinned: false
-license: mit
-short_description: Image and Video Face Swaping App
+
+## Usage
+
+1. Open the application using Streamlit or `run.py`.
+2. Upload your **source face image** and the **target image/video**.
+3. Click the process button and let the magic happen!
+4. Once processing is complete, download the swapped images or videos directly from the app.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Results
+<img src='https://raw.githubusercontent.com/AdiKhanOfficial/face_swapping/refs/heads/main/Results/Result.jpg' style='width:100%'/>
+
+---
+
+## Contributing
+
+Contributions are welcome! If you’d like to improve the app or add new features, feel free to fork the repository, make your changes, and submit a pull request.
+
+---
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).
+
+---
+
+## About
+
+Developed by **Adil Khan**.  
+For more projects and updates, visit my [GitHub Profile](https://github.com/AdiKhanOfficial) or follow me on social media.
+
+---
+
+Feel free to reach out with any questions or feedback! 😊
+

app.py

@@ -0,0 +1,145 @@
+import os
+from tempfile import NamedTemporaryFile
+import streamlit as st
+import cv2
+import numpy as np
+import insightface
+from insightface.app import FaceAnalysis
+import time
+import requests
+
+app = ''
+swapper = ''
+st.set_page_config(page_title="FaceSwap App by Adil Khan")
+
+def download_model():
+    url = "https://cdn.adikhanofficial.com/python/insightface/models/inswapper_128.onnx"
+    filename = url.split('/')[-1]
+    filepath = os.path.join(os.path.dirname(__file__),filename)
+    
+    if not os.path.exists(filepath):
+        print(f"Downloading {filename}...")
+        response = requests.get(url)
+        with open(filepath, 'wb') as file:
+            file.write(response.content)
+        print(f"{filename} downloaded successfully.")
+    else:
+        print(f"{filename} already exists in the directory.")
+
+def swap_faces(target_image, target_face, source_face):
+    try:
+        return swapper.get(target_image, target_face, source_face, paste_back=True)
+    except Exception as e:
+        st.error(f"Error during swaping: {e}")
+
+
+def image_faceswap_app():
+    st.title("Face Swapper for Image")
+    source_image = st.file_uploader("Upload Source Image", type=["jpg", "jpeg", "png"])
+    target_image = st.file_uploader("Upload Target Image", type=["jpg", "jpeg", "png"])
+    if source_image and target_image:
+        with st.spinner("Swapping... Please wait."):
+            try:
+                source_image = cv2.imdecode(np.frombuffer(source_image.read(), np.uint8), -1)
+                target_image = cv2.imdecode(np.frombuffer(target_image.read(), np.uint8), -1)
+                source_image = cv2.cvtColor(source_image, cv2.COLOR_BGR2RGB)
+                target_image = cv2.cvtColor(target_image, cv2.COLOR_BGR2RGB)                
+                source_faces = app.get(source_image)
+                source_faces = sorted(source_faces, key=lambda x: x.bbox[0])
+                if len(source_faces) == 0:
+                    raise ValueError("No faces found in the source image.")
+                source_face = source_faces[0]
+                target_faces = app.get(target_image)
+                target_faces = sorted(target_faces, key=lambda x: x.bbox[0])
+                if len(target_faces) == 0:
+                    raise ValueError("No faces found in the target image.")
+                target_face = target_faces[0]
+                swapped_image = swap_faces(target_image, target_face, source_face)                
+                message_placeholder = st.empty()
+                message_placeholder.success("Swapped Successfully!")
+                col1, col2, col3 = st.columns([1, 1, 1])
+                with col1:
+                    st.image(source_image, caption="Source Image", use_column_width=True)
+                with col2:
+                    st.image(target_image, caption="Target Image", use_column_width=True)
+                with col3:
+                    st.image(swapped_image, caption="Swapped Image", use_column_width=True)
+            except Exception as e:
+                st.error(f"Error during image processing: {e}")
+
+
+def process_video(source_img, video_path, output_video_path):
+    try:
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height))
+        source_faces = app.get(source_img)
+        source_faces = sorted(source_faces, key=lambda x: x.bbox[0])
+        if len(source_faces) == 0:
+            raise ValueError("No faces found in the source image.")
+        source_face = source_faces[0]
+        progress_placeholder = st.empty()
+        frame_count = 0
+        start_time = time.time()
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            target_faces = app.get(frame)
+            target_faces = sorted(target_faces, key=lambda x: x.bbox[0])
+            if len(target_faces) > 0:
+                frame = swap_faces(frame, target_faces[0], source_face)
+            out.write(frame)
+            elapsed_time = time.time() - start_time
+            frames_per_second = frame_count / elapsed_time if elapsed_time > 0 else 0
+            remaining_time_seconds = max(0, (total_frames - frame_count) / frames_per_second) if frames_per_second > 0 else 0
+            remaining_minutes, remaining_seconds = divmod(remaining_time_seconds, 60)
+            elapsed_minutes, elapsed_seconds = divmod(elapsed_time, 60)
+            progress_placeholder.text(
+                f"Processed Frames: {frame_count}/{total_frames} | Elapsed Time: {int(elapsed_minutes)}m {int(elapsed_seconds)}s | Remaining Time: {int(remaining_minutes)}m {int(remaining_seconds)}s")
+            frame_count += 1
+        cap.release()
+        out.release()
+    except Exception as e:
+        st.error(f"Error during video processing: {e}")
+
+
+def video_faceswap_app():
+    st.title("Face Swapper for Video")
+    source_image = st.file_uploader("Upload Source Face Image", type=["jpg", "jpeg", "png"])
+    if source_image is not None:
+        source_image = cv2.imdecode(np.frombuffer(source_image.read(), np.uint8), -1)
+    target_video = st.file_uploader("Upload Target Video", type=["mp4"])
+    if target_video is not None:
+        temp_video = NamedTemporaryFile(delete=False, suffix=".mp4")
+        temp_video.write(target_video.read())
+        output_video_path = os.path.splitext(temp_video.name)[0] + '_output.mp4'
+        status_placeholder = st.empty()
+        try:
+            with st.spinner("Processing... This may take a while."):
+                process_video(source_image, temp_video.name, output_video_path)
+            status_placeholder.success("Processing complete!")
+            st.subheader("Your video is ready:")
+            st.video(output_video_path)
+        except Exception as e:
+            st.error(f"Error during video processing: {e}")
+
+
+def main():
+    app_selection = st.sidebar.radio("Select App", ("Image Face Swapping", "Video Face Swapping"))
+    if app_selection == "Image Face Swapping":
+        image_faceswap_app()
+    elif app_selection == "Video Face Swapping":
+        video_faceswap_app()
+
+
+if __name__ == "__main__":
+    app = FaceAnalysis(name='buffalo_l')
+    app.prepare(ctx_id=0, det_size=(640, 640))
+    download_model() #download model if not available
+    swapper = insightface.model_zoo.get_model('inswapper_128.onnx', root=os.path.dirname(__file__))
+    main()

requirements.txt

@@ -0,0 +1,6 @@
+opencv-python
+numpy
+insightface
+onnx
+onnxruntime
+streamlit

run.py

@@ -0,0 +1,10 @@
+import os
+import sys
+import subprocess
+
+# Define the path to the Streamlit app
+script_path = os.path.join(os.path.dirname(__file__), 'app.py')
+
+# Run the Streamlit app
+if __name__ == "__main__":
+    subprocess.run([sys.executable, "-m", "streamlit", "run", script_path])