added histograms to aid visualisation

.gitignore

@@ -5,3 +5,4 @@ venv/
 workspace/
 *.pyc
 temp.jpg
+.vscode/settings.json

app.py

@@ -57,6 +57,15 @@ def process_image(
         if "filtered_skin_mask" in skin_analysis:
             filtered_skin_mask = skin_analysis["filtered_skin_mask"]
             del skin_analysis["filtered_skin_mask"]
+        elif "l_hist" in skin_analysis:
+            l_hist = skin_analysis["l_hist"]
+            del skin_analysis["l_hist"]
+        elif "tonality_l_hist" in skin_analysis:
+            tonality_l_hist = skin_analysis["tonality_l_hist"]
+            del skin_analysis["tonality_l_hist"]
+        elif "chroma_hist" in skin_analysis:
+            chroma_hist = skin_analysis["chroma_hist"]
+            del skin_analysis["chroma_hist"]
         analysis_results["skin_analysis"] = skin_analysis
 
         # overlay_images.append(skin_analysis["overlay_image"])
@@ -76,33 +85,174 @@ def process_image(
     # Convert combined_overlay to PIL Image for display
     combined_overlay = Image.fromarray(overlay)
 
-    return combined_overlay, analysis_results
-
-
-# Define Gradio interface
-iface = gr.Interface(
-    fn=process_image,
-    inputs=[
-        gr.Image(type="numpy", label="Upload an Image"),
-        gr.Slider(minimum=0, maximum=100, value=10, label="L% Min Skin"),
-        gr.Slider(minimum=0, maximum=100, value=90, label="L% Max Skin"),
-        gr.Slider(minimum=0, maximum=100, value=10, label="L% Min Tonality"),
-        gr.Slider(minimum=0, maximum=100, value=90, label="L% Max Tonality"),
-        gr.Slider(minimum=0, maximum=255, value=20, label="Chroma Threshold"),
-        gr.Checkbox(label="Skin Analysis", value=True),
-        gr.Checkbox(label="Eye Analysis", value=False),
-        gr.Checkbox(label="Hair Analysis", value=False),
-    ],
-    outputs=[
-        gr.Image(type="pil", label="Processed Image"),
-        gr.JSON(label="Analysis Results"),
-    ],
-    allow_flagging="manual",
-    flagging_dir="flagged",
-    flagging_options=["Save", "Hard One"],
-    title="Color Palette Analysis",
-    description="Upload an image to analyze the skin, hair, and eye colors. Select the analyses you want to perform.",
-)
-
-# Launch the Gradio interface
-iface.launch(share=True)
+    return combined_overlay, analysis_results, l_hist, tonality_l_hist, chroma_hist
+
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            upload_image = gr.Image(type="numpy", label="Upload an Image")
+        with gr.Column():
+            l_min_slider = gr.Slider(
+                minimum=0, maximum=100, value=10, label="L(%) Min Skin"
+            )
+            l_hist_output = gr.Image(type="pil", label="L Histogram")
+        with gr.Column():
+            l_max_slider = gr.Slider(
+                minimum=0, maximum=100, value=90, label="L(%) Max Skin"
+            )
+        with gr.Column():
+            tonality_min_slider = gr.Slider(
+                minimum=0, maximum=100, value=50, label="L(%) Min Tonality"
+            )
+            tonality_hist_output = gr.Image(type="pil", label="Tonality L Histogram")
+        with gr.Column():
+            tonality_max_slider = gr.Slider(
+                minimum=0, maximum=100, value=70, label="L(%) Max Tonality"
+            )
+        with gr.Column():
+            chroma_slider = gr.Slider(
+                minimum=0, maximum=100, value=50, label="Chroma(%) Threshold"
+            )
+            chroma_hist_output = gr.Image(type="pil", label="Chroma Histogram")
+    with gr.Row():
+        skin_checkbox = gr.Checkbox(label="Skin Analysis", value=True)
+        eye_checkbox = gr.Checkbox(label="Eye Analysis", value=False)
+        hair_checkbox = gr.Checkbox(label="Hair Analysis", value=False)
+    analysis_results_output = gr.JSON(label="Analysis Results")
+    processed_image_output = gr.Image(type="pil", label="Processed Image")
+
+    gr.Interface(
+        fn=process_image,
+        inputs=[
+            upload_image,
+            l_min_slider,
+            l_max_slider,
+            tonality_min_slider,
+            tonality_max_slider,
+            chroma_slider,
+            skin_checkbox,
+            eye_checkbox,
+            hair_checkbox,
+        ],
+        outputs=[
+            processed_image_output,
+            l_hist_output,
+            tonality_hist_output,
+            chroma_hist_output,
+            analysis_results_output,
+        ],
+    )
+
+    # Set up change event triggers for the sliders
+    l_min_slider.change(
+        process_image,
+        inputs=[
+            upload_image,
+            l_min_slider,
+            l_max_slider,
+            tonality_min_slider,
+            tonality_max_slider,
+            chroma_slider,
+            skin_checkbox,
+            eye_checkbox,
+            hair_checkbox,
+        ],
+        outputs=[
+            processed_image_output,
+            l_hist_output,
+            tonality_hist_output,
+            chroma_hist_output,
+            analysis_results_output,
+        ],
+    )
+
+    l_max_slider.change(
+        process_image,
+        inputs=[
+            upload_image,
+            l_min_slider,
+            l_max_slider,
+            tonality_min_slider,
+            tonality_max_slider,
+            chroma_slider,
+            skin_checkbox,
+            eye_checkbox,
+            hair_checkbox,
+        ],
+        outputs=[
+            processed_image_output,
+            l_hist_output,
+            tonality_hist_output,
+            chroma_hist_output,
+            analysis_results_output,
+        ],
+    )
+
+    tonality_min_slider.change(
+        process_image,
+        inputs=[
+            upload_image,
+            l_min_slider,
+            l_max_slider,
+            tonality_min_slider,
+            tonality_max_slider,
+            chroma_slider,
+            skin_checkbox,
+            eye_checkbox,
+            hair_checkbox,
+        ],
+        outputs=[
+            processed_image_output,
+            l_hist_output,
+            tonality_hist_output,
+            chroma_hist_output,
+            analysis_results_output,
+        ],
+    )
+
+    tonality_max_slider.change(
+        process_image,
+        inputs=[
+            upload_image,
+            l_min_slider,
+            l_max_slider,
+            tonality_min_slider,
+            tonality_max_slider,
+            chroma_slider,
+            skin_checkbox,
+            eye_checkbox,
+            hair_checkbox,
+        ],
+        outputs=[
+            processed_image_output,
+            l_hist_output,
+            tonality_hist_output,
+            chroma_hist_output,
+            analysis_results_output,
+        ],
+    )
+
+    chroma_slider.change(
+        process_image,
+        inputs=[
+            upload_image,
+            l_min_slider,
+            l_max_slider,
+            tonality_min_slider,
+            tonality_max_slider,
+            chroma_slider,
+            skin_checkbox,
+            eye_checkbox,
+            hair_checkbox,
+        ],
+        outputs=[
+            processed_image_output,
+            l_hist_output,
+            tonality_hist_output,
+            chroma_hist_output,
+            analysis_results_output,
+        ],
+    )
+
+demo.launch()

main.py

@@ -0,0 +1,225 @@
+import argparse
+import os
+import gradio as gr
+import cv2
+import numpy as np
+from PIL import Image
+import pandas as pd
+import colorspacious as cs
+from src.skin_analyzer import (
+    analyze_skin_function,
+    categorize_chroma,
+    categorize_tonality,
+    categorize_undertones,
+    determine_season_with_tonality,
+)
+from src.image import ImageBundle
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+
+if __name__ == "__main__":
+    args = argparse.ArgumentParser()
+    args.add_argument("-i", "--input", type=str, default="inputs/")
+    args.add_argument("-ch", "--chroma_thresh", type=int, default=45)
+    args.add_argument("-lmin", "--l_min_tonality", type=int, default=33)
+    args.add_argument("-lmax", "--l_max_tonality", type=int, default=66)
+
+    args = args.parse_args()
+
+    # check if input is folder or a csv file
+
+    if args.input.endswith(".csv"):
+        # read csv file
+        file = pd.read_csv(args.input)
+        # column name Image,Tone,Season,Sub-Season
+        for index, row in tqdm(file.iterrows(), total=file.shape[0]):
+            if index in [26, 62, 61, 23, 22, 24, 13, 1, 2, 4, 6, 8, 10, 11]:
+                # if index in [1, 2, 4, 10]:
+                # get the image from url
+                image_url = row["Image"]
+                # get the tone from the csv
+                tone = row["Tone"]
+                # get the season from the csv
+                season = row["Season"]
+                # get the sub-season from the csv
+                sub_season = row["Sub-Season"]
+
+                image_bundle = ImageBundle(image_source=image_url)
+
+                # Detect faces and landmarks
+                face_data = image_bundle.detect_faces_and_landmarks()
+                landmarks = image_bundle.detect_face_landmarks()
+
+                # Perform segmentation
+                segmentation_maps = image_bundle.segment_image()
+
+                skin_mask = segmentation_maps["face_skin_mask"]
+                image = image_bundle.numpy_image()
+
+                # create histogram of Lchannel for skin mask for all images
+                skin_pixels = (
+                    image[skin_mask > 0].reshape(-1, 3) / 255.0
+                )  # Normalize to [0, 1] range
+
+                # Convert skin pixels to LAB color space using colorspacious
+                lab_pixels = cs.cspace_convert(skin_pixels, "sRGB1", "CIELab")
+
+                # Compute L* percentiles
+                l_values = lab_pixels[:, 0]
+
+                l_min = np.percentile(l_values, 10)
+                l_max = np.percentile(l_values, 90)
+
+                # # Filter based on L* value
+                mask_l = (lab_pixels[:, 0] >= l_min) & (lab_pixels[:, 0] <= l_max)
+                filtered_lab_pixels = lab_pixels[mask_l]
+
+                filtered_l_values = filtered_lab_pixels[:, 0]
+                print(np.unique(filtered_l_values))
+                l_max_tonality = args.l_max_tonality
+                l_min_tonality = args.l_min_tonality
+                l_min_tonality_val = np.percentile(filtered_l_values, l_min_tonality)
+                l_max_tonality_val = np.percentile(filtered_l_values, l_max_tonality)
+                print(l_min_tonality_val, l_max_tonality_val)
+
+                # Update mask
+                filtered_mask = np.zeros_like(skin_mask, dtype=np.uint8)
+                mask_indices = np.where(skin_mask > 0)
+                filtered_mask[mask_indices[0][mask_l], mask_indices[1][mask_l]] = 255
+
+                overlay = image.copy()
+                overlay[filtered_mask > 0] = (0, 0, 255)  # Red for skin
+
+                overlay = cv2.addWeighted(image, 0.85, overlay, 0.15, 0)
+
+                # Convert combined_overlay to PIL Image for display
+                combined_overlay = Image.fromarray(overlay)
+
+                # Create a figure with two subplots: one for the overlay image and one for the histogram
+                fig, ax = plt.subplots(1, 4, figsize=(18, 6))
+
+                # # Plot the overlay image in the first subplot
+                # ax[0].imshow(image)
+                # ax[0].axis("off")
+                # ax[0].set_title("Original Image")
+
+                ax[0].imshow(combined_overlay)
+                ax[0].axis("off")  # Hide the axis
+                ax[0].set_title("Overlay Image")
+                ax[0].text(
+                    0.05,
+                    0.95,
+                    f"Season: {season}\nSub-Season: {sub_season}\nTone: {tone}",
+                    transform=ax[0].transAxes,
+                    horizontalalignment="left",
+                    verticalalignment="top",
+                )
+
+                # Plot the histogram of filtered L channel in the third subplot
+                ax[3].hist(filtered_l_values, bins=100, color="blue", alpha=0.75)
+                ax[3].axvline(
+                    l_min_tonality_val,
+                    color="purple",
+                    linestyle="--",
+                    label="lower percentile",
+                )
+                ax[3].axvline(
+                    l_max_tonality_val,
+                    color="orange",
+                    linestyle="--",
+                    label="higher percentile",
+                )
+                ax[3].set_xlabel("L* Value")
+                ax[3].set_ylabel("Frequency")
+                ax[3].set_title("Histogram of Filtered L* Values in Skin Mask")
+                ax[3].legend()
+
+                # Plot the histogram of L channel in the second subplot
+                ax[2].hist(l_values, bins=100, color="blue", alpha=0.75)
+                ax[2].axvline(
+                    l_min, color="red", linestyle="--", label="10th percentile"
+                )
+                ax[2].axvline(
+                    l_max, color="green", linestyle="--", label="90th percentile"
+                )
+                ax[2].axvline(
+                    l_min_tonality_val,
+                    color="purple",
+                    linestyle="--",
+                    label="lower percentile",
+                )
+                ax[2].axvline(
+                    l_max_tonality_val,
+                    color="orange",
+                    linestyle="--",
+                    label="higher percentile",
+                )
+                ax[2].set_xlabel("L* Value")
+                ax[2].set_ylabel("Frequency")
+                ax[2].set_title("Histogram of L* Values in Skin Mask")
+                ax[2].legend()
+
+                # Plot chroma histogram in the subplot
+                a_values = filtered_lab_pixels[:, 1]
+                b_values = filtered_lab_pixels[:, 2]
+                chroma_values = np.sqrt(a_values**2 + b_values**2)
+                chroma_thresh = args.chroma_thresh
+                chroma_thersh_val = np.percentile(chroma_values, chroma_thresh)
+
+                ax[1].hist(chroma_values, bins=100, color="blue", alpha=0.75)
+                ax[1].set_xlabel("Chroma Value")
+                ax[1].set_ylabel("Frequency")
+                ax[1].set_title("Histogram of Chroma Values in Skin Mask")
+                ax[1].axvline(
+                    chroma_thersh_val,
+                    color="red",
+                    linestyle="--",
+                    label="Threshold Value",
+                )
+                chroma_counts, predominant_chroma, chroma = categorize_chroma(
+                    lab_pixels, chroma_thresh
+                )
+                tonality_counts, predominant_tonality, tonalities = categorize_tonality(
+                    filtered_l_values, l_min_tonality, l_max_tonality
+                )
+                undertone_counts, predominant_undertone, undertones = (
+                    categorize_undertones(filtered_lab_pixels)
+                )
+
+                # add text on plot for predominant chroma
+                ax[1].text(
+                    0.05,
+                    0.95,
+                    f"Predominant Chroma: {predominant_chroma},\n undertone: {predominant_undertone},\n tonality: {predominant_tonality}",
+                    transform=ax[1].transAxes,
+                    horizontalalignment="left",
+                    verticalalignment="top",
+                )
+
+                # Save the figure in the workspace
+                os.makedirs(
+                    f"workspace/all_hist-{chroma_thresh}-{l_min_tonality}-{l_max_tonality}",
+                    exist_ok=True,
+                )
+                plt.savefig(
+                    f"workspace/all_hist-{chroma_thresh}-{l_min_tonality}-{l_max_tonality}/{index}-{season}.png"
+                )
+                plt.close()
+
+                # skin_analysis = analyze_skin_function(
+                #     image,
+                #     skin_mask,
+                #     10,
+                #     90,
+                #     l_min_tonality,
+                #     l_max_tonality,
+                #     chroma_thresh,
+                # )
+                season_counts, predominant_season, seasons = (
+                    determine_season_with_tonality(undertones, chroma, tonalities)
+                )
+                print(
+                    f"Season: {season_counts},\n Chroma: {chroma_counts},\n Tonality: {tonality_counts},\n Undertone: {undertone_counts}"
+                )
+
+                input("Press enter to continue")

src/image.py

@@ -47,6 +47,8 @@ class ImageBundle:
 
             self._handle_color_profile()
             self._extract_exif_data()
+            self._rotate_image_if_needed()
+
             self.is_black_and_white = self._is_black_and_white()
             self.basename, self.ext = extract_filename_and_extension(self.image_source)
             if self.is_black_and_white:
@@ -93,14 +95,14 @@ class ImageBundle:
         """
         Handle the color profile of the image if mentioned.
         """
-        if "icc_profile" in self.image.info:
-            icc_profile = self.image.info.get("icc_profile")
+        if "icc_profile" in self.image.info:  # type: ignore
+            icc_profile = self.image.info.get("icc_profile")  # type: ignore
             if icc_profile:
                 io = BytesIO(icc_profile)
                 src_profile = ImageCms.ImageCmsProfile(io)
                 dst_profile = ImageCms.createProfile("sRGB")
                 self.image = ImageCms.profileToProfile(
-                    self.image, src_profile, dst_profile
+                    self.image, src_profile, dst_profile  # type: ignore
                 )
 
     def _extract_exif_data(self):
@@ -108,12 +110,33 @@ class ImageBundle:
         Extract EXIF data from the image.
         """
         if hasattr(self.image, "_getexif"):
-            exif_info = self.image._getexif()
+            exif_info = self.image._getexif()  # type: ignore
             if exif_info is not None:
                 for tag, value in exif_info.items():
                     decoded_tag = ExifTags.TAGS.get(tag, tag)
                     self.exif_data[decoded_tag] = value
 
+    def _rotate_image_if_needed(self):
+        """
+        Rotate the image based on EXIF orientation information.
+        """
+        if not self.image.info:
+            return
+
+        for orientation in ExifTags.TAGS.keys():
+            if ExifTags.TAGS[orientation] == "Orientation":
+                break
+
+        exif = dict(self.image.info.items())
+        orientation = exif.get(orientation)
+
+        if orientation == 3:
+            self.image = self.image.rotate(180, expand=True)
+        elif orientation == 6:
+            self.image = self.image.rotate(270, expand=True)
+        elif orientation == 8:
+            self.image = self.image.rotate(90, expand=True)
+
     def _is_black_and_white(self):
         """
         Check if the image is black and white even if it has 3 channels.
@@ -160,6 +183,7 @@ class ImageBundle:
 
         # Detect face landmarks and create masks for individual features
         landmarks = self.detect_face_landmarks()
+
         feature_masks = create_feature_masks(image_np, landmarks)
 
         # Subtract feature masks from face skin mask

src/segmentation_utils.py

@@ -1,13 +1,21 @@
-
 from mediapipe.tasks import python
 from mediapipe.tasks.python import vision
 import mediapipe as mp
 import cv2
 import numpy as np
+import warnings
+import os
+import logging
 
+# Suppress INFO and WARNING logs from MediaPipe
+logging.getLogger("mediapipe").setLevel(logging.ERROR)
+# Suppress INFO and WARNING logs
+os.environ["GLOG_minloglevel"] = "2"  # 2 means only ERROR and FATAL logs
+os.environ["GLOG_logtostderr"] = "1"
 # Initialize mediapipe solutions
-mp_face_detection = mp.solutions.face_detection
-mp_face_mesh = mp.solutions.face_mesh
+mp_face_detection = mp.solutions.face_detection  # type: ignore
+mp_face_mesh = mp.solutions.face_mesh  # type: ignore
+
 
 def detect_faces_and_landmarks(image: np.ndarray):
     """
@@ -15,24 +23,29 @@ def detect_faces_and_landmarks(image: np.ndarray):
     :param image: Input image as a numpy array.
     :return: List of dictionaries with face and landmark information.
     """
-    with mp_face_detection.FaceDetection(model_selection=1, min_detection_confidence=0.5) as face_detection:
+    with mp_face_detection.FaceDetection(
+        model_selection=1, min_detection_confidence=0.5
+    ) as face_detection:
         results = face_detection.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
         face_data = []
         if results.detections:
             for detection in results.detections:
                 bboxC = detection.location_data.relative_bounding_box
                 h, w, c = image.shape
-                bbox = int(bboxC.xmin * w), int(bboxC.ymin * h), \
-                       int(bboxC.width * w), int(bboxC.height * h)
+                bbox = (
+                    int(bboxC.xmin * w),
+                    int(bboxC.ymin * h),
+                    int(bboxC.width * w),
+                    int(bboxC.height * h),
+                )
                 landmarks = detection.location_data.relative_keypoints
-                face_data.append({
-                    "bbox": bbox,
-                    "landmarks": landmarks
-                })
+                face_data.append({"bbox": bbox, "landmarks": landmarks})
     return face_data
 
 
-def mediapipe_selfie_segmentor(image: np.ndarray, segment: list = ["face_skin", "body_skin", "hair"]):
+def mediapipe_selfie_segmentor(
+    image: np.ndarray, segment: list = ["face_skin", "body_skin", "hair"]
+):
     """
     Segment image using MediaPipe Multi-Class Selfie Segmentation.
     :param image: Input image as a numpy array.
@@ -59,27 +72,33 @@ def mediapipe_selfie_segmentor(image: np.ndarray, segment: list = ["face_skin",
         masks = {
             "face_skin_mask": np.zeros((h, w), dtype=np.uint8),
             "hair_mask": np.zeros((h, w), dtype=np.uint8),
-            "body_skin_mask": np.zeros((h, w), dtype=np.uint8)
+            "body_skin_mask": np.zeros((h, w), dtype=np.uint8),
         }
 
         # Define class labels based on MediaPipe segmentation (example, may need adjustment)
         face_skin_class = 3
         hair_class = 1
         body_skin_class = 2
-        
+
         masks["face_skin_mask"][category_mask == face_skin_class] = 255
         masks["hair_mask"][category_mask == hair_class] = 255
         masks["body_skin_mask"][category_mask == body_skin_class] = 255
-    
+
     return masks
 
+
 def detect_face_landmarks(image: np.ndarray):
     """
     Detect face landmarks using MediaPipe Face Mesh.
     :param image: Input image as a numpy array.
     :return: Dictionary with landmarks for iris, lips, eyebrows, and eyes.
     """
-    with mp_face_mesh.FaceMesh(static_image_mode=True, max_num_faces=1, refine_landmarks=True, min_detection_confidence=0.5) as face_mesh:
+    with mp_face_mesh.FaceMesh(
+        static_image_mode=True,
+        max_num_faces=1,
+        refine_landmarks=True,
+        min_detection_confidence=0.5,
+    ) as face_mesh:
         results = face_mesh.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
         face_landmarks = {
             "left_iris": [],
@@ -88,7 +107,7 @@ def detect_face_landmarks(image: np.ndarray):
             "left_eyebrow": [],
             "right_eyebrow": [],
             "left_eye": [],
-            "right_eye": []
+            "right_eye": [],
         }
         if results.multi_face_landmarks:
             for face_landmarks_data in results.multi_face_landmarks:
@@ -101,7 +120,28 @@ def detect_face_landmarks(image: np.ndarray):
                     landmark = face_landmarks_data.landmark[i]
                     face_landmarks["right_iris"].append((landmark.x, landmark.y))
                 # Outer lips landmarks
-                for i in [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 0, 409, 270, 269, 267, 37,39, 40, 185]:
+                for i in [
+                    61,
+                    146,
+                    91,
+                    181,
+                    84,
+                    17,
+                    314,
+                    405,
+                    321,
+                    375,
+                    291,
+                    0,
+                    409,
+                    270,
+                    269,
+                    267,
+                    37,
+                    39,
+                    40,
+                    185,
+                ]:
                     landmark = face_landmarks_data.landmark[i]
                     face_landmarks["lips"].append((landmark.x, landmark.y))
                 # Left eyebrow landmarks
@@ -113,15 +153,50 @@ def detect_face_landmarks(image: np.ndarray):
                     landmark = face_landmarks_data.landmark[i]
                     face_landmarks["right_eyebrow"].append((landmark.x, landmark.y))
                 # Left eye landmarks
-                for i in [33, 246, 161, 160, 159, 158, 157, 173, 133, 155, 154, 153, 145, 144, 163, 7]:
+                for i in [
+                    33,
+                    246,
+                    161,
+                    160,
+                    159,
+                    158,
+                    157,
+                    173,
+                    133,
+                    155,
+                    154,
+                    153,
+                    145,
+                    144,
+                    163,
+                    7,
+                ]:
                     landmark = face_landmarks_data.landmark[i]
                     face_landmarks["left_eye"].append((landmark.x, landmark.y))
                 # Right eye landmarks
-                for i in [463, 398, 384, 385, 386, 387, 388, 466, 263, 249, 390, 373, 374, 380, 381, 382]:
+                for i in [
+                    463,
+                    398,
+                    384,
+                    385,
+                    386,
+                    387,
+                    388,
+                    466,
+                    263,
+                    249,
+                    390,
+                    373,
+                    374,
+                    380,
+                    381,
+                    382,
+                ]:
                     landmark = face_landmarks_data.landmark[i]
                     face_landmarks["right_eye"].append((landmark.x, landmark.y))
     return face_landmarks
 
+
 def create_feature_masks(image: np.ndarray, landmarks: dict):
     """
     Create individual masks for facial features based on landmarks.
@@ -137,15 +212,70 @@ def create_feature_masks(image: np.ndarray, landmarks: dict):
         "left_eye_mask": np.zeros((h, w), dtype=np.uint8),
         "right_eye_mask": np.zeros((h, w), dtype=np.uint8),
         "left_iris_mask": np.zeros((h, w), dtype=np.uint8),
-        "right_iris_mask": np.zeros((h, w), dtype=np.uint8)
+        "right_iris_mask": np.zeros((h, w), dtype=np.uint8),
     }
 
     # Define the order of the points to form polygons correctly
-    lips_order = [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 0, 409, 270, 269, 267, 37,39, 40, 185]
+    lips_order = [
+        61,
+        146,
+        91,
+        181,
+        84,
+        17,
+        314,
+        405,
+        321,
+        375,
+        291,
+        0,
+        409,
+        270,
+        269,
+        267,
+        37,
+        39,
+        40,
+        185,
+    ]
     left_eyebrow_order = [70, 63, 105, 66, 107]
     right_eyebrow_order = [336, 296, 334, 293, 300]
-    left_eye_order = [33, 246, 161, 160, 159, 158, 157, 173, 133, 155, 154, 153, 145, 144, 163, 7]
-    right_eye_order = [463, 398, 384, 385, 386, 387, 388, 466, 263, 249, 390, 373, 374, 380, 381, 382]
+    left_eye_order = [
+        33,
+        246,
+        161,
+        160,
+        159,
+        158,
+        157,
+        173,
+        133,
+        155,
+        154,
+        153,
+        145,
+        144,
+        163,
+        7,
+    ]
+    right_eye_order = [
+        463,
+        398,
+        384,
+        385,
+        386,
+        387,
+        388,
+        466,
+        263,
+        249,
+        390,
+        373,
+        374,
+        380,
+        381,
+        382,
+    ]
     left_iris_order = [468, 469, 470, 471, 472]
     right_iris_order = [473, 474, 475, 476, 477]
 
@@ -156,16 +286,36 @@ def create_feature_masks(image: np.ndarray, landmarks: dict):
         "left_eye": left_eye_order,
         "right_eye": right_eye_order,
         "left_iris": left_iris_order,
-        "right_iris": right_iris_order
+        "right_iris": right_iris_order,
     }
 
     for feature, order in orders.items():
-        points = np.array([(int(landmarks[feature][i][0] * w), int(landmarks[feature][i][1] * h)) for i in range(len(order))], dtype=np.int32)
+        points = []
+
+        for i in range(len(order)):
+            try:
+                point = (
+                    int(landmarks[feature][i][0] * w),
+                    int(landmarks[feature][i][1] * h),
+                )
+                points.append(point)
+            except KeyError:
+                warnings.warn(
+                    f"Feature '{feature}' at index {i} is not present in landmarks. Skipping this point."
+                )
+            except IndexError:
+                warnings.warn(
+                    f"Index {i} is out of range for feature '{feature}'. Skipping this point."
+                )
+
+        points = np.array(points, dtype=np.int32)
+
         if len(points) > 0:
             cv2.fillPoly(masks[f"{feature}_mask"], [points], 255)
 
     return masks
 
+
 if __name__ == "__main__":
     # Test the face detection and segmentation
     image = cv2.imread("inputs/vanika.png")
@@ -183,4 +333,4 @@ if __name__ == "__main__":
                 if "iris_mask" in feature:
                     cv2.imwrite(f"outputs/{feature}.png", feature_mask)
                 mask = cv2.subtract(mask, feature_mask)
-        cv2.imwrite(f"outputs/{key}.png", mask)
+        cv2.imwrite(f"outputs/{key}.png", mask)

src/skin_analyzer.py

@@ -1,4 +1,6 @@
+import io
 import cv2
+from matplotlib import pyplot as plt
 import numpy as np
 from colormath.color_objects import LabColor, sRGBColor
 from colormath.color_conversions import convert_color
@@ -38,7 +40,26 @@ def sample_skin_pixels(image, mask, l_min_percentile=10, l_max_percentile=90):
     mask_indices = np.where(mask > 0)
     filtered_mask[mask_indices[0][mask_l], mask_indices[1][mask_l]] = 255
 
-    return filtered_lab_pixels, filtered_mask
+    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+    # Plot the histogram of L channel in the second subplot
+    ax[0].hist(l_values, bins=100, color="blue", alpha=0.75)
+    ax[0].axvline(l_min, color="red", linestyle="--", label="10th percentile")
+    ax[0].axvline(l_max, color="green", linestyle="--", label="90th percentile")
+    ax[0].set_xlabel("L* Value")
+    ax[0].set_ylabel("Frequency")
+    ax[0].set_title("Histogram of L* Values in Skin Mask")
+    ax[0].legend()
+
+    # Save the plot to a file-like object
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png")
+    plt.close(fig)
+    buf.seek(0)
+    # Convert the buffer to a PIL Image and then to a NumPy array
+    image = Image.open(buf)
+    l_hist = np.array(image)
+
+    return filtered_lab_pixels, filtered_mask, l_hist
 
 
 def rgb_to_lab_and_save(image, output_dir="workspace"):
@@ -269,10 +290,41 @@ def categorize_tonality(L_values, l_min_tonality, l_max_tonality):
     tonality_counts = {"Light": light_count, "True": true_count, "Deep": deep_count}
     predominant_tonality = max(tonality_counts, key=tonality_counts.get)
 
+    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+
+    # Plot the histogram of filtered L channel in the third subplot
+    ax[0].hist(L_values, bins=100, color="blue", alpha=0.75)
+    ax[0].axvline(
+        l_abs_min,
+        color="purple",
+        linestyle="--",
+        label="lower percentile",
+    )
+    ax[0].axvline(
+        l_abs_max,
+        color="orange",
+        linestyle="--",
+        label="higher percentile",
+    )
+    ax[0].set_xlabel("L* Value")
+    ax[0].set_ylabel("Frequency")
+    ax[0].set_title("Histogram of Filtered L* Values in Skin Mask")
+    ax[0].legend()
+
+    # Save the plot to a file-like object
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png")
+    plt.close(fig)
+    buf.seek(0)
+    # Convert the buffer to a PIL Image and then to a NumPy array
+    image = Image.open(buf)
+    tonality_l_hist = np.array(image)
+
     return (
         tonality_counts,
         predominant_tonality,
         tonality,
+        tonality_l_hist,
     )
 
 
@@ -299,11 +351,18 @@ def categorize_chroma(lab_pixels, chroma_thresh):
     :return: Chroma category (Bright, Muted).
     """
     chroma = []
+    distances = []
     chroma_counts = {"Bright": 0, "Muted": 0}
+
     for pixel in lab_pixels:
         a = pixel[1]
         b = pixel[2]
-        distance = np.sqrt(a**2 + b**2)
+        distances.append(np.sqrt(a**2 + b**2))
+
+    # get the 50th percentile of the distance
+    chroma_thresh = np.percentile(distances, chroma_thresh)
+    print(f"chroma_thresh: {chroma_thresh}")
+    for distance in distances:
         if distance > chroma_thresh:
             chroma.append("Bright")
             chroma_counts["Bright"] += 1
@@ -312,7 +371,29 @@ def categorize_chroma(lab_pixels, chroma_thresh):
             chroma_counts["Muted"] += 1
 
     predominant_chroma = max(chroma_counts, key=chroma_counts.get)
-    return chroma_counts, predominant_chroma, chroma
+
+    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+    ax[0].hist(distances, bins=100, color="blue", alpha=0.75)
+    ax[0].set_xlabel("Chroma Value")
+    ax[0].set_ylabel("Frequency")
+    ax[0].set_title("Histogram of Chroma Values in Skin Mask")
+    ax[0].axvline(
+        chroma_thresh,
+        color="red",
+        linestyle="--",
+        label="Threshold Value",
+    )
+
+    # Save the plot to a file-like object
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png")
+    plt.close(fig)
+    buf.seek(0)
+    # Convert the buffer to a PIL Image and then to a NumPy array
+    image = Image.open(buf)
+    chorma_hist = np.array(image)
+
+    return chroma_counts, predominant_chroma, chroma, chorma_hist
 
 
 def categorize_undertones(cluster_centers):
@@ -370,7 +451,7 @@ def analyze_skin_function(
     """
 
     # sapmle skin pixels
-    lab_pixels, filtered_skin_mask = sample_skin_pixels(
+    lab_pixels, filtered_skin_mask, l_hist = sample_skin_pixels(
         image, skin_mask, l_min_skin, l_max_skin
     )
 
@@ -387,12 +468,12 @@ def analyze_skin_function(
         predominant_overtone,
         overtone,
     ) = categorize_overtone(ITA_values)
-    tonality_counts, predominant_tonality, tonalities = categorize_tonality(
-        L_values, l_min_tonality, l_max_tonality
+    tonality_counts, predominant_tonality, tonalities, tonality_l_hist = (
+        categorize_tonality(L_values, l_min_tonality, l_max_tonality)
     )
 
     # calculate chroma
-    chroma_counts, predominant_chroma, chroma = categorize_chroma(
+    chroma_counts, predominant_chroma, chroma, chorma_hist = categorize_chroma(
         lab_pixels, chroma_thresh
     )
 
@@ -435,20 +516,6 @@ def analyze_skin_function(
     #     else:
     #         neutral_mask[cluster_indices[0][cluster_mask], cluster_indices[1][cluster_mask]] = 255
 
-    # # Create overlays
-    # overlay = image.copy()
-    # overlay[filtered_skin_mask > 0] = (0, 0, 255)  # Red for skin
-    # # overlay[cool_mask > 0] = (255, 0, 0)  # Blue for cool
-    # # overlay[neutral_mask > 0] = (0, 255, 0)  # Green for neutral
-    # overlay = cv2.addWeighted(image, 0.85, overlay, 0.15, 0)
-    # # resize overlay to longest side 512
-    # h, w, _ = overlay.shape
-    # if h > w:
-    #     scale = 512 / h
-    # else:
-    #     scale = 512 / w
-    # overlay = cv2.resize(overlay, (int(w * scale), int(h * scale)))
-
     return {
         "undertone": predominant_undertone,
         "overtone": predominant_overtone,
@@ -464,4 +531,7 @@ def analyze_skin_function(
         "overtone_counts": overtone_counts,
         "tonality_counts": tonality_counts,
         "season_counts": season_counts,
+        "l_hist": l_hist,
+        "tonality_l_hist": tonality_l_hist,
+        "chorma_hist": chorma_hist,
     }