Upload 7 files

extract_faces.py

@@ -0,0 +1,75 @@
+import os
+from PIL import Image
+from retinaface import RetinaFace
+from concurrent.futures import ProcessPoolExecutor
+
+Image.MAX_IMAGE_PIXELS = 200000000  # Allow images up to 200 million pixels
+
+DATA = [
+    ((512, 512), r"G:\man dataset\man_4502_imgs_raw"),
+    ((1024, 1024), r"G:\man dataset\man_4502_imgs_raw")
+]
+
+NUM_THREADS = 1  # Modify this for the desired number of threads
+OUTPUT_ROOT = r"H:\man dataset\resize_faces"  # Root folder to save resized face images
+
+## change resize enabled to resize
+def resize_face(args, resize_enabled=False):
+    try:
+        input_path, resolution, output_root = args
+    except ValueError as e:
+        print(f"Error unpacking arguments: {e}")
+        return
+
+    try:
+        image = Image.open(input_path)
+    except Exception as e:
+        print(f"Error loading image: {e}")
+        return
+
+    try:
+        # Detect faces
+        faces = RetinaFace.detect_faces(input_path)
+
+        if not faces:
+            print(f"No face detected in {input_path}")
+            return
+
+        # Assuming we take the first detected face
+        face = next(iter(faces.values()))
+        x, y, x2, y2 = face['facial_area']
+        face_image = image.crop((x, y, x2, y2))
+
+        if resize_enabled:
+            # Resize the cropped face only if resizing is enabled
+            face_image = face_image.resize(resolution, Image.LANCZOS)
+    except Exception as e:
+        print(f"Error in face detection or resizing: {e}")
+        return
+
+    try:
+        output_folder = os.path.join(output_root, f"{resolution[0]}x{resolution[1]}" if resize_enabled else "no_resize")
+        if not os.path.exists(output_folder):
+            os.makedirs(output_folder)
+
+        output_path = os.path.join(output_folder, os.path.basename(input_path))
+        face_image.save(output_path, quality=100)
+    except Exception as e:
+        print(f"Error saving image: {e}")
+
+def process_folder(input_folder, resolution, resize_enabled=False):
+    image_paths = [os.path.join(input_folder, fname) for fname in os.listdir(input_folder) if fname.lower().endswith(('png', 'jpg', 'jpeg'))]
+    
+    total_images = len(image_paths)
+    processed_count = 0
+
+    with ProcessPoolExecutor(max_workers=NUM_THREADS) as executor:
+        for _ in executor.map(resize_face, [(path, resolution, OUTPUT_ROOT) for path in image_paths], [resize_enabled] * len(image_paths)):
+            processed_count += 1
+            print(f"Processed {processed_count}/{total_images} images for resolution {resolution[0]}x{resolution[1]} (Resize: {'Enabled' if resize_enabled else 'Disabled'})...")
+
+if __name__ == "__main__":
+    resize_enabled = False  # Change this to True if resizing is needed
+    for resolution, folder in DATA:
+        process_folder(folder, resolution, resize_enabled)
+    print("Processing complete!")

install.bat

@@ -0,0 +1,33 @@
+@echo off
+
+python.exe -m pip install --upgrade pip
+
+REM Create virtual environment folder
+echo composing venv
+IF NOT EXIST venv (
+    python -m venv venv
+) ELSE (
+    echo venv folder already exists, skipping making new venv...
+)
+call .\venv\Scripts\activate.bat
+
+
+
+pip3 install torch==2.0.1 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
+
+pip install tensorflow==2.10
+
+pip install transformers
+
+pip install Pillow
+
+pip install retina-face
+
+
+
+
+REM Show completion message
+echo Virtual environment made and installed properly
+
+REM Pause to keep the command prompt open
+pause

resizer_v4.py

@@ -0,0 +1,154 @@
+import os
+import time
+from PIL import Image
+from retinaface import RetinaFace
+from concurrent.futures import ProcessPoolExecutor
+
+Image.MAX_IMAGE_PIXELS = 200000000  # Allow images up to 200 million pixels
+
+DATA = [
+    ((768,1368), r"F:\woman dataset\768x1368"),
+    ((1216, 832), r"F:\woman dataset\1216x832")
+]
+
+DATA = [
+    ((512, 512), r"H:\woman dataset\1536x1536"),
+    ((768, 768), r"H:\woman dataset\1536x1536"),
+    ((1024, 1024), r"H:\woman dataset\1536x1536"),
+    ((1536, 1536), r"H:\woman dataset\1536x1536"),
+    ((1280, 1536), r"H:\woman dataset\1280x1536"),
+    ((1536, 1280), r"H:\woman dataset\1536x1280"),
+    ((1024, 1536), r"H:\woman dataset\1024x1536"),
+    ((1536, 1024), r"H:\woman dataset\1536x1024"),
+    ((512, 768), r"H:\woman dataset\1024x1536"),
+    ((768, 512), r"H:\woman dataset\1536x1024"),
+    ((768, 1024), r"H:\woman dataset\768x1024"),
+    ((1024, 768), r"H:\woman dataset\1024x768"),
+    ((1024, 1280), r"H:\woman dataset\1024x1280"),
+    ((1280, 1024), r"H:\woman dataset\1280x1024"),
+    ((640,1536), r"H:\woman dataset\640x1536"),
+    ((1536, 640), r"H:\woman dataset\1536x640"),
+    ((768,1344), r"H:\woman dataset\768x1344"),
+    ((1344, 768), r"H:\woman dataset\1344x768"),
+    ((768,1368), r"H:\woman dataset\768x1368"),
+    ((1368, 768), r"H:\woman dataset\1368x768"),
+    ((832,1216), r"H:\woman dataset\832x1216"),
+    ((1216, 832), r"H:\woman dataset\1216x832"),
+    ((896,1152), r"H:\woman dataset\896x1152"),
+    ((1152, 896), r"H:\woman dataset\1152x896")
+]
+
+
+
+NUM_THREADS = 1  # Modify this for the desired number of threads
+OUTPUT_ROOT = r"G:\woman dataset\fixed_faces_png"  # Root folder to save resized images
+Save_PNG = False  # Options are True and False
+LOG_FILE = "face_detection_failures.txt"  # File to log images where faces can't be detected
+
+def resize_image(args):
+    start_time = time.time()  # Start timing
+
+    try:
+        input_path, resolution, output_root, save_as_png = args
+    except ValueError as e:
+        print(f"Error unpacking arguments: {e}")
+        return None
+
+    try:
+        # Load the image
+        image = Image.open(input_path)
+    except Exception as e:
+        print(f"Error loading image: {e}")
+        return None
+
+    face_detected = True
+    face_locations = None
+
+    try:
+        # Get face locations using RetinaFace
+        faces = RetinaFace.detect_faces(input_path)
+
+        if not faces or 'face_1' not in faces:
+            face_detected = False
+            with open(LOG_FILE, 'a') as log:
+                log.write(f"Face not detected: {input_path}\n")
+        else:
+            face = faces['face_1']
+            x, y, x2, y2 = face['facial_area']
+            face_locations = [(y, x2, y2, x)]  # Adjust format to match face_recognition
+    except Exception as e:
+        print(f"Error detecting faces: {e}")
+        face_detected = False
+
+    # Proceed with cropping and resizing
+    try:
+        desired_aspect_ratio = resolution[0] / resolution[1]
+        image_aspect_ratio = image.width / image.height
+
+        # Calculate crop dimensions
+        if image_aspect_ratio > desired_aspect_ratio:
+            new_width = int(image.height * desired_aspect_ratio)
+            new_height = image.height
+        else:
+            new_width = image.width
+            new_height = int(image.width / desired_aspect_ratio)
+
+        # Default centering
+        left = (image.width - new_width) / 2
+        top = (image.height - new_height) / 2
+        right = (image.width + new_width) / 2
+        bottom = (image.height + new_height) / 2
+
+        # Adjust for face center if a face is detected
+        if face_detected and face_locations:
+            face_top, face_right, face_bottom, face_left = face_locations[0]
+            face_center_x = (face_left + face_right) // 2
+            face_center_y = (face_top + face_bottom) // 2
+
+            left = min(max(0, face_center_x - new_width // 2), image.width - new_width)
+            top = min(max(0, face_center_y - new_height // 2), image.height - new_height)
+            right = left + new_width
+            bottom = top + new_height
+
+        image = image.crop((left, top, right, bottom))
+
+        # Resize image with best resampling filter (LANCZOS)
+        image = image.resize(resolution, Image.LANCZOS)
+
+        output_folder = os.path.join(output_root, f"{resolution[0]}x{resolution[1]}")
+        if not os.path.exists(output_folder):
+            os.makedirs(output_folder)
+
+        output_path = os.path.join(output_folder, os.path.basename(input_path))
+        if save_as_png:
+            output_path = os.path.splitext(output_path)[0] + '.png'
+            image.save(output_path, format='PNG')
+        else:
+            image.save(output_path, quality=100)
+
+    except Exception as e:
+        print(f"Error processing or saving image: {e}")
+        return None
+
+    end_time = time.time()  # End timing
+    return end_time - start_time  # Return processing time
+
+def process_folder(input_folder, resolution, save_as_png):
+    image_paths = [os.path.join(input_folder, fname) for fname in os.listdir(input_folder) if fname.lower().endswith(('png', 'jpg', 'jpeg'))]
+
+    total_images = len(image_paths)
+    processed_count = 0
+    total_time = 0  # Total time for processing images
+
+    with ProcessPoolExecutor(max_workers=NUM_THREADS) as executor:
+        for processing_time in executor.map(resize_image, [(path, resolution, OUTPUT_ROOT, save_as_png) for path in image_paths]):
+            processed_count += 1
+            if processing_time is not None:
+                total_time += processing_time
+            average_time = total_time / processed_count * 1000  # Convert to milliseconds
+            print(f"Processed {processed_count}/{total_images} images for resolution {resolution[0]}x{resolution[1]}... Average processing time per image: {average_time:.2f} ms")
+
+if __name__ == "__main__":
+    for resolution, folder in DATA:
+        process_folder(folder, resolution, Save_PNG)
+    print("Processing complete!")

run_extract_faces_CPU.bat

@@ -0,0 +1,10 @@
+@echo off
+
+echo don't forget to run install bat and make sure that you have changed the paths in resize_faces.py file
+echo moreover set your thread count according to your CPU
+call .\venv\Scripts\activate.bat
+
+set CUDA_VISIBLE_DEVICES=124121
+python extract_faces.py
+
+pause

run_extract_faces_GPU.bat

@@ -0,0 +1,10 @@
+@echo off
+
+echo don't forget to run install bat and make sure that you have changed the paths in resize_faces.py file
+echo moreover set your thread count according to your CPU
+call .\venv\Scripts\activate.bat
+
+set CUDA_VISIBLE_DEVICES=0
+python extract_faces.py
+
+pause

run_resizer_CPU.bat

@@ -0,0 +1,10 @@
+@echo off
+
+echo don't forget to run install bat and make sure that you have changed the paths in resizer_v4.py file
+echo moreover set your thread count according to your CPU
+call .\venv\Scripts\activate.bat
+
+set CUDA_VISIBLE_DEVICES=1231412
+python resizer_v4.py
+
+pause

run_resizer_GPU.bat

@@ -0,0 +1,10 @@
+@echo off
+
+echo don't forget to run install bat and make sure that you have changed the paths in resizer_v4.py file
+echo moreover set your thread count according to your CPU
+call .\venv\Scripts\activate.bat
+
+set CUDA_VISIBLE_DEVICES=0
+python resizer_v4.py
+
+pause