clean up changes

src/analyze.py

@@ -3,10 +3,10 @@ import numpy as np
 import math
 from sklearn.cluster import KMeans
 from collections import Counter
-from color_utils import rgb_to_hex, hex_to_bgr, hex_to_rgb
-from hair_utils import HairColorPalette
-from skin_utils import SkinTonePalette
-from eyes_utils import EyeColorPalette
+from src.color_utils import rgb_to_hex, hex_to_bgr, hex_to_rgb
+from src.hair_utils import HairColorPalette
+from src.skin_utils import SkinTonePalette
+from src.eyes_utils import EyeColorPalette
 from sklearn.metrics import silhouette_score
 import matplotlib.pyplot as plt
 
@@ -308,7 +308,7 @@ def create_combined_overlay(image, hair_mask, skin_mask, eye_mask):
     # Color the masks
     hair_overlay[hair_mask > 0] = [0, 255, 0]  # Green for hair
     skin_overlay[skin_mask > 0] = [255, 0, 0]  # Red for skin
-    eye_overlay[eye_mask > 0] = [0, 0, 255]    # Blue for eyes
+    eye_overlay[eye_mask > 0] = [0, 0, 255]  # Blue for eyes
 
     # Combine the overlays with the original image
     combined_overlay = cv2.addWeighted(image, 0.8, hair_overlay, 0.2, 0)
@@ -318,7 +318,6 @@ def create_combined_overlay(image, hair_mask, skin_mask, eye_mask):
     return combined_overlay
 
 
-
 def analyze_and_visualize(image, hair_mask, skin_mask, eye_mask, n_colors=3):
     image_np = np.array(image)
     hair_mask_np = np.array(hair_mask)
@@ -352,7 +351,9 @@ def analyze_and_visualize(image, hair_mask, skin_mask, eye_mask, n_colors=3):
     # Calculate ITA for the dominant skin color
     dominant_skin_color = skin_dominant_colors[0]
     ita = skin_palette.calculate_ita(dominant_skin_color)
-    vectorscope_check = skin_palette.is_within_vectorscope_skin_tone_line(dominant_skin_color)
+    vectorscope_check = skin_palette.is_within_vectorscope_skin_tone_line(
+        dominant_skin_color
+    )
 
     eye_palette = EyeColorPalette()
     eye_dominant_colors, eye_dominant_percentages = get_dominant_colors(
@@ -362,7 +363,9 @@ def analyze_and_visualize(image, hair_mask, skin_mask, eye_mask, n_colors=3):
         eye_dominant_colors, eye_palette.palette
     )
 
-    combined_overlay = create_combined_overlay(image_np, hair_mask_np, skin_mask_np, eye_mask_np)
+    combined_overlay = create_combined_overlay(
+        image_np, hair_mask_np, skin_mask_np, eye_mask_np
+    )
 
     bar_width = 50
     hair_color_bar = create_dominant_color_bar(
@@ -379,19 +382,19 @@ def analyze_and_visualize(image, hair_mask, skin_mask, eye_mask, n_colors=3):
         image_np,
         list(hair_palette.palette.keys()).index(hair_color),
         hair_palette.palette,
-        bar_width
+        bar_width,
     )
     skin_palette_bar = create_tone_palette_bar(
         image_np,
         list(skin_palette.palette.keys()).index(skin_color),
         skin_palette.palette,
-        bar_width
+        bar_width,
     )
     eye_palette_bar = create_tone_palette_bar(
         image_np,
         list(eye_palette.palette.keys()).index(eye_color),
         eye_palette.palette,
-        bar_width
+        bar_width,
     )
 
     output_image = np.hstack(
@@ -411,14 +414,14 @@ def analyze_and_visualize(image, hair_mask, skin_mask, eye_mask, n_colors=3):
         hair_dominant_percentages,
         hair_hex,
         hair_distance,
-        img_shape
+        img_shape,
     )
     msg_bar_skin = create_message_bar(
         skin_dominant_colors,
         skin_dominant_percentages,
         skin_hex,
         skin_distance,
-        img_shape
+        img_shape,
     )
     msg_bar_eye = create_message_bar(
         eye_dominant_colors, eye_dominant_percentages, eye_hex, eye_distance, img_shape
@@ -452,4 +455,4 @@ def analyze_and_visualize(image, hair_mask, skin_mask, eye_mask, n_colors=3):
         },
     }
 
-    return output_image, analysis_record
+    return output_image, analysis_record

src/app.py

@@ -1,105 +0,0 @@
-import gradio as gr
-import cv2
-import numpy as np
-from PIL import Image
-
-from skin_analyzer import analyze_skin_function
-from image import ImageBundle
-
-
-def process_image(
-    image,
-    l_min_skin,
-    l_max_skin,
-    l_min_tonality,
-    l_max_tonality,
-    chroma_thresh,
-    analyze_skin,
-    analyze_eyes,
-    analyze_hair,
-):
-    """
-    Process the uploaded image and return the analysis results based on selected analyses.
-    :param image: Uploaded image.
-    :param analyze_skin: Whether to perform skin analysis.
-    :param analyze_eyes: Whether to perform eye analysis.
-    :param analyze_hair: Whether to perform hair analysis.
-    :return: Analysis results.
-    """
-    image_bundle = ImageBundle(image_array=image)
-
-    # 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()
-
-    analysis_results = {}
-    # overlay_images = []
-
-    # if analyze_hair:
-    #     hair_mask = segmentation_maps["hair_mask"]
-    #     # analysis_results['hair_analysis'] = analyze_hair_function(image, hair_mask)
-    #     overlay_images.append(segmentation_maps["hair_mask"])
-
-    if analyze_skin:
-        skin_mask = segmentation_maps["face_skin_mask"]
-        skin_analysis = analyze_skin_function(
-            image,
-            skin_mask,
-            l_min_skin,
-            l_max_skin,
-            l_min_tonality,
-            l_max_tonality,
-            chroma_thresh,
-        )
-        if "filtered_skin_mask" in skin_analysis:
-            filtered_skin_mask = skin_analysis["filtered_skin_mask"]
-            del skin_analysis["filtered_skin_mask"]
-        analysis_results["skin_analysis"] = skin_analysis
-
-        # overlay_images.append(skin_analysis["overlay_image"])
-
-    # if analyze_eyes:
-    #     eye_mask = segmentation_maps["right_iris_mask"] | segmentation_maps["left_iris_mask"]
-    #     # analysis_results['eye_analysis'] = analyze_eye_function(image, eye_mask)
-    #     overlay_images.append(eye_mask)
-
-    # Combine overlay images
-    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)
-
-    # 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=0, 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"),
-    ],
-    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)

src/eyes_utils.py

@@ -2,7 +2,7 @@ from PIL import Image
 import numpy as np
 from sklearn.cluster import KMeans
 from collections import Counter
-from color_utils import calculate_color_distance_lab
+from src.color_utils import calculate_color_distance_lab
 
 
 class EyeColorPalette:

src/gradio_app.py

@@ -1,105 +0,0 @@
-import gradio as gr
-import cv2
-import numpy as np
-from PIL import Image
-
-from skin_analyzer import analyze_skin_function
-from image import ImageBundle
-
-
-def process_image(
-    image,
-    l_min_skin,
-    l_max_skin,
-    l_min_tonality,
-    l_max_tonality,
-    chroma_thresh,
-    analyze_skin,
-    analyze_eyes,
-    analyze_hair,
-):
-    """
-    Process the uploaded image and return the analysis results based on selected analyses.
-    :param image: Uploaded image.
-    :param analyze_skin: Whether to perform skin analysis.
-    :param analyze_eyes: Whether to perform eye analysis.
-    :param analyze_hair: Whether to perform hair analysis.
-    :return: Analysis results.
-    """
-    image_bundle = ImageBundle(image_array=image)
-
-    # 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()
-
-    analysis_results = {}
-    # overlay_images = []
-
-    # if analyze_hair:
-    #     hair_mask = segmentation_maps["hair_mask"]
-    #     # analysis_results['hair_analysis'] = analyze_hair_function(image, hair_mask)
-    #     overlay_images.append(segmentation_maps["hair_mask"])
-
-    if analyze_skin:
-        skin_mask = segmentation_maps["face_skin_mask"]
-        skin_analysis = analyze_skin_function(
-            image,
-            skin_mask,
-            l_min_skin,
-            l_max_skin,
-            l_min_tonality,
-            l_max_tonality,
-            chroma_thresh,
-        )
-        if "filtered_skin_mask" in skin_analysis:
-            filtered_skin_mask = skin_analysis["filtered_skin_mask"]
-            del skin_analysis["filtered_skin_mask"]
-        analysis_results["skin_analysis"] = skin_analysis
-
-        # overlay_images.append(skin_analysis["overlay_image"])
-
-    # if analyze_eyes:
-    #     eye_mask = segmentation_maps["right_iris_mask"] | segmentation_maps["left_iris_mask"]
-    #     # analysis_results['eye_analysis'] = analyze_eye_function(image, eye_mask)
-    #     overlay_images.append(eye_mask)
-
-    # Combine overlay images
-    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)
-
-    # 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=0, 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"),
-    ],
-    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)

src/hair_utils.py

@@ -2,7 +2,7 @@ from PIL import Image
 import numpy as np
 from sklearn.cluster import KMeans
 from collections import Counter
-from color_utils import calculate_color_distance_lab
+from src.color_utils import calculate_color_distance_lab
 
 
 class HairColorPalette:

src/image.py

@@ -5,14 +5,20 @@ from PIL import Image, ExifTags, ImageCms
 from io import BytesIO
 import requests
 import pillow_heif
-from segmentation_utils import detect_faces_and_landmarks, detect_face_landmarks, mediapipe_selfie_segmentor, create_feature_masks
-from utils import is_url, extract_filename_and_extension
+from src.segmentation_utils import (
+    detect_faces_and_landmarks,
+    detect_face_landmarks,
+    mediapipe_selfie_segmentor,
+    create_feature_masks,
+)
+from src.utils import is_url, extract_filename_and_extension
 
 # Register HEIF opener
 pillow_heif.register_heif_opener()
 
 LOG = logging.getLogger(__name__)
 
+
 class ImageBundle:
     def __init__(self, image_source=None, image_array=None):
         """
@@ -149,21 +155,31 @@ class ImageBundle:
         """
         image_np = self.numpy_image()
         # save image to check bgr or rgb
-        cv2.imwrite('workspace/image.jpg', image_np)
+        cv2.imwrite("workspace/image.jpg", image_np)
         masks = mediapipe_selfie_segmentor(image_np)
-        
+
         # 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
-        for feature in ["lips_mask", "left_eyebrow_mask", "right_eyebrow_mask", "left_eye_mask", "right_eye_mask", "left_iris_mask", "right_iris_mask"]:
+        for feature in [
+            "lips_mask",
+            "left_eyebrow_mask",
+            "right_eyebrow_mask",
+            "left_eye_mask",
+            "right_eye_mask",
+            "left_iris_mask",
+            "right_iris_mask",
+        ]:
             if "iris" in feature:
                 masks[feature] = feature_masks[feature]
-            masks["face_skin_mask"] = cv2.subtract(masks["face_skin_mask"], feature_masks[feature])
+            masks["face_skin_mask"] = cv2.subtract(
+                masks["face_skin_mask"], feature_masks[feature]
+            )
 
         self.segmentation_maps = masks
-        
+
         return self.segmentation_maps
 
     def numpy_image(self):
@@ -176,4 +192,4 @@ class ImageBundle:
             image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
             # import IPython; IPython.embed()
         # image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-        return image
+        return image

src/main.py

@@ -4,15 +4,20 @@ from typing import Union
 from argparse import ArgumentParser
 import cv2
 from PIL import Image
-from analyze import analyze_and_visualize
-from skin_analyzer import analyze_skin_function
-from image import ImageBundle
+
+# from src.analyze import analyze_and_visualize
+from src.skin_analyzer import analyze_skin_function
+from src.image import ImageBundle
 import os
 import numpy as np
 import timeit
+
 LOG = logging.getLogger(__name__)
 
-def process_image(filename_or_url: Union[str, Path], analyze_skin, analyze_eyes, analyze_hair):
+
+def process_image(
+    filename_or_url: Union[str, Path], analyze_skin, analyze_eyes, analyze_hair
+):
     """
     Process the image and return the result.
     :param filename_or_url: The filename (in local devices) or URL (in Internet) of the image.
@@ -26,40 +31,40 @@ def process_image(filename_or_url: Union[str, Path], analyze_skin, analyze_eyes,
     start = timeit.default_timer()
     image_bundle = ImageBundle(image_source=filename_or_url)
     stop = timeit.default_timer()
-    print('load image time: ', stop - start)
-    
+    print("load image time: ", stop - start)
+
     # Detect faces and landmarks
     start = timeit.default_timer()
     face_data = image_bundle.detect_faces_and_landmarks()
     stop = timeit.default_timer()
-    print('detect faces and landmarks time: ', stop - start)
+    print("detect faces and landmarks time: ", stop - start)
     start = timeit.default_timer()
     landmarks = image_bundle.detect_face_landmarks()
     stop = timeit.default_timer()
-    print('detect face landmarks time: ', stop - start)
+    print("detect face landmarks time: ", stop - start)
 
     start = timeit.default_timer()
     # Perform segmentation
     segmentation_maps = image_bundle.segment_image()
     stop = timeit.default_timer()
-    print('segment image time: ', stop - start)
-    
+    print("segment image time: ", stop - start)
+
     analysis_results = {}
     overlay_images = []
 
     image_np = image_bundle.numpy_image()
-    print('image_np shape: ', image_np.shape)   
+    print("image_np shape: ", image_np.shape)
     # import IPython; IPython.embed()
 
     if analyze_hair:
         hair_mask = segmentation_maps["hair_mask"]
         hair_analysis = analyze_hair_function(image_np, hair_mask)
-        analysis_results['hair_analysis'] = hair_analysis
+        analysis_results["hair_analysis"] = hair_analysis
         overlay_images.append(segmentation_maps["hair_mask"])
 
     if analyze_skin:
         skin_mask = segmentation_maps["face_skin_mask"]
-        
+
         skin_analysis = analyze_skin_function(image_np, skin_mask)
         overlay_images.append(skin_analysis["overlay_image"])
         if "overlay_image" in skin_analysis.keys():
@@ -68,15 +73,16 @@ def process_image(filename_or_url: Union[str, Path], analyze_skin, analyze_eyes,
             del skin_analysis["filtered_skin_mask"]
         if "dominant_skin_tones" in skin_analysis.keys():
             del skin_analysis["dominant_skin_tones"]
-        analysis_results['skin_analysis'] = skin_analysis
-        
-        # del overlay_images[-1]
+        analysis_results["skin_analysis"] = skin_analysis
 
+        # del overlay_images[-1]
 
     if analyze_eyes:
-        eye_mask = segmentation_maps["right_eye_mask"] | segmentation_maps["left_eye_mask"]
+        eye_mask = (
+            segmentation_maps["right_eye_mask"] | segmentation_maps["left_eye_mask"]
+        )
         eye_analysis = analyze_eye_function(image_np, eye_mask)
-        analysis_results['eye_analysis'] = eye_analysis
+        analysis_results["eye_analysis"] = eye_analysis
         overlay_images.append(segmentation_maps["right_eye_mask"])
 
     # Combine overlay images
@@ -90,12 +96,19 @@ def process_image(filename_or_url: Union[str, Path], analyze_skin, analyze_eyes,
 
     return combined_overlay_bgr, analysis_results
 
+
 if __name__ == "__main__":
     parser = ArgumentParser()
     parser.add_argument("-i", "--image_path", required=True, help="Path to the image")
-    parser.add_argument("--analyze_skin", action="store_true", help="Perform skin analysis")
-    parser.add_argument("--analyze_eyes", action="store_true", help="Perform eye analysis")
-    parser.add_argument("--analyze_hair", action="store_true", help="Perform hair analysis")
+    parser.add_argument(
+        "--analyze_skin", action="store_true", help="Perform skin analysis"
+    )
+    parser.add_argument(
+        "--analyze_eyes", action="store_true", help="Perform eye analysis"
+    )
+    parser.add_argument(
+        "--analyze_hair", action="store_true", help="Perform hair analysis"
+    )
 
     args = parser.parse_args()
     image_path = args.image_path
@@ -105,7 +118,7 @@ if __name__ == "__main__":
         image_path,
         analyze_skin=args.analyze_skin,
         analyze_eyes=args.analyze_eyes,
-        analyze_hair=args.analyze_hair
+        analyze_hair=args.analyze_hair,
     )
 
     # Save the results
@@ -113,12 +126,12 @@ if __name__ == "__main__":
     overlay_image_path = f"outputs/overlay_{im_basename}.png"
     cv2.imwrite(overlay_image_path, combined_overlay)
     import json
+
     # Save the analysis results as JSON, including the path to the overlay image
     analysis_results["overlay_image_path"] = overlay_image_path
     print(analysis_results)
 
-
     with open(f"outputs/analysis_{im_basename}.json", "w") as f:
         json.dump(analysis_results, f, indent=4)
 
-    print("Analysis complete. Results saved in 'outputs' directory.")
+    print("Analysis complete. Results saved in 'outputs' directory.")

src/skin_utils.py

@@ -2,9 +2,10 @@ from PIL import Image
 import numpy as np
 from sklearn.cluster import KMeans
 from collections import Counter
-from color_utils import calculate_color_distance_lab, rgb_to_lab
+from src.color_utils import calculate_color_distance_lab, rgb_to_lab
 import cv2
 
+
 class SkinTonePalette:
     def __init__(self):
         self.palette = {
@@ -62,4 +63,4 @@ class SkinTonePalette:
     def is_within_vectorscope_skin_tone_line(self, rgb_color):
         ycbcr_color = cv2.cvtColor(np.uint8([[rgb_color]]), cv2.COLOR_RGB2YCrCb)[0][0]
         cb, cr = ycbcr_color[1], ycbcr_color[2]
-        return 80 <= cb <= 120 and 133 <= cr <= 173
+        return 80 <= cb <= 120 and 133 <= cr <= 173