PS|Added face texture module

app.py

@@ -1,13 +1,13 @@
 import gradio as gr
-from cv_utils.facial_texture import compute_face_simplicity
-
-def identity_function(input_image):
-    return input_image
+from utils.face_texture import GetFaceTexture
 
 iface = gr.Interface(
-    fn=compute_face_simplicity,
+    fn=GetFaceTexture().main,
     inputs=gr.inputs.Image(type="pil"),
-    outputs=gr.outputs.Image(type="pil")
+    outputs=[gr.outputs.Image(type="pil"),
+             gr.outputs.Image(type="pil"),
+             "text"
+             ]
 )
 
 iface.launch()

cv_utils/facial_texture.py

@@ -1,77 +0,0 @@
-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
-
-
-def compute_face_simplicity(image):
-    
-    ######## create if or depending on input - filepath or PIL file
-    # Load the image from a filepath
-    # image = cv2.imread(image_path)
-    
-    # Convert RGB to BGR format (OpenCV uses BGR while PIL uses RGB)
-    image_np = np.array(image)
-    image = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
-
-    # Resize the image
-    image = imutils.resize(image, width=800)
-
-    # Convert to grayscale
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    
-    detector = dlib.get_frontal_face_detector()
-    predictor = dlib.shape_predictor("models/face_alignment/shape_predictor_68_face_landmarks.dat")
-    
-    # Detect the face in the image
-    faces = detector(gray, 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_img = gray[y:y+h, x:x+w]
-    
-    
-    # Parameters for LBP
-    radius = 1
-    n_points = 8 * radius
-    
-    # Apply LBP to the face region
-    lbp = local_binary_pattern(face_img, n_points, radius, method="uniform")
-    
-    # Compute the histogram of the LBP
-    hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, n_points + 3), range=(0, n_points + 2))
-    
-    # Measure the variance of the histogram
-    variance = np.var(hist)
-    std = np.sqrt(variance)
-    print(std)
-    
-    # A hypothetical threshold - needs calibration
-    threshold = 10000
-    
-    if std < threshold:
-        simplicity = "Simple"
-    else:
-        simplicity = "Complex"
-    
-    # Visualizing the LBP pattern on the detected face
-    # plt.imshow(lbp)
-    lbp = (lbp * 255).astype(np.uint8)
-    lbp = Image.fromarray(lbp)
-    
-    return lbp #, simplicity
-
-
-if __name__ == "__main__":
-    print(os.getcwd())
-    detector = dlib.get_frontal_face_detector()
-    predictor = dlib.shape_predictor("models/face_alignment/shape_predictor_68_face_landmarks.dat")
-    print(predictor)
-    
-    image_path = 'data/images_symmetry/gigi_hadid.webp'
-    print(compute_face_simplicity(image_path))

utils/cv_utils.py

@@ -0,0 +1,11 @@
+import cv2
+import numpy as np
+
+
+def get_image(image_input) -> np.array:
+    """Outputs numpy array of image given a string filepath or PIL image"""
+    if type(image_input) == str:
+        image = cv2.imread(image_input)  # OpenCV uses BGR
+    else:
+        image = cv2.cvtColor(np.array(image_input), cv2.COLOR_RGB2BGR)  # PIL uses RGB
+    return image

utils/face_texture.py

@@ -0,0 +1,63 @@
+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 utils.cv_utils import get_image
+from typing import Tuple
+
+
+#TODO: face texture class - face detector and output face
+#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
+
+
+class GetFaceTexture:
+    def __init__(self) -> None:
+        pass
+    
+    def preprocess_image(self, image) -> np.array:
+        image = imutils.resize(image, width=800)
+        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        return gray_image
+    
+    def get_face(self, 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]
+        return face_image
+    
+    def get_face_texture(self, 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))
+        variance = np.var(hist)
+        std = np.sqrt(variance)
+        return lbp, std
+    
+    def postprocess_image(self, lbp: np.array) -> Image:
+        lbp = (lbp * 255).astype(np.uint8)
+        return Image.fromarray(lbp)
+    
+    def main(self, image_input) -> Image:
+        image = get_image(image_input)
+        gray_image = self.preprocess_image(image)
+        face_image = self.get_face(gray_image)
+        lbp, std = self.get_face_texture(face_image)
+        face_texture_image = self.postprocess_image(lbp)
+        return face_texture_image, face_image, std
+
+
+if __name__ == "__main__":    
+    image_path = 'data/images_symmetry/gigi_hadid.webp'
+    print(GetFaceTexture().main(image_path))