Merge pull request #1319 from Circuit8/represent-optimizations

Represent optimizations

.gitignore

@@ -17,3 +17,4 @@ benchmarks/results
 benchmarks/outputs
 benchmarks/dataset
 benchmarks/lfwe
+venv

deepface/modules/detection.py

@@ -1,15 +1,16 @@
 # built-in dependencies
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Dict, List, Tuple, Union, Optional
 
 # 3rd part dependencies
+from heapq import nlargest
 import numpy as np
 import cv2
-from PIL import Image
 
 # project dependencies
 from deepface.modules import modeling
 from deepface.models.Detector import Detector, DetectedFace, FacialAreaRegion
 from deepface.commons import image_utils
+
 from deepface.commons.logger import Logger
 
 logger = Logger()
@@ -27,6 +28,7 @@ def extract_faces(
     color_face: str = "rgb",
     normalize_face: bool = True,
     anti_spoofing: bool = False,
+    max_faces: Optional[int] = None,
 ) -> List[Dict[str, Any]]:
     """
     Extract faces from a given image
@@ -97,6 +99,7 @@ def extract_faces(
             img=img,
             align=align,
             expand_percentage=expand_percentage,
+            max_faces=max_faces,
         )
 
     # in case of no face found
@@ -176,7 +179,9 @@ def extract_faces(
 
 
 def detect_faces(
-    detector_backend: str, img: np.ndarray, align: bool = True, expand_percentage: int = 0
+    detector_backend: str, img: np.ndarray,
+    align: bool = True, expand_percentage: int = 0,
+    max_faces: Optional[int] = None
 ) -> List[DetectedFace]:
     """
     Detect face(s) from a given image
@@ -202,7 +207,6 @@ def detect_faces(
         - confidence (float): The confidence score associated with the detected face.
     """
     height, width, _ = img.shape
-
     face_detector: Detector = modeling.build_model(
         task="face_detector", model_name=detector_backend
     )
@@ -233,60 +237,77 @@ def detect_faces(
     # find facial areas of given image
     facial_areas = face_detector.detect_faces(img)
 
-    results = []
+    if max_faces is not None and max_faces < len(facial_areas):
-    for facial_area in facial_areas:
+        facial_areas = nlargest(
-        x = facial_area.x
+            max_faces,
-        y = facial_area.y
+            facial_areas,
-        w = facial_area.w
+            key=lambda facial_area: facial_area.w * facial_area.h
-        h = facial_area.h
-        left_eye = facial_area.left_eye
-        right_eye = facial_area.right_eye
-        confidence = facial_area.confidence
-
-        if expand_percentage > 0:
-            # Expand the facial region height and width by the provided percentage
-            # ensuring that the expanded region stays within img.shape limits
-            expanded_w = w + int(w * expand_percentage / 100)
-            expanded_h = h + int(h * expand_percentage / 100)
-
-            x = max(0, x - int((expanded_w - w) / 2))
-            y = max(0, y - int((expanded_h - h) / 2))
-            w = min(img.shape[1] - x, expanded_w)
-            h = min(img.shape[0] - y, expanded_h)
-
-        # extract detected face unaligned
-        detected_face = img[int(y) : int(y + h), int(x) : int(x + w)]
-
-        # align original image, then find projection of detected face area after alignment
-        if align is True:  # and left_eye is not None and right_eye is not None:
-            aligned_img, angle = align_img_wrt_eyes(img=img, left_eye=left_eye, right_eye=right_eye)
-
-            rotated_x1, rotated_y1, rotated_x2, rotated_y2 = project_facial_area(
-                facial_area=(x, y, x + w, y + h), angle=angle, size=(img.shape[0], img.shape[1])
-            )
-            detected_face = aligned_img[
-                int(rotated_y1) : int(rotated_y2), int(rotated_x1) : int(rotated_x2)
-            ]
-
-            # restore x, y, le and re before border added
-            x = x - width_border
-            y = y - height_border
-            # w and h will not change
-            if left_eye is not None:
-                left_eye = (left_eye[0] - width_border, left_eye[1] - height_border)
-            if right_eye is not None:
-                right_eye = (right_eye[0] - width_border, right_eye[1] - height_border)
-
-        result = DetectedFace(
-            img=detected_face,
-            facial_area=FacialAreaRegion(
-                x=x, y=y, h=h, w=w, confidence=confidence, left_eye=left_eye, right_eye=right_eye
-            ),
-            confidence=confidence,
         )
-        results.append(result)
-    return results
 
+    return [
+        expand_and_align_face(
+            facial_area=facial_area,
+            img=img,
+            align=align,
+            expand_percentage=expand_percentage,
+            width_border=width_border,
+            height_border=height_border
+        )
+        for facial_area in facial_areas
+    ]
+
+def expand_and_align_face(
+    facial_area: FacialAreaRegion, img: np.ndarray,
+    align: bool, expand_percentage: int, width_border: int,
+    height_border: int) -> DetectedFace:
+    x = facial_area.x
+    y = facial_area.y
+    w = facial_area.w
+    h = facial_area.h
+    left_eye = facial_area.left_eye
+    right_eye = facial_area.right_eye
+    confidence = facial_area.confidence
+
+    if expand_percentage > 0:
+        # Expand the facial region height and width by the provided percentage
+        # ensuring that the expanded region stays within img.shape limits
+        expanded_w = w + int(w * expand_percentage / 100)
+        expanded_h = h + int(h * expand_percentage / 100)
+
+        x = max(0, x - int((expanded_w - w) / 2))
+        y = max(0, y - int((expanded_h - h) / 2))
+        w = min(img.shape[1] - x, expanded_w)
+        h = min(img.shape[0] - y, expanded_h)
+
+    # extract detected face unaligned
+    detected_face = img[int(y) : int(y + h), int(x) : int(x + w)]
+    # align original image, then find projection of detected face area after alignment
+    if align is True:  # and left_eye is not None and right_eye is not None:
+        aligned_img, angle = align_img_wrt_eyes(img=img, left_eye=left_eye, right_eye=right_eye)
+
+        rotated_x1, rotated_y1, rotated_x2, rotated_y2 = project_facial_area(
+            facial_area=(x, y, x + w, y + h), angle=angle, size=(img.shape[0], img.shape[1])
+        )
+        detected_face = aligned_img[
+            int(rotated_y1) : int(rotated_y2), int(rotated_x1) : int(rotated_x2)
+        ]
+
+        # restore x, y, le and re before border added
+        x = x - width_border
+        y = y - height_border
+        # w and h will not change
+        if left_eye is not None:
+            left_eye = (left_eye[0] - width_border, left_eye[1] - height_border)
+        if right_eye is not None:
+            right_eye = (right_eye[0] - width_border, right_eye[1] - height_border)
+
+    return DetectedFace(
+        img=detected_face,
+        facial_area=FacialAreaRegion(
+            x=x, y=y, h=h, w=w, confidence=confidence, left_eye=left_eye, right_eye=right_eye
+        ),
+        confidence=confidence,
+    )
 
 def align_img_wrt_eyes(
     img: np.ndarray,
@@ -311,7 +332,16 @@ def align_img_wrt_eyes(
         return img, 0
 
     angle = float(np.degrees(np.arctan2(left_eye[1] - right_eye[1], left_eye[0] - right_eye[0])))
-    img = np.array(Image.fromarray(img).rotate(angle, resample=Image.BICUBIC))
+
+    (h, w) = img.shape[:2]
+    center = (w // 2, h // 2)
+    M = cv2.getRotationMatrix2D(center, angle, 1.0)
+    img = cv2.warpAffine(
+        img, M, (w, h),
+        flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_CONSTANT,
+        borderValue=(0,0,0)
+    )
+
     return img, angle
 
 

deepface/modules/representation.py

@@ -81,6 +81,7 @@ def represent(
             align=align,
             expand_percentage=expand_percentage,
             anti_spoofing=anti_spoofing,
+            max_faces=max_faces,
         )
     else:  # skip
         # Try load. If load error, will raise exception internal