Upload folder using huggingface_hub

requirements.txt

@@ -0,0 +1,5 @@
+numpy
+PIL
+face_recognition
+streamlit
+scipy

.gitignore

@@ -0,0 +1,5 @@
+venv/
+images/
+flagged/
+__pycache__/
+```

README.md

@@ -1,12 +1,6 @@
 ---
-title: Image Grouping Based On Face Recognition
-emoji: 🏃
-colorFrom: yellow
-colorTo: indigo
+title: Image_Grouping_based_on_Face_Recognition
+app_file: face_grouping.py
 sdk: gradio
 sdk_version: 4.19.2
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,89 @@
+import streamlit as st
+import os
+import shutil
+import numpy as np
+from PIL import Image
+import face_recognition
+from scipy.spatial import distance
+import tempfile
+
+class ImageToGroup(object):
+    def __init__(self, filename, path):
+        self.filename = filename
+        self.path = path
+        self.embeddings = self.extract_embeddings()
+
+    def extract_embeddings(self):
+        img = face_recognition.load_image_file(self.path)
+        face_locations = face_recognition.face_locations(img)
+        if len(face_locations) == 0:
+            return []  # No face found in the image
+        face_encodings = [face_recognition.face_encodings(img, [face_location])[0] for face_location in face_locations]
+        return face_encodings
+
+    def are_similar(self, other_embeddings, threshold=0.6):
+        # Calculate the Euclidean distance between two embeddings
+        for other_embedding in other_embeddings:
+            for self_embedding in self.embeddings:
+                dist = distance.euclidean(self_embedding, other_embedding)
+                if dist < threshold:
+                    return True
+        return False
+
+def main(images, output_dir):
+    images_to_group = [ImageToGroup(os.path.basename(image_path), image_path) for image_path in images]
+    
+    # Group images into clusters based on face embeddings
+    grouped_images = {}
+    for image in images_to_group:
+        if not image.embeddings:
+            continue  # Skip images with no faces
+        for embedding in image.embeddings:
+            found_group = False
+            for group_key, group_images in grouped_images.items():
+                if image.are_similar(group_images[0].embeddings):  # Compare embeddings using are_similar method
+                    group_images.append(image)
+                    found_group = True
+                    break
+            if not found_group:
+                grouped_images[tuple(embedding)] = [image]  # Convert numpy.ndarray to a hashable type using tuple()
+
+    # Save grouped images
+    for i, (embedding, group_images) in enumerate(grouped_images.items()):
+        group_dir = os.path.join(output_dir, f"group_{i+1}")  # Add +1 to the index to start from 1
+        os.makedirs(group_dir, exist_ok=True)
+        for image in group_images:
+            image_filename = os.path.basename(image.path)
+            destination_path = os.path.join(group_dir, image_filename)
+            shutil.copy(image.path, destination_path)
+
+def app():
+    st.title('Image Grouping based on Face Recognition')
+
+    uploaded_files = st.file_uploader('Upload images:', type=['png', 'jpg', 'jpeg'], accept_multiple_files=True)
+
+    if st.button('Group Images'):
+        if uploaded_files:
+            images = []
+            for uploaded_file in uploaded_files:
+                tfile = tempfile.NamedTemporaryFile(delete=False) 
+                tfile.write(uploaded_file.read())
+                images.append(tfile.name)
+            
+            output_dir = tempfile.mkdtemp()
+            main(images, output_dir)
+            
+            st.success('Images grouped successfully.')
+            
+            # Display the grouped images
+            for group_dir in os.listdir(output_dir):
+                st.header(f'Group: {group_dir}')
+                for image_file in os.listdir(os.path.join(output_dir, group_dir)):
+                    image = Image.open(os.path.join(output_dir, group_dir, image_file))
+                    st.image(image)
+
+        else:
+            st.error('Please upload images.')
+
+if __name__ == '__main__':
+    app()

face_grouping.py

@@ -0,0 +1,73 @@
+import os
+import numpy as np
+from PIL import Image
+import face_recognition
+from scipy.spatial import distance
+import gradio as gr
+
+class ImageToGroup(object):
+    def __init__(self, filename, path):
+        self.filename = filename
+        self.path = path
+        self.embeddings = self.extract_embeddings()
+
+    def extract_embeddings(self):
+        try:
+            img = Image.open(self.path)
+            img = img.convert("RGB")  # Convert image to RGB
+            img = img.resize((800, 800))  # Resize the image to improve performance
+            img = np.array(img)
+            face_locations = face_recognition.face_locations(img)
+            if len(face_locations) == 0:
+                return []  # No face found in the image
+            # Generate multiple face encodings with jitter
+            face_encodings = [face_recognition.face_encodings(img, [face_location], num_jitters=10)[0] for face_location in face_locations]
+            return face_encodings
+        except Exception as e:
+            print(f"Error extracting embeddings from {self.path}: {e}")
+            return []
+
+    def are_similar(self, other_embeddings, threshold=0.6):
+        # Calculate the Euclidean distance between two embeddings
+        for other_embedding in other_embeddings:
+            for _ in self.embeddings:
+                dist = distance.euclidean(_, other_embedding)
+                if dist < threshold:
+                    return True
+        return False
+
+def group_images(input_files):
+    images_to_group = [ImageToGroup(os.path.basename(file), file) for file in input_files]
+   
+    # Group images into clusters based on face embeddings
+    grouped_images = {}
+    for image in images_to_group:
+        if not image.embeddings:
+            continue  # Skip images with no faces
+        for group_images in grouped_images.values():
+            if image.are_similar(group_images[0].embeddings):  # Compare embeddings using are_similar method
+                group_images.append(image)
+                break
+        else:
+            # Use the first embedding of the current image as the key for the new group
+            grouped_images[tuple(image.embeddings[0])] = [image]
+
+    # Convert grouped images to PIL Image objects
+    group_images_pil = []
+    for i, (_, group_images) in enumerate(grouped_images.items()):
+        for image in group_images:
+            pil_image = Image.open(image.path)
+            group_images_pil.append((pil_image, f"Group {i+1}"))
+
+    return group_images_pil
+
+# Interface for Gradio
+input_directory = gr.File(label="Input Directory",file_count="multiple")
+
+gallery = gr.Gallery(label="Grouped Images")
+
+gr.Interface(
+   fn=group_images, 
+   inputs=[input_directory], 
+   outputs=gallery
+).launch(share=True)

main.py

@@ -0,0 +1,75 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import os
+import shutil
+import numpy as np
+from PIL import Image
+import face_recognition
+from scipy.spatial import distance
+
+app = FastAPI()
+
+class ImageToGroup(object):
+    def __init__(self, filename, path):
+        self.filename = filename
+        self.path = path
+        self.embeddings = self.extract_embeddings()
+
+    def extract_embeddings(self):
+        img = face_recognition.load_image_file(self.path)
+        face_locations = face_recognition.face_locations(img)
+        if len(face_locations) == 0:
+            return []  # No face found in the image
+        # Generate multiple face encodings with jitter
+        face_encodings = [face_recognition.face_encodings(img, [face_location], num_jitters=10)[0] for face_location in face_locations]
+        return face_encodings
+
+    def are_similar(self, other_embeddings, threshold=0.6):
+        # Calculate the Euclidean distance between two embeddings
+        for other_embedding in other_embeddings:
+            for self_embedding in self.embeddings:
+                dist = distance.euclidean(self_embedding, other_embedding)
+                if dist < threshold:
+                    return True
+        return False
+
+def main(input_dir, output_dir):
+    filenames = os.listdir(input_dir)
+    images_to_group = [ImageToGroup(filename, os.path.join(input_dir, filename)) for filename in filenames]
+    
+    # Group images into clusters based on face embeddings
+    grouped_images = {}
+    for image in images_to_group:
+        if not image.embeddings:
+            continue  # Skip images with no faces
+        for embedding in image.embeddings:
+            found_group = False
+            for group_key, group_images in grouped_images.items():
+                if image.are_similar(group_images[0].embeddings):  # Compare embeddings using are_similar method
+                    group_images.append(image)
+                    found_group = True
+                    break
+            if not found_group:
+                grouped_images[tuple(embedding)] = [image]  # Convert numpy.ndarray to a hashable type using tuple()
+
+    # Save grouped images
+    for i, (embedding, group_images) in enumerate(grouped_images.items()):
+        group_dir = os.path.join(output_dir, f"group_{i+1}")  # Add +1 to the index to start from 1
+        os.makedirs(group_dir, exist_ok=True)
+        for image in group_images:
+            image_filename = os.path.basename(image.path)
+            destination_path = os.path.join(group_dir, image_filename)
+            shutil.copy(image.path, destination_path)
+
+class GroupImagesRequest(BaseModel):
+    input_dir: str
+    output_dir: str
+
+@app.post("/group_images")
+async def group_images(request: GroupImagesRequest):
+    if not os.path.isdir(request.input_dir):
+        raise HTTPException(status_code=400, detail="Input directory does not exist")
+    if not os.path.isdir(request.output_dir):
+        os.makedirs(request.output_dir)
+    main(request.input_dir, request.output_dir)
+    return {"message": "Images grouped successfully"}

req.py

@@ -0,0 +1,11 @@
+import requests
+
+response = requests.post(
+    "http://192.168.100:8000/group_images",
+    json={
+        "input_dir": "/home/greyshadow/Desktop/source/Grouping/images",
+        "output_dir": "/home/greyshadow/Desktop/source/Grouping/result"
+    }
+)
+
+print(response.json())

updated1.py

@@ -0,0 +1,73 @@
+import os
+import shutil
+import numpy as np
+from PIL import Image
+import face_recognition
+from scipy.spatial import distance
+
+class ImageToGroup(object):
+    def __init__(self, filename, path):
+        self.filename = filename
+        self.path = path
+        self.embeddings = self.extract_embeddings()
+
+    def extract_embeddings(self):
+        try:
+            img = Image.open(self.path)
+            img = img.resize((800, 800))  # Resize the image to improve performance
+            img = np.array(img)
+            face_locations = face_recognition.face_locations(img)
+            if len(face_locations) == 0:
+                return []  # No face found in the image
+            # Generate multiple face encodings with jitter
+            face_encodings = [face_recognition.face_encodings(img, [face_location], num_jitters=10)[0] for face_location in face_locations]
+            return face_encodings
+        except Exception as e:
+            print(f"Error extracting embeddings from {self.path}: {e}")
+            return []
+
+    def are_similar(self, other_embeddings, threshold=0.6):
+        # Calculate the Euclidean distance between two embeddings
+        for other_embedding in other_embeddings:
+            for self_embedding in self.embeddings:
+                dist = distance.euclidean(self_embedding, other_embedding)
+                if dist < threshold:
+                    return True
+        return False
+
+def main(input_dir, output_dir):
+    filenames = os.listdir(input_dir)
+    images_to_group = [ImageToGroup(filename, os.path.join(input_dir, filename)) for filename in filenames]
+    
+    # Group images into clusters based on face embeddings
+    grouped_images = {}
+    for image in images_to_group:
+        if not image.embeddings:
+            continue  # Skip images with no faces
+        for embedding in image.embeddings:
+            found_group = False
+            for group_key, group_images in grouped_images.items():
+                if image.are_similar(group_images[0].embeddings):  # Compare embeddings using are_similar method
+                    group_images.append(image)
+                    found_group = True
+                    break
+            if not found_group:
+                grouped_images[tuple(embedding)] = [image]  # Convert numpy.ndarray to a hashable type using tuple()
+
+    # Save grouped images
+    for i, (embedding, group_images) in enumerate(grouped_images.items()):
+        group_dir = os.path.join(output_dir, f"group_{i+1}")  # Add +1 to the index to start from 1
+        try:
+            os.makedirs(group_dir, exist_ok=True)
+            for image in group_images:
+                image_filename = os.path.basename(image.path)
+                destination_path = os.path.join(group_dir, image_filename)
+                shutil.copy(image.path, destination_path)
+        except Exception as e:
+            print(f"Error saving images to {group_dir}: {e}")
+
+if __name__ == '__main__':
+    import sys
+    input_dir = sys.argv[1]
+    output_dir = sys.argv[2]
+    main(input_dir, output_dir)