PS|Modularise symmetry code

app.py

@@ -1,13 +1,17 @@
 import gradio as gr
 from utils.face_texture import GetFaceTexture
+from utils.face_symmetry import GetFaceSymmetry
 
 iface = gr.Interface(
     fn=GetFaceTexture().main,
     inputs=gr.inputs.Image(type="pil"),
-    outputs=[gr.outputs.Image(type="pil"),
-             gr.outputs.Image(type="pil"),
-             "text"
-             ]
+    outputs=[gr.outputs.Image(type="pil"), gr.outputs.Image(type="pil"), "text"],
 )
 
-iface.launch()
+iface = gr.Interface(
+    fn=GetFaceSymmetry().main,
+    inputs=gr.inputs.Image(type="pil"),
+    outputs=[gr.outputs.Image(type="pil"), "text"],
+)
+
+iface.launch()

parameters.yml

@@ -0,0 +1,3 @@
+face_detection:
+  prototxt: "models/face_detection/deploy.prototxt.txt"
+  model: "models/face_detection/res10_300x300_ssd_iter_140000.caffemodel"

requirements.txt

@@ -4,4 +4,4 @@ scikit-image==0.21.0
 dlib==19.24.2
 imutils==0.5.4
 pillow==9.4.0
-pyyaml==6.0
+pyyaml==6.0

utils/face_symmetry.py

@@ -1,5 +1,142 @@
-#TODO: create YAML file to point towards static parameters
-#TODO: Test main output and app
-#TODO: Consider using other method for face detector - this one not as reliable
-#TODO: Text output showing other examples - celeb, child, gender
-#TODO: Move notebooks here
+import cv2
+import numpy as np
+from utils.cv_utils import get_image
+from typing import Tuple, List, Union
+from skimage.metrics import structural_similarity as ssim
+from scipy.spatial import distance
+from sklearn.metrics import mean_squared_error, mean_absolute_error
+from PIL import Image as PILImage
+import yaml
+
+with open("parameters.yml", "r") as stream:
+    try:
+        parameters = yaml.safe_load(stream)
+    except yaml.YAMLError as exc:
+        print(exc)
+
+
+class GetFaceSymmetry:
+    def __init__(self):
+        pass
+
+    def get_faces(self, image: np.array) -> np.array:
+        self.h, self.w = image.shape[:2]
+        blob = cv2.dnn.blobFromImage(image=image, scalefactor=1.0, size=(300, 300))
+        net = cv2.dnn.readNetFromCaffe(
+            parameters["face_detection"]["prototxt"],
+            parameters["face_detection"]["model"],
+        )
+        net.setInput(blob)
+        detections = net.forward()
+        return detections
+
+    @staticmethod
+    def postprocess_face(face: np.array) -> np.array:
+        face = cv2.cvtColor(face, cv2.COLOR_BGR2GRAY)
+        face = cv2.equalizeHist(face)  # remove illumination
+        face = cv2.GaussianBlur(face, (5, 5), 0)  # remove noise
+        return face
+
+    @staticmethod
+    def get_face_halves(face: np.array) -> Tuple:
+        mid = face.shape[1] // 2
+        left_half = face[:, :mid]
+        right_half = face[:, mid:]
+        right_half = cv2.resize(right_half, (left_half.shape[1], left_half.shape[0]))
+        right_half = cv2.flip(right_half, 1)
+        return left_half, right_half
+
+    @staticmethod
+    def histogram_performance(
+        left_half: np.array, right_half: np.array
+    ) -> List[Union[float, float, float, float]]:
+        hist_left = cv2.calcHist([left_half], [0], None, [256], [0, 256])
+        hist_right = cv2.calcHist([right_half], [0], None, [256], [0, 256])
+
+        # Normalize histograms
+        hist_left /= hist_left.sum()
+        hist_right /= hist_right.sum()
+        correlation = cv2.compareHist(hist_left, hist_right, cv2.HISTCMP_CORREL)
+        chi_square = cv2.compareHist(hist_left, hist_right, cv2.HISTCMP_CHISQR)
+        intersection = cv2.compareHist(hist_left, hist_right, cv2.HISTCMP_INTERSECT)
+        bhattacharyya = cv2.compareHist(
+            hist_left, hist_right, cv2.HISTCMP_BHATTACHARYYA
+        )
+
+        return correlation, chi_square, intersection, bhattacharyya
+
+    @staticmethod
+    def orb_detector(left_half: np.array, right_half: np.array) -> int:
+        """The fewer the matches (or the greater the average distance), the more dissimilar the images"""
+
+        orb = cv2.ORB_create()
+        keypoints_left, descriptors_left = orb.detectAndCompute(left_half, None)
+        keypoints_right, descriptors_right = orb.detectAndCompute(right_half, None)
+        bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
+        matches = bf.match(descriptors_left, descriptors_right)
+        matches = sorted(matches, key=lambda x: x.distance)
+        return len(matches)
+
+    def get_face_similarity_results(
+        self, left_half: np.array, right_half: np.array
+    ) -> dict:
+        structural_similarity, _ = ssim(left_half, right_half, full=True)
+        cosine_distance = distance.cosine(left_half.ravel(), right_half.ravel())
+        mse = mean_squared_error(left_half, right_half)
+        mae = mean_absolute_error(left_half, right_half)
+        (
+            correlation,
+            chi_square,
+            intersection,
+            bhattacharyya,
+        ) = self.histogram_performance(left_half, right_half)
+        matches = self.orb_detector(left_half, right_half)
+        pixel_difference = np.sum((left_half - right_half) ** 2)
+
+        d = {
+            "structural_similarity": structural_similarity,
+            "cosine_distance": cosine_distance,
+            "mse": mse,
+            "mae": mae,
+            "histogram_correlation": correlation,
+            "histogram_intersection": intersection,
+            "orb_detector_matches": matches,
+            "pixel_difference": pixel_difference,
+        }
+        return d
+
+    def main(self, image_input):
+        image = get_image(image_input)
+        detections = self.get_faces(image)
+        lowest_mse = float("inf")
+        best_face_data, best_left_half, best_right_half = None, None, None
+        for i in range(0, detections.shape[2]):
+            confidence = detections[0, 0, i, 2]
+            if confidence > 0.99:
+                box = detections[0, 0, i, 3:7] * np.array(
+                    [self.w, self.h, self.w, self.h]
+                )
+                (startX, startY, endX, endY) = box.astype("int")
+                face = image[startY:endY, startX:endX]
+                face = self.postprocess_face(face)
+                left_half, right_half = self.get_face_halves(face)
+                d = self.get_face_similarity_results(left_half, right_half)
+
+            if d["mse"] < lowest_mse:
+                best_face_data, best_left_half, best_right_half = (
+                    d,
+                    left_half,
+                    right_half,
+                )
+                lowest_mse = d["mse"]
+
+        full_face = np.hstack((best_left_half, best_right_half))
+        full_face = PILImage.fromarray(full_face)
+
+        return full_face, best_face_data
+
+
+if __name__ == "__main__":
+    image_path = "data/images_symmetry/gigi_hadid.webp"
+    results = GetFaceSymmetry().main(image_path)
+    print(results)

utils/face_texture.py

@@ -1,48 +1,57 @@
 import cv2
 import numpy as np
 from skimage.feature import local_binary_pattern
-import matplotlib.pyplot as plt
 import dlib
 import imutils
-import os
-from PIL import Image
+from PIL import Image as PILImage
 from utils.cv_utils import get_image
-from typing import Tuple
+from typing import Tuple, List, Union
 
 
 class GetFaceTexture:
     def __init__(self) -> None:
         pass
-    
-    def preprocess_image(self, image) -> np.array:
-        image = imutils.resize(image, width=400)
+
+    @staticmethod
+    def preprocess_image(image) -> np.array:
+        image = imutils.resize(image, width=300)
         gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         return gray_image
-    
-    def get_face(self, gray_image: np.array) -> np.array:
+
+    @staticmethod
+    def get_face(gray_image: np.array) -> np.array:
         detector = dlib.get_frontal_face_detector()
         faces = detector(gray_image, 1)
         if len(faces) == 0:
             return "No face detected."
 
-        x, y, w, h = (faces[0].left(), faces[0].top(), faces[0].width(), faces[0].height())
-        face_image = gray_image[y:y+h, x:x+w]
+        x, y, w, h = (
+            faces[0].left(),
+            faces[0].top(),
+            faces[0].width(),
+            faces[0].height(),
+        )
+        face_image = gray_image[y: y + h, x: x + w]
         return face_image
-    
-    def get_face_texture(self, face_image: np.array) -> Tuple[np.array, float]:
+
+    @staticmethod
+    def get_face_texture(face_image: np.array) -> Tuple[np.array, float]:
         radius = 1
         n_points = 8 * radius
         lbp = local_binary_pattern(face_image, n_points, radius, method="uniform")
-        hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, n_points + 3), range=(0, n_points + 2))
+        hist, _ = np.histogram(
+            lbp.ravel(), bins=np.arange(0, n_points + 3), range=(0, n_points + 2)
+        )
         variance = np.var(hist)
         std = np.sqrt(variance)
         return lbp, std
-    
-    def postprocess_image(self, lbp: np.array) -> Image:
+
+    @staticmethod
+    def postprocess_image(lbp: np.array) -> PILImage:
         lbp = (lbp * 255).astype(np.uint8)
-        return Image.fromarray(lbp)
-    
-    def main(self, image_input) -> Image:
+        return PILImage.fromarray(lbp)
+
+    def main(self, image_input) -> List[Union[PILImage.Image, np.array, float]]:
         image = get_image(image_input)
         gray_image = self.preprocess_image(image)
         face_image = self.get_face(gray_image)
@@ -51,6 +60,6 @@ class GetFaceTexture:
         return face_texture_image, face_image, std
 
 
-if __name__ == "__main__":    
-    image_path = 'data/images_symmetry/gigi_hadid.webp'
+if __name__ == "__main__":
+    image_path = "data/images_symmetry/gigi_hadid.webp"
     print(GetFaceTexture().main(image_path))