In place zombies working

align.py

@@ -2,10 +2,49 @@ import numpy as np
 import mediapipe as mp
 from PIL import Image
 import PIL
+import scipy
+import scipy.ndimage
 
 mp_face_detection = mp.solutions.face_detection
 face_detection = mp_face_detection.FaceDetection(min_detection_confidence=0.5, model_selection=0)
 
+def aligns(pil_image,enable_padding=True,output_size=512,model_type="dlib",max_people=7):
+    w,h = pil_image.size
+    scale = 1
+    if min(w,h) > output_size*2:
+        scale = min(w,h) / (output_size*2)
+        new_w = int(w/scale)
+        new_h = int(h/scale)
+        pil_image = pil_image.resize((new_w,new_h),PIL.Image.BILINEAR)
+    
+    numpy_im = np.array(pil_image)
+    
+    #Find the locations of faces
+    locations,context = get_locations(numpy_im,model_type)#face_recognition.face_locations(numpy_im)
+    n_found = len(locations)
+    print("Faces found",n_found)
+    if (n_found == 0):
+        return []
+    
+    #How many are we going to return?
+    n_to_return = min(n_found,max_people)
+        
+    #Return the largest ones
+    areas = [(l[2] - l[0])*(l[1] - l[3]) for l in locations]
+    indices = np.argpartition(areas, -n_to_return)[-n_to_return:]
+    
+    #Find the landmarks
+    face_landmarks_list = get_landmarks(numpy_im,[locations[i] for i in indices],context,model_type)#face_recognition.face_landmarks(numpy_im,[locations[i]])
+
+    #Package them up
+    to_return = []
+    for face in face_landmarks_list:
+        im,quad = image_align(pil_image,face,enable_padding=enable_padding,output_size=output_size,transform_size=output_size)
+        to_return.append((im,quad*scale))
+
+    #Return them
+    return to_return
+
 def get_landmarks(numpy_array,locations,context,model_type="dlib"):
     '''
     model_type can be "dlib" or "mediapipe"

app.py

@@ -44,14 +44,10 @@ def predict(input_image, mode):
         return zombie_image
     elif mode == "In Place":
         im_array = np.array(input_image)
-        # Use the make_faces_zombie_from_array function for in-place transformation
-        #zombie_image = zombie.make_faces_zombie_from_array(im_array, None, ort_session)
-        #if zombie_image is None:
-        #    return "No face found"
-        #return zombie_image
-        face_mask = get_face_mask(input_image)
-        return face_mask
-
+        zombie_image = zombie.make_faces_zombie_from_array(im_array, None, ort_session)
+        if zombie_image is None:
+            return "No face found"
+        return zombie_image
     else:
         return "Invalid mode selected"
 

faceparsing.py

@@ -4,7 +4,6 @@ from transformers import SegformerImageProcessor, SegformerForSemanticSegmentati
 import numpy as np
 
 from PIL import Image
-import matplotlib.pyplot as plt
 
 # Global variables for lazy loading
 image_processor = None

faceparsing2.py

@@ -7,9 +7,9 @@ from pathlib import Path
 import numpy as np
 from tqdm import tqdm
 import onnxruntime as ort
-import matplotlib.pyplot as plt
 from huggingface_hub import hf_hub_download
 import cv2
+from PIL import Image
 
 
 model_path = hf_hub_download(repo_id="jbrownkramer/face-parsing", filename="resnet18.onnx")
@@ -17,24 +17,10 @@ providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if ort.get_device(
 session = ort.InferenceSession(model_path, providers=providers)
 
 def prepare_image(image, input_size: Tuple[int, int] = (512, 512)) -> np.ndarray:
-    # Resize the image
-    resized_image = cv2.resize(image, input_size, interpolation=cv2.INTER_LINEAR)
-    
-    # # Define transformation pipeline
-    # transform = transforms.Compose([
-    #     transforms.ToTensor(),
-    #     transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
-    # ])
-
-    # # Apply transformations
-    # image_tensor = transform(resized_image)
-    # image_batch = image_tensor.unsqueeze(0)
-
-    image_batch = np.array(resized_image)
+    image_batch = np.array(image)
+        # Resize the image
+    resized_image = cv2.resize(image_batch, input_size, interpolation=cv2.INTER_LINEAR)
 
-
-
-    
     image_batch = image_batch / 255.0
     image_batch -= np.array([[[0.485, 0.456, 0.406]]])
     image_batch /= np.array([[[0.229, 0.224, 0.225]]])
@@ -46,7 +32,7 @@ def prepare_image(image, input_size: Tuple[int, int] = (512, 512)) -> np.ndarray
 
 def get_face_mask(image):
     # Store original image resolution
-    h,w = image.shape[:2]
+    w,h = image.size
     
     # Prepare image for inference
     image_batch = prepare_image(image)

requirements.txt

@@ -3,9 +3,6 @@ onnxruntime
 opencv-python
 numpy
 mediapipe
-transformers
 Pillow
-matplotlib
 huggingface-hub
-torch
-torchvision
+scipy

zombie.py

@@ -3,9 +3,7 @@
 
 from PIL import Image
 import numpy as np
-# import pickle
 import align
-# import time
 import cv2
 
 from faceparsing2 import get_face_mask
@@ -122,7 +120,6 @@ def ImageOpen(filepath):
 
 def do_face(aligned, box, im_array, ort_session):
         z = square_human_2_zombie_onnx(aligned,ort_session)
-        t1 = time.time()
 
         t = cv2.getAffineTransform(np.array([[0,0],[0,511],[511,511]],dtype="float32"),box[:3,:].astype("float32"))
 
@@ -148,9 +145,7 @@ def make_faces_zombie(path, facenet, ort_session):
 def make_faces_zombie_from_array(im_array_rgb, facenet, ort_session):
     im_array_rgb = np.copy(im_array_rgb)
 
-    t0 = time.time()
-    faces = align.aligns(Image.fromarray(im_array_rgb),enable_padding=True,output_size=512)
-    print("Find faces",time.time() - t0)
+    faces = align.aligns(Image.fromarray(im_array_rgb),enable_padding=True,output_size=512,model_type="mediapipe")
     if faces is None:
         faces = []