Save current state after cleanup

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+model_weights/
+inputs/
+outputs/
+venv-color-palette/
+workspace/
+*.pyc

README.md

@@ -0,0 +1,2 @@
+# ColorPalette
+Color Palette Recommendation

src/__init__.py

@@ -0,0 +1,11 @@
+import numpy as np
+from api import process
+
+# from stone.image import DEFAULT_TONE_PALETTE, DEFAULT_TONE_LABELS, show
+from utils import __version__, check_version
+
+setattr(np, "asscalar", lambda x: np.asarray(x).item())
+
+__all__ = ["process", "__version__"]
+
+check_version()

src/__main__.py

@@ -0,0 +1,222 @@
+import functools
+import logging
+import os
+import shutil
+import sys
+import threading
+from datetime import datetime
+from multiprocessing import freeze_support, cpu_count, Pool
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+from tqdm.contrib.logging import logging_redirect_tqdm
+from typing import List
+
+from stone.api import process
+# from stone.image import normalize_palette
+from stone.utils import (
+    build_arguments,
+    build_image_paths,
+    is_windows,
+    ArgumentError,
+    is_debugging,
+    # resolve_labels,
+)
+from stone.package import (
+    __app_name__,
+    __version__,
+    __description__,
+    __copyright__,
+    __url__,
+    __author__,
+    __license__,
+    __code__,
+    __issues__,
+    __package_name__,
+)
+
+LOG = logging.getLogger(__name__)
+lock = threading.Lock()
+
+use_cli = len(sys.argv) > 1 and "--gui" not in sys.argv
+
+
+def process_in_main(
+    filename_or_url,
+    # image_type,
+    # tone_palette,
+    # tone_labels,
+    # convert_to_black_white,
+    n_dominant_colors=2,
+    # new_width=250,
+    # scale=1.1,
+    # min_nbrs=5,
+    min_size=(90, 90),
+    # threshold=0.3,
+    return_report_image=False,
+):
+    """
+    This is a wrapper function that calls process() in the main process to avoid pickling error.
+    :param filename_or_url:
+    :param image_type:
+    :param tone_palette:
+    :param tone_labels:
+    :param convert_to_black_white:
+    :param n_dominant_colors:
+    :param new_width:
+    :param scale:
+    :param min_nbrs:
+    :param min_size:
+    :param threshold:
+    :param return_report_image:
+    :return:
+    """
+    try:
+        return process(
+            filename_or_url,
+            # image_type=image_type,
+            # tone_palette=tone_palette,
+            # tone_labels=tone_labels,
+            # convert_to_black_white=convert_to_black_white,
+            n_dominant_colors=n_dominant_colors,
+            # new_width=new_width,
+            # scale=scale,
+            # min_nbrs=min_nbrs,
+            min_size=min_size,
+            # threshold=threshold,
+            return_report_image=return_report_image,
+        )
+    except ArgumentError as e:
+        # Abort the app if any argument error occurs
+        raise e
+    except Exception as e:
+        msg = f"Error processing image {filename_or_url}: {str(e)}"
+        LOG.error(msg)
+        return {
+            "filename": filename_or_url,
+            "message": msg,
+        }
+
+
+def main():
+    args = build_arguments()
+    # Setup logger
+    now = datetime.now()
+    os.makedirs("./log", exist_ok=True)
+
+    logging.basicConfig(
+        filename=now.strftime("./log/log-%y%m%d%H%M.log"),
+        level=logging.INFO,
+        format="[%(asctime)s] {%(filename)s:%(lineno)4d} %(levelname)s - %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    image_paths = build_image_paths(args.images, args.recursive)
+
+    debug: bool = args.debug
+
+    n_dominant_colors = args.n_colors
+    min_size = args.min_size[:2]
+    output_dir = args.output
+    os.makedirs(output_dir, exist_ok=True)
+    result_filename = os.path.join(output_dir, "./result.csv")
+
+    def write_to_csv(row: list):
+        with lock:
+            with open(result_filename, "a", newline="", encoding="UTF8") as f:
+                f.write(",".join(map(str, row)) + "\n")
+
+    num_workers = cpu_count() if args.n_workers == 0 else args.n_workers
+
+    pool = Pool(processes=num_workers)
+
+    # Backup result.csv if exists
+    if os.path.exists(result_filename):
+        renamed_file = os.path.join(output_dir, now.strftime("./result_bak_%y%m%d%H%M.csv"))
+        shutil.move(result_filename, renamed_file)
+    header = (
+        "file,image type,face id,"
+        + ",".join([f"dominant {i + 1},percent {i + 1}" for i in range(n_dominant_colors)])
+        + ",skin tone,tone label,accuracy(0-100)"
+    )
+    write_to_csv(header.split(","))
+
+    # Start
+    process_wrapper = functools.partial(
+        process if is_debugging() else process_in_main,
+        n_dominant_colors=n_dominant_colors,
+        min_size=min_size,
+        return_report_image=debug,
+    )
+    print("The program is processing your images...")
+    print("Please wait for the program to finish.")
+    with logging_redirect_tqdm():
+        with tqdm(image_paths, desc="Processing images", unit="images") as pbar:
+            for result in pool.imap(process_wrapper, image_paths):
+                if "faces" in result:
+                    write_to_csv([result["faces"]])
+                    pbar.update()
+                    continue
+
+                basename = result["basename"]
+                extension = result["extension"]
+                # image_type = result["image_type"]
+                faces = result["faces"]
+                report_images = result["report_images"]
+                pbar.set_description(f"Processing {basename}.{extension}")
+                pbar.update()
+    pool.close()
+    pool.join()
+
+
+sys.argv.remove("--gui") if "--gui" in sys.argv else None
+if not use_cli and "--ignore-gooey" not in sys.argv:
+    try:
+        from gooey import Gooey
+    except ImportError:
+        # If gooey is not installed, use a dummy decorator
+        from stone.utils import Gooey
+
+    from importlib.resources import files
+
+    main = Gooey(
+        show_preview_warning=False,
+        advanced=True,  # fixme: `False` is not working
+        dump_build_config=False,  # fixme: `True` is not working, as the path cannot be resolved correctly
+        target="stone",
+        suppress_gooey_flag=True,
+        program_name=f"{__app_name__} v{__version__}",
+        required_cols=1,
+        optional_cols=1,
+        image_dir=str(files("stone.ui")),
+        tabbed_groups=True,
+        navigation="Tabbed",
+        richtext_controls=True,
+        use_cmd_args=True,
+        menu=[
+            {
+                "name": "Help",
+                "items": [
+                    {
+                        "type": "AboutDialog",
+                        "menuTitle": "About",
+                        "name": __app_name__,
+                        "description": __description__,
+                        "version": __version__,
+                        "copyright": __copyright__,
+                        "website": __url__,
+                        "developer": __author__,
+                        "license": __license__,
+                    },
+                    {"type": "Link", "menuTitle": "Documentation", "url": __code__},
+                    {"type": "Link", "menuTitle": "Report Bugs", "url": __issues__},
+                ],
+            },
+        ],
+    )(main)
+
+if __name__ == "__main__":
+    if is_windows():
+        freeze_support()
+    main()

src/analyze.py

@@ -0,0 +1,279 @@
+import cv2
+import numpy as np
+from PIL import Image
+import math
+from sklearn.cluster import KMeans
+from collections import Counter
+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
+import json
+
+
+# Function to create a color bar
+def create_color_bar(height, width, color):
+    bar = np.zeros((height, width, 3), dtype=np.uint8)
+    bar[:] = color
+    return bar
+
+
+# Function to get dominant colors and their percentages
+def get_dominant_colors(image_np, n_colors):
+    pixels = image_np.reshape((-1, 3))
+    kmeans = KMeans(n_clusters=n_colors)
+    kmeans.fit(pixels)
+    dominant_colors = kmeans.cluster_centers_
+    counts = Counter(kmeans.labels_)
+    total_count = sum(counts.values())
+    dominant_colors = [dominant_colors[i] for i in counts.keys()]
+    dominant_percentages = [counts[i] / total_count for i in counts.keys()]
+    return dominant_colors, dominant_percentages
+
+
+# Function to get the closest color from the palette
+def get_closest_color(dominant_colors, palette):
+    closest_color = None
+    closest_hex = None
+    min_distance = float("inf")
+    for dom_color in dominant_colors:
+        for color_name, (color_value, color_hex) in palette.items():
+            distance = np.linalg.norm(dom_color - np.array(color_value))
+            if distance < min_distance:
+                min_distance = distance
+                closest_color = color_name
+                closest_hex = color_hex
+    return closest_color, closest_hex, min_distance
+
+
+# Function to create the dominant color bar
+def create_dominant_color_bar(
+    report_image, dominant_colors, dominant_percentages, bar_width
+):
+    color_bars = []
+    total_height = 0
+    for color, pct in zip(dominant_colors, dominant_percentages):
+        bar_height = int(math.floor(report_image.shape[0] * pct))
+        total_height += bar_height
+        bar = create_color_bar(bar_height, bar_width, color)
+        color_bars.append(bar)
+    padding_height = report_image.shape[0] - total_height
+    if padding_height > 0:
+        padding = create_color_bar(padding_height, bar_width, (255, 255, 255))
+        color_bars.append(padding)
+    return np.vstack(color_bars)
+
+
+# Function to create the tone palette bar
+def create_tone_palette_bar(report_image, tone_id, skin_tone_palette, bar_width):
+    palette_bars = []
+    tone_height = report_image.shape[0] // len(skin_tone_palette)
+    tone_bgrs = []
+    for tone in skin_tone_palette.values():
+        color_bgr = hex_to_bgr(tone[1])
+        tone_bgrs.append(color_bgr)
+        bar = create_color_bar(tone_height, bar_width, color_bgr)
+        palette_bars.append(bar)
+    padding_height = report_image.shape[0] - tone_height * len(skin_tone_palette)
+    if padding_height > 0:
+        padding = create_color_bar(padding_height, bar_width, (255, 255, 255))
+        palette_bars.append(padding)
+    bar = np.vstack(palette_bars)
+
+    padding = 1
+    start_point = (padding, tone_id * tone_height + padding)
+    end_point = (bar_width - padding, (tone_id + 1) * tone_height)
+    bar = cv2.rectangle(bar, start_point, end_point, (255, 0, 0), 2)
+    return bar
+
+
+# Function to create the message bar
+def create_message_bar(
+    dominant_colors, dominant_percentages, tone_hex, distance, img_shape
+):
+    bar_width = img_shape[1]
+    bar_height = img_shape[0] // 30
+    msg_bar = create_color_bar(
+        height=bar_height, width=bar_width, color=(243, 239, 214)
+    )
+    b, g, r = np.around(dominant_colors[0]).astype(int)
+    dominant_color_hex = "#%02X%02X%02X" % (r, g, b)
+    pct = f"{dominant_percentages[0] * 100:.2f}%"
+
+    font, font_scale, txt_color, thickness, line_type = (
+        cv2.FONT_HERSHEY_SIMPLEX,
+        1,
+        (0, 0, 0),
+        1,
+        cv2.LINE_AA,
+    )
+    x, y = 2, 15
+    msg = f"- Dominant color: {dominant_color_hex}, percent: {pct}"
+    cv2.putText(msg_bar, msg, (x, y), font, font_scale, txt_color, thickness, line_type)
+
+    text_size, _ = cv2.getTextSize(msg, font, font_scale, thickness)
+    line_height = text_size[1] + 10
+    accuracy = round(100 - distance, 2)
+    cv2.putText(
+        msg_bar,
+        f"- Skin tone: {tone_hex}, accuracy: {accuracy}",
+        (x, y + line_height),
+        font,
+        font_scale,
+        txt_color,
+        thickness,
+        cv2.LINE_AA,
+    )
+
+    return msg_bar
+
+
+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)
+    skin_mask_np = np.array(skin_mask)
+    eye_mask_np = np.array(eye_mask)
+
+    if not (
+        image_np.shape[:2]
+        == hair_mask_np.shape[:2]
+        == skin_mask_np.shape[:2]
+        == eye_mask_np.shape[:2]
+    ):
+        raise ValueError("Image and all masks must have the same dimensions")
+
+    hair_palette = HairColorPalette()
+    hair_dominant_colors, hair_dominant_percentages = get_dominant_colors(
+        image_np[hair_mask_np > 0], n_colors
+    )
+    hair_color, hair_hex, hair_distance = get_closest_color(
+        hair_dominant_colors, hair_palette.palette
+    )
+
+    skin_palette = SkinTonePalette()
+    skin_dominant_colors, skin_dominant_percentages = get_dominant_colors(
+        image_np[skin_mask_np > 0], n_colors
+    )
+    skin_color, skin_hex, skin_distance = get_closest_color(
+        skin_dominant_colors, skin_palette.palette
+    )
+
+    eye_palette = EyeColorPalette()
+    eye_dominant_colors, eye_dominant_percentages = get_dominant_colors(
+        image_np[eye_mask_np > 0], n_colors
+    )
+    eye_color, eye_hex, eye_distance = get_closest_color(
+        eye_dominant_colors, eye_palette.palette
+    )
+
+    # create overlay for different color for hair, skin and eye
+    hair_overlay = np.zeros_like(image_np)
+    skin_overlay = np.zeros_like(image_np)
+    eye_overlay = np.zeros_like(image_np)
+
+    hair_overlay[hair_mask_np > 0] = [0, 255, 0]  # hex_to_rgb(hair_hex)
+    skin_overlay[skin_mask_np > 0] = [255, 0, 0]  # hex_to_rgb(skin_hex)
+    eye_overlay[eye_mask_np > 0] = [0, 0, 255]  # hex_to_rgb(eye_hex)
+
+    combined_overlay = cv2.addWeighted(image_np, 0.8, hair_overlay, 0.2, 0)
+    combined_overlay = cv2.addWeighted(combined_overlay, 0.8, skin_overlay, 0.2, 0)
+    combined_overlay = cv2.addWeighted(combined_overlay, 0.8, eye_overlay, 0.2, 0)
+
+    bar_width = 50
+    hair_color_bar = create_dominant_color_bar(
+        image_np, hair_dominant_colors, hair_dominant_percentages, bar_width
+    )
+    skin_color_bar = create_dominant_color_bar(
+        image_np, skin_dominant_colors, skin_dominant_percentages, bar_width
+    )
+    eye_color_bar = create_dominant_color_bar(
+        image_np, eye_dominant_colors, eye_dominant_percentages, bar_width
+    )
+
+    hair_palette_bar = create_tone_palette_bar(
+        image_np,
+        list(hair_palette.palette.keys()).index(hair_color),
+        hair_palette.palette,
+        bar_width,
+    )
+    skin_palette_bar = create_tone_palette_bar(
+        image_np,
+        list(skin_palette.palette.keys()).index(skin_color),
+        skin_palette.palette,
+        bar_width,
+    )
+    eye_palette_bar = create_tone_palette_bar(
+        image_np,
+        list(eye_palette.palette.keys()).index(eye_color),
+        eye_palette.palette,
+        bar_width,
+    )
+
+    output_image = np.hstack(
+        [
+            combined_overlay,
+            hair_color_bar,
+            hair_palette_bar,
+            skin_color_bar,
+            skin_palette_bar,
+            eye_color_bar,
+            eye_palette_bar,
+        ]
+    )
+    img_shape = output_image.shape
+    msg_bar_hair = create_message_bar(
+        hair_dominant_colors,
+        hair_dominant_percentages,
+        hair_hex,
+        hair_distance,
+        img_shape,
+    )
+    msg_bar_skin = create_message_bar(
+        skin_dominant_colors,
+        skin_dominant_percentages,
+        skin_hex,
+        skin_distance,
+        img_shape,
+    )
+    msg_bar_eye = create_message_bar(
+        eye_dominant_colors, eye_dominant_percentages, eye_hex, eye_distance, img_shape
+    )
+
+    output_image = np.vstack([output_image, msg_bar_hair, msg_bar_skin, msg_bar_eye])
+    # Create JSON record
+    analysis_record = {
+        "hair": {
+            "dominant_colors": [rgb_to_hex(color) for color in hair_dominant_colors],
+            "dominant_percentages": hair_dominant_percentages,
+            "closest_color": hair_color,
+            "closest_color_hex": hair_hex,
+            "distance": hair_distance,
+        },
+        "skin": {
+            "dominant_colors": [rgb_to_hex(color) for color in skin_dominant_colors],
+            "dominant_percentages": skin_dominant_percentages,
+            "closest_color": skin_color,
+            "closest_color_hex": skin_hex,
+            "distance": skin_distance,
+        },
+        "eyes": {
+            "dominant_colors": [rgb_to_hex(color) for color in eye_dominant_colors],
+            "dominant_percentages": eye_dominant_percentages,
+            "closest_color": eye_color,
+            "closest_color_hex": eye_hex,
+            "distance": eye_distance,
+        },
+    }
+
+    # Save output image and JSON record
+    # cv2.imwrite("output_image.png", output_image)
+    # with open("analysis_record.json", "w") as json_file:
+    #     json.dump(analysis_record, json_file, indent=4)
+
+    return output_image, analysis_record
+    # cv2.imwrite("output_image.png", output_image)
+
+
+# Example usage
+# analyze_and_visualize('path_to_image.jpg', 'path_to_hair_mask.png', 'path_to_skin_mask.png', 'path_to_eye_mask.png')

src/api.py

@@ -0,0 +1,52 @@
+import logging
+from pathlib import Path
+from typing import Union, Literal
+
+import cv2
+from stone.analyze import analyze_and_visualize
+from stone.image import ImageBundle
+from stone.utils import ArgumentError
+
+LOG = logging.getLogger(__name__)
+
+
+def process(
+    filename_or_url: Union[str, Path],
+    n_dominant_colors: int = 3,
+    min_size: tuple[int, int] = (90, 90),
+    return_report_image=False,
+):
+    """
+    Process the image and return the result.
+    :param filename_or_url: The filename (in local devices) or URL (in Internet) of the image.
+    :param image_type: Specify whether the input image(s) is/are colored or black/white.
+           Valid choices are: "auto", "color" or "bw", Defaults to "auto", which will be detected automatically.
+    :param convert_to_black_white: Whether to convert the image to black/white before processing. Defaults to False.
+    :param n_dominant_colors: Number of dominant colors to be extracted from the image. Defaults to 2.
+    :param min_size: Minimum possible face size. Faces smaller than that are ignored, defaults to (90, 90).
+    :param return_report_image: Whether to return the report image(s) in the result. Defaults to False.
+    :return:
+
+    """
+    
+    ib = ImageBundle(filename_or_url)
+    basename, ext = ib.basename, ib.ext
+    faces = ib._get_faces(detector_backend='retinaface', min_size=min_size)
+    if len(faces) == 0:
+        raise ArgumentError("No face detected in the image.")
+    segmentation_maps = ib._segment_image()
+    image = ib.numpy_image()
+
+    hair_mask = segmentation_maps["hair_mask"]
+    skin_mask = segmentation_maps["face_skin_mask"]
+    eye_mask = segmentation_maps["eyes_mask"]
+    
+    report_images, records = analyze_and_visualize(image, hair_mask, skin_mask, eye_mask, n_colors=n_dominant_colors)
+    return {
+        "basename": basename,
+        "extension": ext,
+        "faces": records,
+        "report_images": report_images if return_report_image else None,
+    }
+
+

src/color_utils.py

@@ -0,0 +1,47 @@
+from colormath.color_objects import sRGBColor, LabColor
+from colormath.color_conversions import convert_color
+from colormath.color_diff import delta_e_cie2000
+
+def rgb_to_lab(rgb):
+    """
+    Convert an RGB color to LAB color.
+    :param rgb: A tuple (R, G, B) with values ranging from 0 to 255.
+    :return: A LabColor object.
+    """
+    srgb_color = sRGBColor(rgb[0], rgb[1], rgb[2], is_upscaled=True)
+    lab_color = convert_color(srgb_color, LabColor)
+    return lab_color
+
+# Helper function to convert RGB to hex
+def rgb_to_hex(rgb_color):
+    r, g, b = rgb_color
+    return "#%02X%02X%02X" % (int(r), int(g), int(b))
+# Function to convert hex color to BGR
+def hex_to_bgr(hex_color):
+    hex_value = hex_color.lstrip("#")
+    r, g, b = [int(hex_value[i:i + 2], 16) for i in (0, 2, 4)]
+    return [b, g, r]
+
+def hex_to_rgb(hex_color):
+    hex_value = hex_color.lstrip("#")
+    r, g, b = [int(hex_value[i:i + 2], 16) for i in (0, 2, 4)]
+    return [r, g, b]
+
+def calculate_color_distance_lab(color1, color2):
+    """
+    Calculate the distance between two colors in LAB space using the CIE2000 formula.
+    :param color1: A tuple (R, G, B) with values ranging from 0 to 255.
+    :param color2: A tuple (R, G, B) with values ranging from 0 to 255.
+    :return: The distance between the two colors.
+    """
+    lab1 = rgb_to_lab(color1)
+    lab2 = rgb_to_lab(color2)
+    distance = delta_e_cie2000(lab1, lab2)
+    return distance
+
+# # Example usage
+# color1 = (255, 215, 0)  # Golden Blonde RGB
+# color2 = (255, 248, 220)  # Platinum Blonde RGB
+
+# distance = calculate_color_distance_lab(color1, color2)
+# print(f"Color distance in LAB space: {distance}")

src/eyes_utils.py

@@ -0,0 +1,75 @@
+from PIL import Image
+import numpy as np
+from sklearn.cluster import KMeans
+from collections import Counter
+from src.color_utils import calculate_color_distance_lab
+
+
+class EyeColorPalette:
+    def __init__(self):
+        self.palette = {
+            "Light Blue": ((173, 216, 230), "#ADD8E6"),
+            "Dark Blue": ((0, 0, 139), "#00008B"),
+            "Light Green": ((144, 238, 144), "#90EE90"),
+            "Dark Green": ((0, 100, 0), "#006400"),
+            "Hazel": ((218, 165, 32), "#DAA520"),
+            "Light Brown": ((210, 180, 140), "#D2B48C"),
+            "Dark Brown": ((101, 67, 33), "#654321"),
+            "Gray": ((169, 169, 169), "#A9A9A9"),
+            "Amber": ((255, 191, 0), "#FFBF00"),
+        }
+
+    def get_dominant_colors(self, image_np, n_colors):
+        # Reshape the image to be a list of pixels
+        pixels = image_np.reshape((-1, 3))
+
+        # Use KMeans to find n_colors clusters in the image
+        kmeans = KMeans(n_clusters=n_colors)
+        kmeans.fit(pixels)
+
+        # Get the cluster centers (dominant colors)
+        dominant_colors = kmeans.cluster_centers_
+
+        # Get the number of pixels in each cluster
+        counts = Counter(kmeans.labels_)
+
+        # Sort the colors by the number of pixels in each cluster
+        dominant_colors = [dominant_colors[i] for i in counts.keys()]
+
+        return dominant_colors
+
+    def get_closest_color(self, image, mask, n_colors=3):
+        # Convert images to numpy arrays
+        image_np = np.array(image)
+        mask_np = np.array(mask)
+
+        # Ensure the images have the same size
+        if image_np.shape[:2] != mask_np.shape[:2]:
+            raise ValueError("Image and mask must have the same dimensions")
+
+        # Extract the eye region from the image
+        eye_pixels = image_np[mask_np > 0]
+
+        # Get dominant colors from the eye region
+        dominant_colors = self.get_dominant_colors(eye_pixels, n_colors)
+
+        # Find the closest color in the palette
+        closest_color = None
+        closest_hex = None
+        min_distance = float("inf")
+        for dom_color in dominant_colors:
+            for color_name, (color_value, color_hex) in self.palette.items():
+                distance = calculate_color_distance_lab(dom_color, color_value)
+                # distance = np.linalg.norm(dom_color - np.array(color_value))
+                if distance < min_distance:
+                    min_distance = distance
+                    closest_color = color_name
+                    closest_hex = color_hex
+
+        return closest_color, closest_hex
+
+
+# Example usage
+# palette = EyeColorPalette()
+# closest_color, closest_hex = palette.get_closest_color('path_to_image.jpg', 'path_to_mask.png')
+# print(f"The closest eye color is: {closest_color} with hex code: {closest_hex}")

src/hair_utils.py

@@ -0,0 +1,84 @@
+from PIL import Image
+import numpy as np
+from sklearn.cluster import KMeans
+from collections import Counter
+from stone.color_utils import calculate_color_distance_lab
+class HairColorPalette:
+    def __init__(self):
+        self.palette = {
+            "Platinum Blonde": ((255, 248, 220), "#FFF8DC"),
+            "Ash Blonde": ((190, 190, 190), "#BEBEBE"),
+            "Golden Blonde": ((255, 215, 0), "#FFD700"),
+            "Strawberry Blonde": ((255, 204, 153), "#FFCC99"),
+            "Light Brown": ((165, 42, 42), "#A52A2A"),
+            "Medium Brown": ((139, 69, 19), "#8B4513"),
+            "Dark Brown": ((92, 64, 51), "#5C4033"),
+            "Chestnut Brown": ((152, 105, 96), "#986960"),
+            "Light Auburn": ((255, 69, 0), "#FF4500"),
+            "Copper Red": ((184, 115, 51), "#B87333"),
+            "Dark Auburn": ((139, 0, 0), "#8B0000"),
+            "Mahogany": ((192, 64, 0), "#C04000"),
+            "Jet Black": ((10, 10, 10), "#0A0A0A"),
+            "Soft Black": ((59, 59, 59), "#3B3B3B"),
+            "Blue Black": ((20, 30, 60), "#141E3C"),
+            "Pastel Pink": ((255, 209, 220), "#FFD1DC"),
+            "Electric Blue": ((0, 127, 255), "#007FFF"),
+            "Lavender": ((230, 230, 250), "#E6E6FA"),
+            "Emerald Green": ((80, 200, 120), "#50C878"),
+            "Silver": ((192, 192, 192), "#C0C0C0"),
+        }
+
+    def get_dominant_colors(self, image_np, n_colors):
+        # Reshape the image to be a list of pixels
+        pixels = image_np.reshape((-1, 3))
+        
+        # Use KMeans to find n_colors clusters in the image
+        kmeans = KMeans(n_clusters=n_colors)
+        kmeans.fit(pixels)
+        
+        # Get the cluster centers (dominant colors)
+        dominant_colors = kmeans.cluster_centers_
+        
+        # Get the number of pixels in each cluster
+        counts = Counter(kmeans.labels_)
+        
+        # Sort the colors by the number of pixels in each cluster
+        dominant_colors = [dominant_colors[i] for i in counts.keys()]
+        
+        return dominant_colors
+
+    def get_closest_color(self, image, mask, n_colors=3):
+        # Convert images to numpy arrays
+        image_np = np.array(image)
+        mask_np = np.array(mask)
+        
+        # Ensure the images have the same size
+        if image_np.shape[:2] != mask_np.shape[:2]:
+            raise ValueError("Image and mask must have the same dimensions")
+        
+        
+        # Extract the hair region from the image
+        hair_pixels = image_np[mask_np > 0]
+        
+        # Get dominant colors from the hair region
+        dominant_colors = self.get_dominant_colors(hair_pixels, n_colors)
+        
+        # Find the closest color in the palette
+        closest_color = None
+        closest_hex = None
+        min_distance = float('inf')
+        for dom_color in dominant_colors:
+            for color_name, (color_value, color_hex) in self.palette.items():
+                distance = calculate_color_distance_lab(dom_color, color_value)
+                # distance = np.linalg.norm(dom_color - np.array(color_value))
+                if distance < min_distance:
+                    min_distance = distance
+                    closest_color = color_name
+                    closest_hex = color_hex
+        
+        return closest_color, closest_hex
+
+# Example usage
+# palette = HairColorPalette()
+# closest_color, closest_hex = palette.get_closest_color('path_to_image.jpg', 'path_to_mask.png')
+# print(f"The closest hair color is: {closest_color} with hex code: {closest_hex}")

src/image.py

@@ -0,0 +1,153 @@
+# Description: Image handling utilities for the Skin Tone Classifier.
+import logging
+import cv2
+import numpy as np
+from deepface import DeepFace
+from stone.utils import is_url, extract_filename_and_extension, alphabet_id, ArgumentError
+from stone.segmentation_utils import detect_eye_mask, mediapipe_selfie_segmentor
+import requests
+from PIL import Image, ExifTags, ImageCms
+from io import BytesIO
+import pillow_heif
+# Register HEIF opener
+pillow_heif.register_heif_opener()
+
+
+
+LOG = logging.getLogger(__name__)
+
+class ImageBundle:
+    def __init__(self, image_source):
+        """
+        Initialize the ImageHandler object.
+        :param image_source: Path to the image file or URL of the image.
+        """
+        self.image_source = image_source
+        self.image = None
+        self.exif_data = {}
+        self.segmentation_maps = {}
+        self._open_image()
+
+    def _open_image(self):
+        """
+        Open the image and preserve EXIF data.
+        """
+        try:
+            if is_url(self.image_source):
+                self._open_image_from_url(self.image_source)
+            else:
+                self._open_image_from_path(self.image_source)
+            self._handle_color_profile()
+            self._extract_exif_data()
+            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:
+                raise ValueError("The image is black and white. Please provide a colored image.")
+            
+        except Exception as e:
+            print(f"An error occurred while opening the image: {e}")
+            self.image = None
+
+    def _open_image_from_path(self, image_path):
+        """
+        Open an image from a file path.
+        :param image_path: Path to the image file.
+        """
+        self.image = Image.open(image_path)
+
+    def _open_image_from_url(self, image_url):
+        """
+        Open an image from a URL.
+        :param image_url: URL of the image.
+        """
+        response = requests.get(image_url)
+        response.raise_for_status()  # Raise an exception for HTTP errors
+        self.image = Image.open(BytesIO(response.content))
+
+    def _handle_color_profile(self):
+        """
+        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:
+                io = BytesIO(icc_profile)
+                src_profile = ImageCms.ImageCmsProfile(io)
+                dst_profile = ImageCms.createProfile("sRGB")
+                self.image = ImageCms.profileToProfile(self.image, src_profile, dst_profile)
+
+    def _extract_exif_data(self):
+        """
+        Extract EXIF data from the image.
+        """
+        if hasattr(self.image, '_getexif'):
+            exif_info = self.image._getexif()
+            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 _is_black_and_white(self):
+        """
+        Check if the image is black and white even if it has 3 channels.
+        :return: True if the image is black and white, otherwise False.
+        """
+        if self.image.mode not in ['RGB', 'RGBA']:
+            return self.image.mode in ['1', 'L']
+        
+        np_image = np.array(self.image)
+        if len(np_image.shape) == 3 and np_image.shape[2] == 3:
+            r, g, b = np_image[:,:,0], np_image[:,:,1], np_image[:,:,2]
+            return np.all(r == g) and np.all(g == b)
+        return False
+    
+    def _get_faces(self, detector_backend='retinaface', is_bw=False, min_size=(90, 90)):
+        """
+        Get the coordinates of the detected faces in the image.
+        :param detector_backend: Face detector backend to use.
+        :param is_bw: Whether the image is black and white.
+        gets a list of faces detected, with each face as dict of facial_area, face, confidence
+        """
+        self.faces = DeepFace.extract_faces(self.numpy_image(), detector_backend=detector_backend, grayscale=is_bw)
+        if len(self.faces) == 0:
+            raise ValueError("No face is detected in the image.")
+        elif len(self.faces) > 1:
+            raise ValueError("Multiple faces are detected in the image.")
+        else:
+            # check if the face is too small
+            face = self.faces[0]
+            if face["facial_area"]["w"] < min_size[0] or face["facial_area"]["h"] < min_size[1]:
+                raise ValueError("The face is too small.")
+            else:
+                self.faces = self.faces[0]
+
+        return self.faces
+
+    def numpy_image(self):
+        """
+        Convert the image to a numpy array.
+        :return: Numpy array of the image.
+        """
+        return np.array(self.image)
+
+
+    def _segment_image(self, segment=["face_skin", "body_skin", "hair", "eyes", "clothes"]):
+        """
+        Get a segmentation map by name.
+        :param name: Name of the segmentation map.
+        :return: Segmentation map as a numpy array or None if not found.
+        """
+        if "eyes" in segment:
+            del segment[segment.index("eyes")]
+            eye_mask = detect_eye_mask(self.numpy_image(), self.faces)
+            self.segmentation_maps["eyes_mask"] = eye_mask
+        if "face_skin" in segment or "body_skin" in segment or "hair" in segment or "clothes" in segment:
+            # import IPython; IPython.embed()
+            mask_dict = mediapipe_selfie_segmentor(self.numpy_image(), segment=segment)
+            for seg in segment:
+                self.segmentation_maps[seg+"_mask"] = mask_dict[seg]
+        return self.segmentation_maps
+    
+    
+
+

src/package.py

@@ -0,0 +1,12 @@
+__version__ = "1.2.4"
+__package_name__ = "skin-tone-classifier"
+__app_name__ = "Skin Tone Classifier"
+__description__ = "An easy-to-use library for skin tone classification"
+__author__ = "Chenglong Ma"
+__author_email__ = "chenglong.m@outlook.com"
+__author_website__ = "https://chenglongma.com/"
+__url__ = "https://chenglongma.com/SkinToneClassifier/"
+__code__ = "https://github.com/ChenglongMa/SkinToneClassifier/"
+__issues__ = "https://github.com/ChenglongMa/SkinToneClassifier/issues"
+__license__ = "GPLv3"
+__copyright__ = "2022"

src/segmentation_utils.py

@@ -0,0 +1,50 @@
+from mediapipe.tasks import python
+from mediapipe.tasks.python import vision
+import mediapipe as mp
+import cv2
+import numpy as np
+
+def mediapipe_selfie_segmentor(image: np.ndarray, segment: list = ["face_skin", "body_skin", "hair"]):
+    # Create the options that will be used for ImageSegmenter
+    base_options = python.BaseOptions(
+        model_asset_path="model_weights/selfie_segmenter.tflite"
+    )
+    options = vision.ImageSegmenterOptions(
+        base_options=base_options,
+        output_category_mask=True,
+        output_confidence_masks=True,
+    )
+    with vision.ImageSegmenter.create_from_options(options) as segmenter:
+        # Create the MediaPipe image file that will be segmented
+        image = mp.Image(image_format=mp.ImageFormat.SRGB, data=image)
+
+        # Retrieve the masks for the segmented image
+        segmentation_result = segmenter.segment(image)
+        category_mask = segmentation_result.category_mask.numpy_view()
+        bg_mask = (category_mask == 0)
+        hair_mask = (category_mask == 1)
+        body_skin_mask = (category_mask == 2)
+        face_skin_mask = (category_mask == 3)
+        clothes_mask = (category_mask == 4)
+        
+    return_dict = {}
+    for seg in segment:
+        return_dict[seg] = locals()[seg + "_mask"]
+    return return_dict
+
+
+def detect_eye_mask(image, face_coord):
+    
+    h, w = image.shape[0:2]
+    imgMask = np.zeros((h, w), np.uint8)
+    
+    left_eye = face_coord["facial_area"]["left_eye"]
+    right_eye = face_coord["facial_area"]["right_eye"]
+
+    eye_distance = np.linalg.norm(np.array(left_eye)-np.array(right_eye))
+    eye_radius = eye_distance/12 # approximate
+   
+    cv2.circle(imgMask, left_eye, int(eye_radius), (255,255,255), -1)
+    cv2.circle(imgMask, right_eye, int(eye_radius), (255,255,255), -1)
+
+    return imgMask

src/skin_utils.py

@@ -0,0 +1,150 @@
+from PIL import Image
+import numpy as np
+from sklearn.cluster import KMeans
+from collections import Counter
+from stone.color_utils import calculate_color_distance_lab
+class SkinTonePalette:
+    def __init__(self):
+        self.palette = {
+            "Ebony": ((55, 48, 40), "#373028"),
+            "Deep Mocha": ((66, 40, 17), "#422811"),
+            "Dark Chocolate": ((81, 59, 46), "#513b2e"),
+            "Warm Almond": ((111, 80, 60), "#6f503c"),
+            "Golden Bronze": ((129, 101, 79), "#81654f"),
+            "Honey": ((157, 122, 84), "#9d7a54"),
+            "Caramel": ((190, 160, 126), "#bea07e"),
+            "Light Tan": ((229, 200, 166), "#e5c8a6"),
+            "Peach": ((231, 193, 184), "#e7c1b8"),
+            "Fair": ((243, 218, 214), "#f3dad6"),
+            "Ivory": ((251, 242, 243), "#fbf2f3"),
+        }
+
+    def get_dominant_colors(self, image_np, n_colors):
+        # Reshape the image to be a list of pixels
+        pixels = image_np.reshape((-1, 3))
+        
+        # Use KMeans to find n_colors clusters in the image
+        kmeans = KMeans(n_clusters=n_colors)
+        kmeans.fit(pixels)
+        
+        # Get the cluster centers (dominant colors)
+        dominant_colors = kmeans.cluster_centers_
+        
+        # Get the number of pixels in each cluster
+        counts = Counter(kmeans.labels_)
+        
+        # Sort the colors by the number of pixels in each cluster
+        dominant_colors = [dominant_colors[i] for i in counts.keys()]
+        
+        return dominant_colors
+
+    def get_closest_color(self, image, mask, n_colors=3):
+
+        # Convert images to numpy arrays
+        image_np = np.array(image)
+        mask_np = np.array(mask)        
+
+        # Ensure the images have the same h and w
+        if image_np.shape[:2] != mask_np.shape[:2]:
+            raise ValueError("Image and mask must have the same dimensions")
+    
+        
+        # Extract the skin region from the image
+        skin_pixels = image_np[mask_np > 0]
+        
+        # Get dominant colors from the skin region
+        dominant_colors = self.get_dominant_colors(skin_pixels, n_colors)
+        
+        # Find the closest color in the palette
+        closest_color = None
+        closest_hex = None
+        min_distance = float('inf')
+        for dom_color in dominant_colors:
+            for color_name, (color_value, color_hex) in self.palette.items():
+                distance = calculate_color_distance_lab(dom_color, color_value)
+                # distance = np.linalg.norm(dom_color - np.array(color_value))
+                if distance < min_distance:
+                    min_distance = distance
+                    closest_color = color_name
+                    closest_hex = color_hex
+        
+        return closest_color, closest_hex
+
+# Example usage
+# palette = SkinTonePalette()
+# closest_color, closest_hex = palette.get_closest_color('path_to_image.jpg', 'path_to_mask.png')
+# print(f"The closest skin tone is: {closest_color} with hex code: {closest_hex}")
+# def dominant_colors(image, to_bw, n_clusters=2):
+#     if to_bw:
+#         data = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+#         data = cv2.cvtColor(data, cv2.COLOR_GRAY2BGR)
+#     else:
+#         data = image
+#     data = np.reshape(data, (-1, 3))
+#     data = data[np.all(data != 0, axis=1)]
+#     data = np.float32(data)
+
+#     criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
+#     flags = cv2.KMEANS_RANDOM_CENTERS
+#     compactness, labels, colors = cv2.kmeans(data, n_clusters, None, criteria, 10, flags)
+#     labels, counts = np.unique(labels, return_counts=True)
+
+#     order = (-counts).argsort()
+#     colors = colors[order]
+#     counts = counts[order]
+
+#     percents = counts / counts.sum()
+
+#     return colors, percents
+
+# DEFAULT_TONE_PALETTE = {
+#     "color": [
+#         "#373028",
+#         "#422811",
+#         "#513b2e",
+#         "#6f503c",
+#         "#81654f",
+#         "#9d7a54",
+#         "#bea07e",
+#         "#e5c8a6",
+#         "#e7c1b8",
+#         "#f3dad6",
+#         "#fbf2f3",
+#     ],
+#     # Refer to this paper:
+#     # Leigh, A., & Susilo, T. (2009). Is voting skin-deep? Estimating the effect of candidate ballot photographs on election outcomes.
+#     # Journal of Economic Psychology, 30(1), 61-70.
+#     "bw": [
+#         "#FFFFFF",
+#         "#F0F0F0",
+#         "#E0E0E0",
+#         "#D0D0D0",
+#         "#C0C0C0",
+#         "#B0B0B0",
+#         "#A0A0A0",
+#         "#909090",
+#         "#808080",
+#         "#707070",
+#         "#606060",
+#         "#505050",
+#         "#404040",
+#         "#303030",
+#         "#202020",
+#         "#101010",
+#         "#000000",
+#     ],
+# }
+
+# DEFAULT_TONE_LABELS = {
+#     "color": ["C" + alphabet_id(i) for i in range(len(DEFAULT_TONE_PALETTE["color"]))],
+#     "bw": ["B" + alphabet_id(i) for i in range(len(DEFAULT_TONE_PALETTE["bw"]))],
+# }
+# def skin_tone(colors, percents, skin_tone_palette, tone_labels):
+#     lab_tones = [convert_color(sRGBColor.new_from_rgb_hex(rgb), LabColor) for rgb in skin_tone_palette]
+#     lab_colors = [convert_color(sRGBColor(rgb_r=r, rgb_g=g, rgb_b=b, is_upscaled=True), LabColor) for b, g, r in colors]
+#     distances = [np.sum([delta_e_cie2000(c, label) * p for c, p in zip(lab_colors, percents)]) for label in lab_tones]
+#     tone_id = np.argmin(distances)
+#     distance: float = distances[tone_id]
+#     tone_hex = skin_tone_palette[tone_id].upper()
+#     tone_label = tone_labels[tone_id]
+#     return tone_id, tone_hex, tone_label, distance

src/utils.py

@@ -0,0 +1,529 @@
+import argparse
+import functools
+import logging
+import os
+import re
+import string
+import sys
+from pathlib import Path
+from typing import Union
+from urllib.parse import urlparse
+
+from stone.package import __version__, __package_name__, __description__, __app_name__
+
+LOG = logging.getLogger(__name__)
+
+
+class ArgumentError(ValueError):
+    """
+    Wrapper for argument error. This exception will be raised when the arguments are invalid.
+    """
+
+    pass
+
+
+def Gooey(*args, **kwargs):
+    """
+    Dummy decorator for Gooey.
+    Used in CLI mode to avoid the import error when the Gooey package is not installed.
+    :param args:
+    :param kwargs:
+    :return:
+    """
+
+    def inner(func):
+        return func
+
+    return inner
+
+
+@functools.cache
+def alphabet_id(n):
+    letters = string.ascii_uppercase
+    n_letters = len(letters)
+    if n < n_letters:
+        return letters[n]
+    _id = ""
+
+    while n > 0:
+        remainder = (n - 1) % n_letters
+        _id = letters[remainder] + _id
+        n = (n - 1) // n_letters
+
+    return _id
+
+
+def is_url(text):
+    return urlparse(text).scheme in ["http", "https"]
+
+
+def extract_filename_and_extension(url):
+    """
+    Extract base filename and extension from the url.
+    :param url: URL with filename and extension, e.g., https://example.com/images/pic.jpg?param=value
+    :return: Base filename and extension, e.g., pic, jpg
+    """
+    parsed_url = urlparse(url)
+    path = parsed_url.path
+    filename = path.split("/")[-1]
+    basename, *extension = filename.split(".")
+    return basename, f".{extension[0]}" if extension else None
+
+
+def build_image_paths(images_paths, recursive=False):
+    filenames, urls = [], []
+    valid_images = ["*.jpg", "*.gif", "*.png", "*.jpeg", "*.webp", "*.tif"]
+    excluded_folders = ["debug", "log"]
+    if isinstance(images_paths, str):
+        images_paths = [images_paths]
+
+    for filename in images_paths:
+        if is_url(filename):
+            urls.append(filename)
+            continue
+        p = Path(filename)
+        if p.is_dir():
+            images = [p.glob(pattern) for pattern in valid_images]
+            if recursive:
+                subfolders = [f for f in p.glob("*/") if f.name not in excluded_folders]
+                images.extend([sp.rglob(pattern) for pattern in valid_images for sp in subfolders])
+
+            filenames.extend(images)
+        elif p.is_file():
+            filenames.append([p])
+    paths = set([f.resolve() for fs in filenames for f in fs] + urls)
+    paths = list(paths)
+    if len(paths) == 0:
+        raise FileNotFoundError("No valid images in the specified path.")
+    # Sort paths by (first) number extracted from the filename string
+    paths.sort(key=sort_file)
+    return paths
+
+
+def sort_file(path: Union[str, Path]):
+    if isinstance(path, Path):
+        basename = path.stem
+    else:
+        basename, *_ = extract_filename_and_extension(path)
+    nums = re.findall(r"\d+", basename)
+    return (int(nums[0]) if nums else float("inf")), basename
+
+
+def is_windows():
+    return sys.platform in ["win32", "cygwin"]
+
+
+def is_debugging():
+    gettrace = getattr(sys, "gettrace", None)
+    return gettrace is not None and gettrace()
+
+
+def build_arguments():
+    try:
+        from gooey import GooeyParser
+
+        in_gui = True
+    except ImportError:
+        from argparse import ArgumentParser as GooeyParser
+
+        in_gui = False
+
+    kwargs = dict(formatter_class=argparse.RawTextHelpFormatter) if not in_gui else {}
+    parser = GooeyParser(
+        description=__description__,
+        **kwargs,
+    )
+    kwargs = (
+        {
+            "gooey_options": {"show_border": False, "columns": 1},
+        }
+        if in_gui
+        else {}
+    )
+    files = parser.add_argument_group(
+        "Images to process",
+        "The locations of images to process, which can be directories, files, or URLs.\n"
+        "Multiple values are separated by space;\n"
+        'You can mix folders, filenames and web links together, e.g., "/path/to/dir1 /path/to/pic.jpg https://example.com/pic.png".\n',
+        **kwargs,
+    )
+    kwargs = {"gooey_options": {"visible": False}} if in_gui else {}
+
+    files.add_argument(
+        "-i",
+        "--images",
+        nargs="+",
+        default=[os.getcwd()],
+        metavar="Image Filenames",
+        help="Image filename(s), Directories or URLs to process. Separated by space.",
+        **kwargs,
+    )
+    if in_gui:
+        files.add_argument(
+            "--image_dirs",
+            nargs="+",
+            metavar="Image Directories",
+            widget="DirChooser",
+            # widget="MultiDirChooser", # fixme: enable this widget when issues are fixed
+            gooey_options={
+                "message": "Select directories to process",
+                "initial_value": os.getcwd(),
+                "default_path": os.getcwd(),
+                "placeholder": "e.g., /path/to/dir1 /path/to/dir2",
+            },
+        )
+    kwargs = dict(metavar="Recursive Search") if in_gui else {}
+    files.add_argument(
+        "-r",
+        "--recursive",
+        action="store_true",
+        help="Search images recursively in the specified directory.",
+        **kwargs,
+    )
+    if in_gui:
+        files.add_argument(
+            "--image_files",
+            nargs="+",
+            metavar="Image Filenames",
+            help="Add individual image file(s)",
+            widget="MultiFileChooser",
+            gooey_options={
+                "wildcard": "All images|*.jpg;*.jpeg;*.png;*.bmp;*.gif;*.tif;*.webp|"
+                "JPG (*.jpg)|*.jpg|"
+                "JPEG (*.jpeg)|*.jpeg|"
+                "PNG (*.png)|*.png|"
+                "BMP (*.bmp)|*.bmp|"
+                "GIF (*.gif)|*.gif|"
+                "TIFF (*.tif)|*.tif|"
+                "WEBP (*.webp)|*.webp|"
+                "All files (*.*)|*.*",
+                "message": "Select the image file(s) to process",
+                "default_dir": os.getcwd(),
+                "full_width": False,
+                "placeholder": "e.g., a.jpg b.png",
+            },
+        )
+
+        files.add_argument(
+            "--image_urls",
+            nargs="+",
+            metavar="Image URLs",
+            help="Add image URLs",
+            gooey_options={
+                "full_width": False,
+                "placeholder": "e.g., https://example.com/a.jpg https://example.com/b.png",
+            },
+        )
+
+    kwargs = {"gooey_options": {"show_border": False, "columns": 2}} if in_gui else {}
+    images = parser.add_argument_group(
+        "Image Settings",
+        **kwargs,
+    )
+    bw_option = "black/white" if in_gui else "bw"
+    images.add_argument(
+        "-t",
+        "--image_type",
+        default="auto",
+        metavar="Image Type",
+        help="Specify whether the input image(s) is/are colored or black/white.\n"
+        f'Defaults to "auto", which will be detected automatically. Other options are "color" and "{bw_option}".\n',
+        choices=["auto", "color", bw_option],
+    )
+    kwargs = {"gooey_options": {"full_width": True}} if in_gui else {}
+    images.add_argument(
+        "-p",
+        "--palette",
+        nargs="+",
+        metavar="Palette",
+        help="Skin tone palette;\n"
+        'Input RGB hex values leading by "#" or RGB values separated by comma(,),\n'
+        "E.g., #373028 #422811 or 255,255,255 100,100,100\n"
+        "Leave blank to use the default palette as mentioned in the document.\n",
+        **kwargs,
+    )
+    images.add_argument(
+        "-l",
+        "--labels",
+        nargs="+",
+        metavar="Labels",
+        help="Skin tone labels;\n"
+        "Leave blank to use the default values: the uppercase alphabet list leading by the image type ('C' for 'color'; 'B' for 'Black&White'), "
+        "e.g., ['CA', 'CB', ..., 'CZ'] or ['BA', 'BB', ..., 'BZ'].\n"
+        "Since v1.2.0, supports range of labels, e.g., 'A-Z' or '1-10'.\n"
+        "Refer to https://github.com/ChenglongMa/SkinToneClassifier#3-specify-category-labels for more details.",
+        **kwargs,
+    )
+
+    kwargs = dict(metavar="Convert to Black/White") if in_gui else {}
+    images.add_argument(
+        "-bw",
+        "--black_white",
+        action="store_true",
+        help="Whether to convert the input to black/white image(s)?\n"
+        "If true, the app will convert the input to black/white image(s) and use the black/white palette for classification.",
+        **kwargs,
+    )
+
+    kwargs = (
+        {"gooey_options": {"initial_value": 2, "min": 1, "max": 99999, "full_width": False}, "widget": "IntegerField"}
+        if in_gui
+        else {}
+    )
+    images.add_argument(
+        "--n_colors",
+        metavar="Number of Dominant Colors",
+        type=int,
+        help="Specify the number of dominant colors to be extracted.\n"
+        "The colors will be used to compare with the colors in the palette.\n",
+        default=2,
+        **kwargs,
+    )
+
+    kwargs = (
+        {
+            "gooey_options": {"initial_value": 250, "min": 10, "max": 99999, "full_width": False},
+            "widget": "IntegerField",
+        }
+        if in_gui
+        else {}
+    )
+    images.add_argument(
+        "--new_width",
+        type=int,
+        metavar="New Width (pixels)",
+        help="Resize the images with the specified width.\n"
+        "Sometimes smaller images will be processed faster and more accurately.\n"
+        "No resizing will be performed if the value is negative.",
+        default=250,
+        **kwargs,
+    )
+
+    kwargs = {"gooey_options": {"show_border": True}} if in_gui else {}
+    outputs = parser.add_argument_group("Output Settings", **kwargs)
+
+    kwargs = (
+        {
+            "gooey_options": {"message": "Select the output directory", "default_path": os.getcwd()},
+            "widget": "DirChooser",
+        }
+        if in_gui
+        else {}
+    )
+    outputs.add_argument(
+        "-o",
+        "--output",
+        metavar="Output Directory",
+        default=os.getcwd(),
+        help="Specify the path of output file, defaults to current directory.",
+        **kwargs,
+    )
+
+    kwargs = dict(metavar="Generate Report Images") if in_gui else {}
+    outputs.add_argument(
+        "-d",
+        "--debug",
+        action="store_true",
+        default=in_gui,
+        help="Whether to generate report images?\n"
+        "If true, the report images will be saved in the '<OUTPUT_DIRECTORY>/debug' directory.",
+        **kwargs,
+    )
+
+    kwargs = {"gooey_options": {"show_border": False, "columns": 2}} if in_gui else {}
+    advanced = parser.add_argument_group(
+        "Advanced Settings",
+        "For advanced users only, please refer to https://stackoverflow.com/a/20805153/8860079",
+        **kwargs,
+    )
+
+    kwargs = (
+        {"gooey_options": {"initial_value": 1.1, "min": 0.1, "max": 2.0}, "widget": "DecimalField"} if in_gui else {}
+    )
+    advanced.add_argument(
+        "--scale",
+        type=float,
+        metavar="Scale",
+        help="Specify how much the image size is reduced at each image scale.",
+        default=1.1,
+        **kwargs,
+    )
+
+    kwargs = {"gooey_options": {"initial_value": 5, "min": 1, "max": 99999}, "widget": "IntegerField"} if in_gui else {}
+    advanced.add_argument(
+        "--min_nbrs",
+        type=int,
+        metavar="Minimum Neighbors",
+        help="Specify how many neighbors each candidate rectangle should have to retain it.\n"
+        "Higher value results in less detections but with higher quality.",
+        default=5,
+        **kwargs,
+    )
+    default_min_width = 90
+    default_min_height = 90
+
+    kwargs = {"gooey_options": {"visible": False}} if in_gui else {}
+    advanced.add_argument(
+        "--min_size",
+        type=int,
+        nargs="+",
+        metavar="Minimum Possible Face Size, format: <Width Height>",
+        help=f'Specify the minimum possible face size. Faces smaller than that are ignored, defaults to "{default_min_width} {default_min_height}".',
+        default=(default_min_width, default_min_height),
+        **kwargs,
+    )
+    if in_gui:
+        min_size = advanced.add_argument_group(
+            "Minimum Possible Face Size (pixels)",
+            'Specify the minimum possible face size. Faces smaller than that are ignored, defaults to "90 90".',
+            gooey_options={"show_border": True, "columns": 2},
+        )
+
+        min_size.add_argument(
+            "--min_width",
+            type=int,
+            metavar="Minimum Width",
+            # help="Specify the minimum possible face width. Faces smaller than that are ignored, defaults to 90.",
+            default=default_min_width,
+            widget="IntegerField",
+            gooey_options={"initial_value": default_min_width, "min": 10, "max": 99999},
+        )
+
+        min_size.add_argument(
+            "--min_height",
+            type=int,
+            metavar="Minimum Height",
+            # help="Specify the minimum possible face height. Faces smaller than that are ignored, defaults to 90.",
+            default=default_min_height,
+            widget="IntegerField",
+            gooey_options={"initial_value": default_min_height, "min": 10, "max": 99999},
+        )
+
+    kwargs = (
+        {"gooey_options": {"initial_value": 0.15, "min": 0.01, "max": 1.0}, "widget": "DecimalField"} if in_gui else {}
+    )
+    advanced.add_argument(
+        "--threshold",
+        type=float,
+        metavar="Minimum Possible Face Proportion",
+        help="Specify the minimum proportion of the skin area required to identify the face, defaults to 0.15.",
+        default=0.15,
+        **kwargs,
+    )
+
+    kwargs = {"gooey_options": {"initial_value": 0, "min": 0, "max": 99999}, "widget": "IntegerField"} if in_gui else {}
+    advanced.add_argument(
+        "--n_workers",
+        type=int,
+        metavar="Number of CPU Workers",
+        help="Specify the number of workers to process the images.\n"
+        "0 means the total number of CPU cores in the system.",
+        default=0,
+        **kwargs,
+    )
+
+    kwargs = dict(gooey_options={"visible": False}) if in_gui else {}
+    advanced.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show the version number and exit.",
+        **kwargs,
+    )
+    args = parser.parse_args()
+    images = args.images or []
+    if getattr(args, "image_dirs", False):
+        images.extend(args.image_dirs)
+    if getattr(args, "image_files", False):
+        images.extend(args.image_files)
+    if getattr(args, "image_urls", False):
+        images.extend(args.image_urls)
+    args.images = images
+    if (
+        tuple(args.min_size) == (default_min_width, default_min_height)
+        and getattr(args, "min_width", False)
+        and getattr(args, "min_height", False)
+    ):
+        args.min_size = (args.min_width, args.min_height)
+    return args
+
+
+def resolve_labels(labels):
+    if not labels or len(labels) != 1:
+        return labels
+    label = labels[0]
+
+    separator = r"[-,~:;_]"
+    pattern = rf"^([a-zA-Z0-9]+){separator}([a-zA-Z0-9]+)(?:{separator}([-+]?\d+))?$"
+    match = re.match(pattern, label)
+    if match is None:
+        return labels
+    start, end, step = match.groups()
+    if not step:
+        step = 1
+    else:
+        step = int(step)
+    if step == 0:
+        LOG.warning(f"The specified step in the '--label' setting ('{label}') cannot be 0; resetting to 1.")
+        step = 1
+    if step < 0:
+        start, end = end, start
+
+    if start.isdigit() and end.isalpha() or start.isalpha() and end.isdigit():
+        LOG.warning(
+            f"Invalid '--label' setting ('{label}'): The start value ({start}) and the end value ({end}) should be both digits or both letters."
+        )
+        return labels
+    if start >= end:
+        LOG.warning(
+            f"Invalid '--label' setting ('{label}'): The start value ({start}) should be less than the end value ({end})."
+        )
+        return labels
+    if start.isdigit() and end.isdigit():
+        start, end = int(start), int(end)
+        return [str(i) for i in range(start, end + 1, step)]
+    if start.isalpha() and end.isalpha():
+        start, end = start.upper(), end.upper()
+        return [chr(i) for i in range(ord(start), ord(end) + 1, step)]
+    return labels
+
+
+def get_latest_version_from_pypi(package_name):
+    try:
+        import requests
+
+        response = requests.get(f"https://pypi.org/pypi/{package_name}/json")
+        response.raise_for_status()
+
+        data = response.json()
+        latest_version = data["info"]["version"]
+        return latest_version
+    except Exception:
+        pass
+
+
+def check_version():
+    if "STONE_UPGRADE_FLAG" in os.environ:
+        return
+    try:
+        from packaging.version import parse
+        import importlib.metadata
+
+        latest_version = get_latest_version_from_pypi(__package_name__)
+        if not latest_version:
+            return
+        distribution = importlib.metadata.distribution(__package_name__)
+        installed_version = distribution.version
+        if parse(installed_version) < parse(latest_version):
+            from colorama import just_fix_windows_console, Fore
+
+            just_fix_windows_console()
+            print(
+                Fore.YELLOW + f"You are using an outdated version of {__package_name__} ({installed_version}).\n"
+                f"Please upgrade to the latest version ({latest_version}) with the following command:\n",
+                Fore.GREEN + f"pip install {__package_name__}[all] --upgrade\n" + Fore.RESET,
+            )
+            os.environ["STONE_UPGRADE_FLAG"] = "1"
+    except Exception:
+        pass

test.py

@@ -0,0 +1,50 @@
+import cv2
+from PIL import Image
+from argparse import ArgumentParser
+from pillow_heif import register_heif_opener
+import src
+import os
+from json import dumps  # Optional
+
+register_heif_opener()
+
+
+def process_image(image_path: str):
+    im_basename = os.path.basename(image_path).split(".")[0]
+    result = src.process(image_path, return_report_image=True)
+    report_images = result.pop("report_images")
+
+    # Save the faces
+    # for i, face in enumerate(report_images.keys()):
+    cv2.imwrite(
+        f"outputs/face_{im_basename}.png",
+        cv2.cvtColor(report_images, cv2.COLOR_RGB2BGR),
+    )
+    # report_images.save(f"outputs/face_{im_basename}.png")
+
+    # convert the result to json
+    result_json = dumps(result)
+    # save the json dump
+    with open(f"outputs/faces_{im_basename}.json", "w") as f:
+        f.write(result_json)
+
+    return result
+
+
+if __name__ == "__main__":
+    args = ArgumentParser()
+    args.add_argument(
+        "-i",
+        "--image_path",
+        required=True,
+        help="Path to the image",
+    )
+
+    args = args.parse_args()
+    # import IPython
+
+    # IPython.embed()
+    print("Image path:", args.image_path)
+    # image = cv2.imread(args.image)
+    result = process_image(args.image_path)
+    print(result)