PS | Add face comparison feature

app.py

@@ -1,51 +1,142 @@
 import gradio as gr
 import os
 import yaml
+import pandas as pd
 from src.face_texture import GetFaceTexture
 from src.face_symmetry import GetFaceSymmetry
 from src.face_demographics import GetFaceDemographics
 from src.face_proportions import GetFaceProportions
+from PIL import Image as PILImage
+from typing import List, Any
 
 
-def combined_fn(input_image, input_image_2):
-    demographics_dict = GetFaceDemographics().main(input_image)
-    golden_ratios_dict, equal_ratios_dict, face_landmarks_image = GetFaceProportions().main(input_image)
-    face_symmetry_image, symmetry_dict = GetFaceSymmetry().main(input_image)
-    face_image, face_texture_image, texture_dict = GetFaceTexture().main(input_image)
-    
+def get_results(image_input: PILImage.Image) -> List[Any]:
+    demographics_dict = GetFaceDemographics().main(image_input)
+    (
+        ratios_dict,
+        face_landmarks_image,
+    ) = GetFaceProportions().main(image_input)
+    face_symmetry_image, symmetry_dict = GetFaceSymmetry().main(image_input)
+    face_image, face_texture_image, texture_dict = GetFaceTexture().main(image_input)
+
     results = {
         "Demographic predictions": demographics_dict,
-        "Face proportions (golden ratio)": golden_ratios_dict,
-        "Face proportions (equal ratio)": equal_ratios_dict,
+        "Face proportions": ratios_dict,
         "Face symmetry metrics": symmetry_dict,
-        "Face texture metrics": texture_dict
+        "Face texture metrics": texture_dict,
     }
-    with open("parameters.yml", 'r') as file:
+
+    return (
+        results,
+        face_image,
+        face_landmarks_image,
+        face_symmetry_image,
+        face_texture_image,
+    )
+
+
+def concatenate_image(
+    image_1: PILImage.Image, image_2: PILImage.Image
+) -> PILImage.Image:
+    image = PILImage.new("RGB", (image_1.width + image_2.width, image_1.height))
+    image.paste(image_1, (0, 0))
+    image.paste(image_2, (image_1.width, 0))
+    return image
+
+
+def get_dict_child_data(results_image: dict, image_number: int) -> dict:
+    flattened_data = {"image": f"Face {image_number}"}
+    for key, sub_dict in results_image.items():
+        for sub_key, value in sub_dict.items():
+            flattened_data[sub_key] = value
+    return flattened_data
+
+
+def output_fn(
+    image_input_1: PILImage.Image, image_input_2: PILImage.Image
+) -> List[Any]:
+    with open("parameters.yml", "r") as file:
         data = yaml.safe_load(file)
         results_interpretation = data["results_interpretation"]
-    
-    return (results, results_interpretation, face_image, face_landmarks_image, face_symmetry_image, face_texture_image)
+
+    if image_input_1 is not None and image_input_2 is not None:
+        (
+            results_image_1,
+            face_image_1,
+            face_landmarks_image_1,
+            face_symmetry_image_1,
+            face_texture_image_1,
+        ) = get_results(image_input_1)
+        (
+            results_image_2,
+            face_image_2,
+            face_landmarks_image_2,
+            face_symmetry_image_2,
+            face_texture_image_2,
+        ) = get_results(image_input_2)
+        results_image_1, results_image_2 = get_dict_child_data(
+            results_image_1, 1
+        ), get_dict_child_data(results_image_2, 2)
+        results_df = pd.DataFrame([results_image_1, results_image_2])
+        face_image = concatenate_image(face_image_1, face_image_2)
+        face_landmarks_image = concatenate_image(
+            face_landmarks_image_1, face_landmarks_image_2
+        )
+        face_symmetry_image = concatenate_image(
+            face_symmetry_image_1, face_symmetry_image_2
+        )
+        face_texture_image = concatenate_image(
+            face_texture_image_1, face_texture_image_2
+        )
+
+    if image_input_1 == None and image_input_2 is not None:
+        (
+            results,
+            face_image,
+            face_landmarks_image,
+            face_symmetry_image,
+            face_texture_image,
+        ) = get_results(image_input_2)
+        results_df = pd.DataFrame([get_dict_child_data(results, 2)])
+
+    if image_input_2 == None and image_input_1 is not None:
+        (
+            results,
+            face_image,
+            face_landmarks_image,
+            face_symmetry_image,
+            face_texture_image,
+        ) = get_results(image_input_1)
+        results_df = pd.DataFrame([get_dict_child_data(results, 1)])
+
+    return (
+        results_df,
+        results_interpretation,
+        face_image,
+        face_landmarks_image,
+        face_symmetry_image,
+        face_texture_image,
+    )
+
 
 gigi_hadid = os.path.join(os.path.dirname(__file__), "data/gigi_hadid.webp")
-jay_z = os.path.join(os.path.dirname(__file__), "data/jay_z.jpg")
 
 iface = gr.Interface(
-    fn=combined_fn,
+    fn=output_fn,
     inputs=[
-        gr.Image(type="pil", label="Upload Face 1", value=jay_z),
-        gr.Image(type="pil", label="Upload Face 2", value=gigi_hadid)
-            ],
+        gr.Image(type="pil", label="Upload Face 1", value=gigi_hadid),
+        gr.Image(type="pil", label="Upload Face 2"),
+    ],
     outputs=[
-        gr.JSON(label="Results"),
+        gr.DataFrame(label="Results"),
         gr.JSON(label="Results explainer"),
         gr.Image(type="pil", label="Extracted face"),
         gr.Image(type="pil", label="Face landmarks"),
         gr.Image(type="pil", label="Face symmetry"),
-        gr.Image(type="pil", label="Extracted face texture"),         
+        gr.Image(type="pil", label="Extracted face texture"),
     ],
     title="Advanced Facial Feature Detector",
-    description=
-    """
+    description="""
     <!DOCTYPE html>
     <html lang="en">
     <head>
@@ -59,18 +150,21 @@ iface = gr.Interface(
         </style>
     </head>
     <body>
-    
+
     <div class="section">
-        <p><strong>Description:</strong> This tool analyses a facial image to predict age and gender, assess symmetry, evaluate proportions, and examine texture.</p>
-        <p><strong>Instructions:</strong> For optimal results, upload a clear front-facing image (see example image). To do so, either drag and drop your photo or click on "Upload Face Image", then press 'Submit'.</p>
-        <p><strong>Interpreting the results:</strong></p>
+        <font size="3">
+        <h3><center>Turn your selfie into insights! Discover age and gender predictions, symmetry evaluations, and detailed proportions and texture analyses with our app.</center></h3>
+        <hr style="margin-top: 20px; margin-bottom: 20px;">
+        <p><strong>Instructions:</strong> Upload up to 2 photos. For optimal results, upload a clear front-facing image (see example). To do so, either drag and drop your photo or click <i>Upload Face</i>, then press <i>Submit</i>.</p>
         <p><strong>Other information:</strong></p>
         <ul>
+            <li>The output computation requires approximately 5 to 30 seconds.</li>
             <li>No uploaded photo is stored.</li>
-            <li>The output will take several seconds to compute.</li>
             <li>If an error occurs try again or try a different photo or angle.</li>
+            <li>Once submitted, a section detailing the results and associated images will be displayed.</li>
         </ul>
-    </div> 
+        </font>  
+    </div>
     </body>
     </html>
     """,

notebooks/own-photos-symmetry.ipynb

@@ -910,13 +910,6 @@
    "source": [
     "df.sort_values(\"mse\") "
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

parameters.yml

@@ -15,15 +15,12 @@ results_interpretation:
     age_confidence: "Confidence of age prediction (0-1)"
     gender: "Predicted gender"
     gender_confidence: "Confidence of gender prediction (0-1)"
-  Face proportions (golden ratio):
-    Ideal ratio (golden ratio): "The ideal facial proportion ratio according to the classical Greek work on maths and geometry. Ideal facial features ratios in this section should be 1:1.62 (the golden ratio)"
-    Top of nose to middle of mouth vs middle mouth to bottom of chin: "See description"
-    Middle of mouth to bottom of mouth vs top of mouth to middle of mouth: "See description"
-  Face proportions (equal ratio):
-    Ideal ratio: "Typical facial features ratios in this section should be 1:1 (equal ratio)"
-    Eye width vs distance between eyes: "See description"
-    Eye to eyebrows vs eye height: "See description"
-    Center of left to right eye vs mouth width: "See description"
+  Face proportions:
+    top_of_nose_to_middle_of_mouth_vs_middle_mouth_to_bottom_of_chin: "Ideal value is 1.62 (golden ratio - from classical Greek work on maths and geometry)"
+    middle_of_mouth_to_bottom_of_mouth_vs_top_of_mouth_to_middle_of_mouth: "Ideal value is 1.62 (golden ratio - from classical Greek work on maths and geometry)"
+    eye_width_vs_distance_between_eyes: "Ideal value is 1"
+    eye_to_eyebrows_vs_eye_height: "Ideal value is 1"
+    center_of_left_to_right_eye_vs_mouth_width: "Ideal value is 1"
   Face symmetry metrics:
     structural_similarity: "Range: -1 (opposite) to 1 (similar). Considers differences in structural information, luminance, and texture."
     cosine_distance: "Ranges: -1 to 1. 0 =similar, -1 or 1 = not similar. Considers differences in pixels."
@@ -34,4 +31,4 @@ results_interpretation:
     orb_detector_matches: "Higher is better. Counts the number of matches between keypoints in images."
     pixel_difference: "Lower is better.  Minimum value is 0, maximum is unbounded."
   Face texture metrics:
-    Texture std: "Lower means less varied facial texture. Minimum is 0, maximum is unbounded."
+    texture_std: "Lower means less varied facial texture. Minimum is 0, maximum is unbounded."

requirements.txt

@@ -8,3 +8,4 @@ pyyaml==6.0
 scikit-learn==1.2.2
 transformers==4.33.3
 torch==2.0.1
+pandas==1.5.3

src/cv_utils.py

@@ -16,4 +16,4 @@ def resize_image_height(image: PILImage.Image, new_height=300) -> PILImage.Image
     aspect_ratio = image.width / image.height
     new_width = int(aspect_ratio * new_height)
     image = image.resize((new_width, new_height))
-    return image
+    return image

src/face_demographics.py

@@ -18,38 +18,57 @@ with open("parameters.yml", "r") as stream:
 class GetFaceDemographics:
     def __init__(self):
         pass
-    
+
     @staticmethod
     def preprocess_image_for_caffe_cnn(image: np.array):
-        model_mean = (78.4263377603, 87.7689143744, 114.895847746) # taken from the model page on Caffe
+        model_mean = (
+            78.4263377603,
+            87.7689143744,
+            114.895847746,
+        )  # taken from the model page on Caffe
         blob = cv2.dnn.blobFromImage(image, 1.0, (227, 227), model_mean, swapRB=False)
         return blob
-        
+
     @staticmethod
     def get_age_cnn(blob) -> Tuple:
-        age_net = cv2.dnn.readNet(parameters["face_age"]["config"], parameters["face_age"]["model"])
-        age_list = ['(0-2)', '(4-6)', '(8-12)', '(15-20)', '(25-32)', '(38-43)', '(48-53)', '(60-100)']
+        age_net = cv2.dnn.readNet(
+            parameters["face_age"]["config"], parameters["face_age"]["model"]
+        )
+        age_list = [
+            "(0-2)",
+            "(4-6)",
+            "(8-12)",
+            "(15-20)",
+            "(25-32)",
+            "(38-43)",
+            "(48-53)",
+            "(60-100)",
+        ]
         age_net.setInput(blob)
         age_preds = age_net.forward()
         i = age_preds[0].argmax()
         age = age_list[i]
         age_confidence_score = age_preds[0][i]
         return age, age_confidence_score
-    
+
     @staticmethod
     def get_gender_cnn(blob) -> Tuple:
-        gender_net = cv2.dnn.readNet(parameters["face_gender"]["config"], parameters["face_gender"]["model"])
-        gender_list = ['Male', 'Female']
+        gender_net = cv2.dnn.readNet(
+            parameters["face_gender"]["config"], parameters["face_gender"]["model"]
+        )
+        gender_list = ["Male", "Female"]
         gender_net.setInput(blob)
         gender_preds = gender_net.forward()
         i = gender_preds[0].argmax()
         gender = gender_list[i]
         gender_confidence_score = gender_preds[0][i]
         return gender, gender_confidence_score
-    
+
     @staticmethod
     def get_age_vit(image: np.array) -> Tuple:
-        os.environ["CURL_CA_BUNDLE"] = ""  # fixes VPN issue when connecting to hugging face hub
+        os.environ[
+            "CURL_CA_BUNDLE"
+        ] = ""  # fixes VPN issue when connecting to hugging face hub
         urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
         id2label = {
             0: "0-2",
@@ -60,52 +79,59 @@ class GetFaceDemographics:
             5: "40-49",
             6: "50-59",
             7: "60-69",
-            8: "more than 70"
+            8: "more than 70",
         }
-        model = ViTForImageClassification.from_pretrained('nateraw/vit-age-classifier')
-        transforms = ViTImageProcessor.from_pretrained('nateraw/vit-age-classifier')
-        inputs = transforms(image, return_tensors='pt')
+        model = ViTForImageClassification.from_pretrained("nateraw/vit-age-classifier")
+        transforms = ViTImageProcessor.from_pretrained("nateraw/vit-age-classifier")
+        inputs = transforms(image, return_tensors="pt")
         output = model(**inputs)
         proba = output.logits.softmax(1)
-        preds = proba.argmax(1)  
+        preds = proba.argmax(1)
         age_confidence_score = round(max(proba[0]).item(), 2)
         age = id2label[int(preds)]
         return age, age_confidence_score
-    
+
     @staticmethod
     def get_gender_vit(image: np.array) -> Tuple:
-        os.environ["CURL_CA_BUNDLE"] = ""  # fixes VPN issue when connecting to hugging face hub
+        os.environ[
+            "CURL_CA_BUNDLE"
+        ] = ""  # fixes VPN issue when connecting to hugging face hub
         urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
         id2label = {
             0: "female",
             1: "male",
         }
-        model = ViTForImageClassification.from_pretrained('rizvandwiki/gender-classification')
-        transforms = ViTImageProcessor.from_pretrained('rizvandwiki/gender-classification')
-        inputs = transforms(image, return_tensors='pt')
+        model = ViTForImageClassification.from_pretrained(
+            "rizvandwiki/gender-classification"
+        )
+        transforms = ViTImageProcessor.from_pretrained(
+            "rizvandwiki/gender-classification"
+        )
+        inputs = transforms(image, return_tensors="pt")
         output = model(**inputs)
         proba = output.logits.softmax(1)
-        preds = proba.argmax(1)  
+        preds = proba.argmax(1)
         gender_confidence_score = round(max(proba[0]).item(), 2)
         gender = id2label[int(preds)]
         return gender, gender_confidence_score
 
     def main(self, image_input) -> dict:
-        image = get_image(image_input)      
+        image = get_image(image_input)
         age, age_confidence_score = self.get_age_vit(image)
         gender, gender_confidence_score = self.get_gender_vit(image)
         d = {
             "age_range": age,
             "age_confidence": age_confidence_score,
             "gender": gender,
-            "gender_confidence": gender_confidence_score 
+            "gender_confidence": gender_confidence_score,
         }
         return d
 
+
 if __name__ == "__main__":
     path_to_images = "data/"
     image_files = os.listdir(path_to_images)
     for image in image_files:
         print(image)
         results = GetFaceDemographics().main(path_to_images + image)
-        print(results)
+        print(results)

src/face_proportions.py

@@ -13,12 +13,12 @@ with open("parameters.yml", "r") as stream:
         parameters = yaml.safe_load(stream)
     except yaml.YAMLError as exc:
         print(exc)
-        
-        
+
+
 class GetFaceProportions:
     def __init__(self):
-        self.golden_ratio = 1.618
-    
+        pass
+
     @staticmethod
     def preprocess_image(image: np.array) -> np.array:
         image = imutils.resize(image, width=500)
@@ -27,80 +27,100 @@ class GetFaceProportions:
 
     @staticmethod
     def detect_face_landmarks(gray_image: np.array) -> List[Union[np.array, np.array]]:
-        
+
         detector = dlib.get_frontal_face_detector()
         predictor = dlib.shape_predictor(parameters["face_landmarks"]["model"])
         rects = detector(gray_image, 1)
         for rect in rects:
             shape = predictor(gray_image, rect)
-            shape = np.array([(shape.part(i).x, shape.part(i).y) for i in range(shape.num_parts)])
+            shape = np.array(
+                [(shape.part(i).x, shape.part(i).y) for i in range(shape.num_parts)]
+            )
 
             # Draw facial landmarks
             for (x, y) in shape:
                 cv2.circle(gray_image, (x, y), 2, (0, 255, 0), -1)
-            
+
         return shape, gray_image
-    
-    def compute_golden_ratios(self, shape: np.array) -> dict:
+
+    @staticmethod
+    def compute_golden_ratios(shape: np.array) -> dict:
         top_mouth, middle_mouth, bottom_mouth = shape[51], shape[62], shape[57]
         top_nose, bottom_nose = shape[27], shape[33]
         bottom_chin = shape[8]
-        
+
         # 1
-        top_nose_to_middle_mouth_dist = np.linalg.norm(top_nose - middle_mouth) # euclidean distance
+        top_nose_to_middle_mouth_dist = np.linalg.norm(
+            top_nose - middle_mouth
+        )  # euclidean distance
         middle_mouth_to_bottom_chin_dist = np.linalg.norm(middle_mouth - bottom_chin)
-        ratio_top_nose_to_middle_mouth_vs_middle_mouth_to_bottom_chin = top_nose_to_middle_mouth_dist/middle_mouth_to_bottom_chin_dist
-        
+        ratio_top_nose_to_middle_mouth_vs_middle_mouth_to_bottom_chin = (
+            top_nose_to_middle_mouth_dist / middle_mouth_to_bottom_chin_dist
+        )
+
         # 2
         top_mouth_to_middle_mouth_dist = np.linalg.norm(top_mouth - middle_mouth)
         middle_mouth_to_bottom_mouth_dist = np.linalg.norm(middle_mouth - bottom_mouth)
-        ratio_middle_mouth_to_bottom_mouth_vs_top_mouth_to_middle_mouth = middle_mouth_to_bottom_mouth_dist/top_mouth_to_middle_mouth_dist
-    
+        ratio_middle_mouth_to_bottom_mouth_vs_top_mouth_to_middle_mouth = (
+            middle_mouth_to_bottom_mouth_dist / top_mouth_to_middle_mouth_dist
+        )
+
         golden_ratios = {
-            "Ideal ratio (golden ratio)": self.golden_ratio,
-            "Top of nose to middle of mouth vs middle mouth to bottom of chin": ratio_top_nose_to_middle_mouth_vs_middle_mouth_to_bottom_chin,
-            "Middle of mouth to bottom of mouth vs top of mouth to middle of mouth": ratio_middle_mouth_to_bottom_mouth_vs_top_mouth_to_middle_mouth
+            "top_of_nose_to_middle_of_mouth_vs_middle_mouth_to_bottom_of_chin": ratio_top_nose_to_middle_mouth_vs_middle_mouth_to_bottom_chin,
+            "middle_of_mouth_to_bottom_of_mouth_vs_top_of_mouth_to_middle_of_mouth": ratio_middle_mouth_to_bottom_mouth_vs_top_mouth_to_middle_mouth,
         }
         return golden_ratios
-    
+
     @staticmethod
     def compute_equal_ratios(shape: np.array) -> dict:
-        left_side_left_eye, right_side_left_eye, left_side_right_eye, right_side_right_eye = shape[36], shape[39], shape[42], shape[45]
-        left_eye_top, left_eye_bottom, right_eye_top, right_eye_bottom = shape[37], shape[41], shape[44], shape[46]
+        (
+            left_side_left_eye,
+            right_side_left_eye,
+            left_side_right_eye,
+            right_side_right_eye,
+        ) = (shape[36], shape[39], shape[42], shape[45])
+        left_eye_top, left_eye_bottom, right_eye_top, right_eye_bottom = (
+            shape[37],
+            shape[41],
+            shape[44],
+            shape[46],
+        )
         left_eyebrow_top, right_eyebrow_top = shape[19], shape[24]
         left_eye_center = np.mean([shape[37], shape[38], shape[41], shape[40]], axis=0)
         right_eye_center = np.mean([shape[43], shape[44], shape[47], shape[46]], axis=0)
         left_mouth, right_mouth = shape[48], shape[54]
-        
+
         # 1
         left_eye_dist = np.linalg.norm(left_side_left_eye - right_side_left_eye)
         right_eye_dist = np.linalg.norm(left_side_right_eye - right_side_right_eye)
-        average_eye_dist = (left_eye_dist + right_eye_dist)/2
+        average_eye_dist = (left_eye_dist + right_eye_dist) / 2
         between_eye_dist = np.linalg.norm(right_side_left_eye - left_side_right_eye)
-        ratio_eyes_width_vs_between_eye = average_eye_dist/between_eye_dist
-        
+        ratio_eyes_width_vs_between_eye = average_eye_dist / between_eye_dist
+
         # 2
         left_eye_to_eyebrow_dist = np.linalg.norm(left_eyebrow_top - left_eye_top)
         right_eye_to_eyebrow_dist = np.linalg.norm(right_eyebrow_top - right_eye_top)
-        eye_to_eyebrow_dist = (left_eye_to_eyebrow_dist + right_eye_to_eyebrow_dist)/2
+        eye_to_eyebrow_dist = (left_eye_to_eyebrow_dist + right_eye_to_eyebrow_dist) / 2
         left_eye_height = np.linalg.norm(left_eye_top - left_eye_bottom)
         right_eye_height = np.linalg.norm(right_eye_top - right_eye_bottom)
-        eye_height = (left_eye_height + right_eye_height)/2
-        ratio_eye_to_eyebrow_vs_eye_height = eye_to_eyebrow_dist/eye_height
-        
+        eye_height = (left_eye_height + right_eye_height) / 2
+        ratio_eye_to_eyebrow_vs_eye_height = eye_to_eyebrow_dist / eye_height
+
         # 3
-        left_to_right_eye_center_dist = np.linalg.norm(left_eye_center - right_eye_center)
+        left_to_right_eye_center_dist = np.linalg.norm(
+            left_eye_center - right_eye_center
+        )
         mouth_width = np.linalg.norm(left_mouth - right_mouth)
-        ratio_left_to_right_eye_center_vs_mouth_width = left_to_right_eye_center_dist/mouth_width
-        
+        ratio_left_to_right_eye_center_vs_mouth_width = (
+            left_to_right_eye_center_dist / mouth_width
+        )
+
         equal_ratios = {
-            "Ideal ratio": 1,
-            "Eye width vs distance between eyes": ratio_eyes_width_vs_between_eye,
-            "Eye to eyebrows vs eye height": ratio_eye_to_eyebrow_vs_eye_height,
-            "Center of left to right eye vs mouth width": ratio_left_to_right_eye_center_vs_mouth_width
+            "eye_width_vs_distance_between_eyes": ratio_eyes_width_vs_between_eye,
+            "eye_to_eyebrows_vs_eye_height": ratio_eye_to_eyebrow_vs_eye_height,
+            "center_of_left_to_right_eye_vs_mouth_width": ratio_left_to_right_eye_center_vs_mouth_width,
         }
         return equal_ratios
-        
 
     def main(self, image_input):
         image = get_image(image_input)
@@ -110,10 +130,11 @@ class GetFaceProportions:
         golden_ratios = {k: round(v, 2) for k, v in golden_ratios.items()}
         equal_ratios = self.compute_equal_ratios(shape)
         equal_ratios = {k: round(v, 2) for k, v in equal_ratios.items()}
-        image = PILImage.fromarray(image)     
+        image = PILImage.fromarray(image)
         image = resize_image_height(image, new_height=300)
-        return golden_ratios, equal_ratios, image
-        
+        ratios = {**golden_ratios, **equal_ratios}
+        return ratios, image
+
 
 if __name__ == "__main__":
     path_to_images = "data/"
@@ -121,4 +142,4 @@ if __name__ == "__main__":
     for image in image_files:
         print(image)
         results = GetFaceProportions().main(path_to_images + image)
-        print(results)
+        print(results)

src/face_symmetry.py

@@ -118,7 +118,9 @@ class GetFaceSymmetry:
                 )
                 (startX, startY, endX, endY) = box.astype("int")
                 face = image[startY:endY, startX:endX]
-                if face.shape[0] != 0: # temp fix bug where image of dim (0, 0, 3) appear
+                if (
+                    face.shape[0] != 0
+                ):  # temp fix bug where image of dim (0, 0, 3) appear
                     face = self.postprocess_face(face)
                     left_half, right_half = self.get_face_halves(face)
                     d = self.get_face_similarity_results(left_half, right_half)
@@ -133,7 +135,7 @@ class GetFaceSymmetry:
 
         full_face = np.hstack((best_left_half, best_right_half))
         full_face_image = PILImage.fromarray(full_face)
-        full_face_image = resize_image_height(full_face_image, new_height=300) 
+        full_face_image = resize_image_height(full_face_image, new_height=300)
         best_face_data = {k: float(round(v, 2)) for k, v in best_face_data.items()}
         return full_face_image, best_face_data
 

src/face_texture.py

@@ -31,7 +31,7 @@ class GetFaceTexture:
             faces[0].width(),
             faces[0].height(),
         )
-        face_image = gray_image[y: y + h, x: x + w]
+        face_image = gray_image[y : y + h, x : x + w]
         return face_image
 
     @staticmethod
@@ -58,9 +58,9 @@ class GetFaceTexture:
         lbp, std = self.get_face_texture(face_image)
         face_texture_image = self.postprocess_image(lbp)
         face_image = PILImage.fromarray(face_image)
-        face_image = resize_image_height(face_image, new_height=300)   
-        face_texture_image = resize_image_height(face_texture_image, new_height=300)    
-        return face_image, face_texture_image, {"Texture std": round(std, 2)}
+        face_image = resize_image_height(face_image, new_height=300)
+        face_texture_image = resize_image_height(face_texture_image, new_height=300)
+        return face_image, face_texture_image, {"texture_std": round(std, 2)}
 
 
 if __name__ == "__main__":