colour-match-sdl 0.1.0__tar.gz

colour_match_sdl-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md
+include requirements.txt
+recursive-include colour_match_web/static *.css *.js
+recursive-include colour_match_web/templates *.html
+recursive-include sdl_sim_web/static *.css *.js
+recursive-include sdl_sim_web/templates *.html

colour_match_sdl-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: colour-match-sdl
+Version: 0.1.0
+Summary: Colour matching and SDL simulation utilities for IvoryOS demos.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ivoryos
+Provides-Extra: full
+Requires-Dist: numpy; extra == "full"
+Requires-Dist: matplotlib; extra == "full"
+Requires-Dist: plotly; extra == "full"
+Requires-Dist: opencv-python==4.10.0.84; extra == "full"
+Requires-Dist: colormath==3.0.0; extra == "full"
+
+# Colour match SDL
+
+
+## Getting started
+...
+
+## Description
+...
+
+## Visuals
+...
+
+## Installation
+First create a new virtual environment then use:
+
+```commandline
+pip install -r requirements.txt
+```
+
+## Usage
+Order to go through the scripts
+
+In the scripts folder
+1. [instruments.py](scripts/instruments.py)
+2. [multiposition_vici_valve.py](scripts/multiposition_vici_valve.py)
+3. [demo_prepare_stock_solution_complete.py](scripts/demo_prepare_stock_solution_complete.py)
+4. [demo_prepare_stock_solution_with_analyze.py](scripts/demo_prepare_stock_solution_with_analyze.py)
+5. [demo_data_visualization_matplotlib.py](scripts/demo_data_visualization_matplotlib.py)
+6. [demo_data_visualization_plotly.py](scripts/demo_data_visualization_plotly.py)
+7. [demo_bayesian_optimization.py](scripts/demo_bayesian_optimization.py)
+8. [demo_bayesian_optimization_matplotlib.py](scripts/demo_bayesian_optimization_matplotlib.py)
+9. [demo_bayesian_optimization_plotly.py](scripts/demo_bayesian_optimization_plotly.py)
+
+In the colour match folder
+1. [bayesian_optimization_colour_match.py](colour_match/bayesian_optimization_colour_match.py)
+
+In the ivoryOS demo basic sdl folder
+1. [ivoryos_basic_sdl/sdl.py](ivoryos_basic_sdl/sdl.py)
+   * Explore the workflow designer then load and run 
+     * [create_stock_solution_and_analyze.json](ivoryos_basic_sdl/create_stock_solution_and_analyze.json)
+
+In the ivoryOS demo basic sdl folder
+1. [ivorysos_colour_match_sdl/sdl.py](ivorysos_colour_match_sdl/sdl.py)
+   * Explore the workflow designer then load and run 
+     * [colour_match_ryb_sunset_orange.json](ivorysos_colour_match_sdl/colour_match_ryb_sunset_orange.json)
+     * [colour_match_ryb_grey_blue.json](ivorysos_colour_match_sdl/colour_match_ryb_grey_blue.json)
+     * [colour_match_rybgp_grey_blue.json](ivorysos_colour_match_sdl/colour_match_rybgp_grey_blue.json)
+
+## Authors and acknowledgment
+...
+
+## License
+...

colour_match_sdl-0.1.0/README.md

@@ -0,0 +1,53 @@
+# Colour match SDL
+
+
+## Getting started
+...
+
+## Description
+...
+
+## Visuals
+...
+
+## Installation
+First create a new virtual environment then use:
+
+```commandline
+pip install -r requirements.txt
+```
+
+## Usage
+Order to go through the scripts
+
+In the scripts folder
+1. [instruments.py](scripts/instruments.py)
+2. [multiposition_vici_valve.py](scripts/multiposition_vici_valve.py)
+3. [demo_prepare_stock_solution_complete.py](scripts/demo_prepare_stock_solution_complete.py)
+4. [demo_prepare_stock_solution_with_analyze.py](scripts/demo_prepare_stock_solution_with_analyze.py)
+5. [demo_data_visualization_matplotlib.py](scripts/demo_data_visualization_matplotlib.py)
+6. [demo_data_visualization_plotly.py](scripts/demo_data_visualization_plotly.py)
+7. [demo_bayesian_optimization.py](scripts/demo_bayesian_optimization.py)
+8. [demo_bayesian_optimization_matplotlib.py](scripts/demo_bayesian_optimization_matplotlib.py)
+9. [demo_bayesian_optimization_plotly.py](scripts/demo_bayesian_optimization_plotly.py)
+
+In the colour match folder
+1. [bayesian_optimization_colour_match.py](colour_match/bayesian_optimization_colour_match.py)
+
+In the ivoryOS demo basic sdl folder
+1. [ivoryos_basic_sdl/sdl.py](ivoryos_basic_sdl/sdl.py)
+   * Explore the workflow designer then load and run 
+     * [create_stock_solution_and_analyze.json](ivoryos_basic_sdl/create_stock_solution_and_analyze.json)
+
+In the ivoryOS demo basic sdl folder
+1. [ivorysos_colour_match_sdl/sdl.py](ivorysos_colour_match_sdl/sdl.py)
+   * Explore the workflow designer then load and run 
+     * [colour_match_ryb_sunset_orange.json](ivorysos_colour_match_sdl/colour_match_ryb_sunset_orange.json)
+     * [colour_match_ryb_grey_blue.json](ivorysos_colour_match_sdl/colour_match_ryb_grey_blue.json)
+     * [colour_match_rybgp_grey_blue.json](ivorysos_colour_match_sdl/colour_match_rybgp_grey_blue.json)
+
+## Authors and acknowledgment
+...
+
+## License
+...

colour_match_sdl-0.1.0/colour_match/bayesian_optimization_colour_match.py

@@ -0,0 +1,113 @@
+"""
+pip install ax-platform==1.1.2
+"""
+
+import time
+
+import cv2
+from ax.service.managed_loop import optimize
+
+from colour_match.colour_utils import (average_rgb_in_roi, cie2000_distance,
+                                       dummy_mix_colours_red_yellow_blue_green_purple_water_to_bgr, colour_swatch_from_bgr,
+                                       plot_lab_distance, plot_lab_distance_live,
+                                       )
+
+# Suppress warnings from ax
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+
+def dummy_colour_match_objective(params):
+    """
+    Objective Function for BO. params is a dict of
+        {
+            "red", "type": "range", "bounds": [0.0, 1.0],
+            "yellow", "type": "range", "bounds": [0.0, 1.0],
+            "blue", "type": "range", "bounds": [0.0, 1.0],
+            "green", "type": "range", "bounds": [0.0, 1.0],
+            "purple", "type": "range", "bounds": [0.0, 1.0],
+        }
+        parameter_constraints=["red + blue + yellow + green + purple <= 1.0"]
+
+    This is good for simulating colour mixing only, not to run on a deck.
+    """
+    trial_time = time.time()
+
+    water = 1 - (params['red'] + params['blue'] + params['yellow'] + params['green'] + params['purple'])
+
+    params['water'] = water
+
+    _bgr_mix = dummy_mix_colours_red_yellow_blue_green_purple_water_to_bgr(**params)
+    img = colour_swatch_from_bgr(bgr=_bgr_mix, width=15, height=15)
+
+    # convert the image from BGR to RBG
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+    # crop ROI and compute average RGB
+    avg_rgb = img.mean(axis=(0, 1))
+    predicted_rgb_colours.append(avg_rgb)  # add to list of rgb colours that have been predicted by the optimizer, for plotting
+
+    # # optional: live plot
+    # plot_lab_distance_live(predicted_rgb_colours, target_rgb=TARGET_RGB)
+
+    # # optional: save rgb image
+    # filename = f"r{params['red']}_b{params['blue']}_y{params['yellow']}_g{params['green']}_p{params['purple']}_w{params['water']}_trial_{trial_time:.0f}.png"
+    # cv2.imwrite(filename, cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
+
+    # compute ΔE00 distance
+    delta_e = cie2000_distance(avg_rgb, TARGET_RGB)
+
+    print(f"Tested {params} -> Avg RGB {avg_rgb} -> ΔE00 = {delta_e:.2f}")
+
+    return delta_e  # minimize this
+
+
+if __name__ == "__main__":
+    # Run Bayesian Optimization with Ax to match a target colour - simulation only
+
+    # todo set target colour to match
+    SUNSET_ORANGE_RGB = (253, 94, 83) # https://www.colorhexa.com/fd5e53
+    PINK_RGB = (255, 183, 206)
+    TEAL_RGB = (0, 128, 128)
+    DARK_PURPLE = (76, 30, 79)
+    FOREST_GREEN = (0, 110, 51)
+    GREY_BLUE = (22, 96, 136)
+    TARGET_RGB = SUNSET_ORANGE_RGB
+    predicted_rgb_colours = []  # to store the rgb colours that have been predicted by the optimizer
+
+    # BO optimization
+    best_params, best_val, experiment, model = optimize(
+        parameters=[
+            {"name": "red", "type": "range", "bounds": [0.0, 1.0]},
+            {"name": "blue", "type": "range", "bounds": [0.0, 1.0]},
+            {"name": "yellow", "type": "range", "bounds": [0.0, 1.0]},
+            {"name": "green", "type": "range", "bounds": [0.0, 1.0]},
+            {"name": "purple", "type": "range", "bounds": [0.0, 1.0]},
+        ],
+        evaluation_function=dummy_colour_match_objective,
+        objective_name="deltaE00",
+        minimize=True,
+        total_trials=20,
+        parameter_constraints=["red + blue + yellow + green + purple <= 1.0"],
+    )
+
+    # Print all evaluated parameter sets and their values
+    print("All evaluated parameter sets and their deltaE00 values (objective: minimize):")
+    for trial in experiment.trials.values():
+        if trial.status.name == "COMPLETED":
+            red = trial.arm.parameters["red"]
+            blue = trial.arm.parameters["blue"]
+            yellow = trial.arm.parameters["yellow"]
+            green = trial.arm.parameters["green"]
+            purple = trial.arm.parameters["purple"]
+            deltaE00 = trial.objective_mean
+            print(f"Iteration: {trial.index + 1}: red: {red}, blue: {blue}, yellow: {yellow}, green: {green}, purple: {purple}, ΔE00: {deltaE00}")
+
+    # Print the best result
+    print()
+    print("Best params:", best_params)
+    print("Best ΔE00 value (want to minimize):", best_val)
+
+    # final plot of after all optimization is done
+    plotly_fig = plot_lab_distance(predicted_rgb_colours, TARGET_RGB, save=True, save_path=f"colour_match_rbygp_bo_lab_plot_{time.time():.0f}.html")
+    plotly_fig.show(renderer="browser")

colour_match_sdl-0.1.0/colour_match/colour_utils.py

@@ -0,0 +1,448 @@
+import json
+import time
+from typing import Dict, Union, List, Tuple
+import cv2
+import platform
+
+
+import numpy as np
+from colormath.color_objects import sRGBColor, LabColor
+from colormath.color_conversions import convert_color
+from colormath.color_diff import delta_e_cie2000
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+
+
+# need to patch if using numpy <= 1.24.0
+def patch_asscalar(a):
+    return a.item()
+setattr(np, "asscalar", patch_asscalar)
+
+
+# ---------------------------
+# ROI Handling
+# ---------------------------
+DEFAULT_ROI_FILE_PATH = "roi.json"
+
+
+
+def select_roi_and_save(image: Union[str, np.ndarray],
+                        roi_file: str = DEFAULT_ROI_FILE_PATH) -> Dict:
+    """
+    Allows ROI selection on an input image.
+
+    image can be:
+        - str: path to an image file
+        - numpy.ndarray: an image already loaded (e.g. via cv2.imread)
+
+    Returns:
+        {
+          "x": int,
+          "y": int,
+          "w": int,
+          "h": int
+        }
+    """
+    # LOAD IMAGE BASED ON INPUT TYPE
+    if isinstance(image, str):
+        img = cv2.imread(image)
+        if img is None:
+            raise ValueError(f"Could not read image from path: {image}")
+    elif isinstance(image, np.ndarray):
+        img = image
+    else:
+        raise TypeError("image_source must be either a file path (str) or an image array (numpy.ndarray).")
+
+    r = cv2.selectROI("Select ROI", img, showCrosshair=True, fromCenter=False)
+    cv2.destroyAllWindows()
+
+    roi_data = {
+        "x": int(r[0]),
+        "y": int(r[1]),
+        "w": int(r[2]),
+        "h": int(r[3])
+    }
+    print(f'save roi.json file to {roi_file}')
+    with open(roi_file, "w") as f:
+        json.dump(roi_data, f)
+
+    return roi_data
+
+
+def load_roi(roi_file: str = DEFAULT_ROI_FILE_PATH) -> Dict:
+    """
+    return
+        {
+          "x": 123,
+          "y": 45,
+          "w": 80,
+          "h": 60
+        }
+    """
+    print(f'load roi from: {roi_file}')
+    with open(roi_file, "r") as f:
+        roi_data = json.load(f)
+    return roi_data
+
+
+def crop_image_using_roi(image, roi_data):
+    x, y, w, h = roi_data["x"], roi_data["y"], roi_data["w"], roi_data["h"]
+    return image[y:y + h, x:x + w]
+
+
+def average_rgb_in_roi(image, roi_data):
+    roi = crop_image_using_roi(image, roi_data)
+    avg_rgb = tuple(np.mean(roi.reshape(-1, 3), axis=0))
+    return avg_rgb
+
+
+# ---------------------------
+# Color Utilities
+# ---------------------------
+def rgb_to_lab(rgb):
+    """Convert 0–255 RGB to Lab array"""
+    rgb_scaled = sRGBColor(*rgb, is_upscaled=True)
+    lab = convert_color(rgb_scaled, LabColor)
+    return np.array([lab.lab_l, lab.lab_a, lab.lab_b])
+
+
+def cie2000_distance(rgb_1, rgb_2):
+    """
+    Compute CIEDE2000 color difference using colormath.
+    Input RGB: 0–255 tuples
+
+    | ΔE₀₀  | Perception                                |
+    | ----- | ----------------------------------------- |
+    | 0–1   | Not perceptible by human eyes             |
+    | 1–2   | Perceptible through close observation     |
+    | 2–10  | Perceptible at a glance, small difference |
+    | 11–49 | Colors are clearly different              |
+    | 100+  | Colors are drastically different          |
+
+    < 2–3: Usually considered a “match” for quality control (e.g., paints, textiles, prints).
+    > 5: Most people will notice the difference immediately.
+    > 10: Colors are obviously different.
+    """
+    c1 = sRGBColor(*rgb_1, is_upscaled=True)
+    c2 = sRGBColor(*rgb_2, is_upscaled=True)
+    lab1 = convert_color(c1, LabColor)
+    lab2 = convert_color(c2, LabColor)
+    return delta_e_cie2000(lab1, lab2)
+
+
+def colour_swatch_from_rbg(rgb, width=30, height=30):
+    """
+    Create solid RGB image
+
+    Args:
+        rgb (tuple/list): (R, G, B) values in 0–255.
+        width (int): width of the image.
+        height (int): height of the image.
+    """
+    swatch_rgb = np.zeros((height, width, 3), dtype=np.uint8)
+    swatch_rgb[:, :] = rgb
+    return swatch_rgb
+
+
+def save_color_swatch_rgb(rgb, width=30, height=30, filename=None):
+    """
+    Save an image filled entirely with an RGB color.
+
+    Args:
+        rgb (tuple/list): (R, G, B) values in 0–255.
+        width (int): width of the image.
+        height (int): height of the image.
+        filename (str): output file path, e.g. "swatch.png".
+    """
+    if filename is None:
+        filename = f"swatch_r{rgb[0]}_g{rgb[1]}b{rgb[2]}_{time.time():.0f}.png"
+
+    swatch_rgb = colour_swatch_from_rbg(rgb=rgb, width=width, height=height)
+    swatch_bgr = cv2.cvtColor(swatch_rgb, cv2.COLOR_RGB2BGR)
+    cv2.imwrite(filename, swatch_bgr)  # need to convert to bgr before saving
+    return swatch_rgb
+
+
+def colour_swatch_from_bgr(bgr, width=30, height=30):
+    """
+   Create solid BGR image
+
+   Args:
+       bgr (tuple/list): (B, G, R) values in 0–255.
+       width (int): width of the image.
+       height (int): height of the image.
+   """
+    swatch_bgr = np.zeros((height, width, 3), dtype=np.uint8)
+    swatch_bgr[:, :] = bgr  # Fill with BGR color
+    return swatch_bgr
+
+
+def save_color_swatch_bgr(bgr, width=30, height=30, filename=None):
+    """
+    Save an image filled with a BGR color and return the BGR array.
+
+    Args:
+        bgr (tuple/list): (B, G, R) values in 0–255.
+        width (int): width of the image.
+        height (int): height of the image.
+        filename (str): optional output file name.
+
+    Returns:
+        np.ndarray: The generated (height, width, 3) BGR image array.
+    """
+    if filename is None:
+        filename = f"swatch_b{bgr[0]}_g{bgr[1]}_r{bgr[2]}_{int(time.time())}.png"
+
+    swatch_bgr = colour_swatch_from_bgr(bgr=bgr, width=width, height=height)
+    cv2.imwrite(filename, swatch_bgr)
+    return swatch_bgr
+
+
+def dummy_mix_colours_red_yellow_blue_water_to_bgr(red, yellow, blue, water):
+    """
+    Mix red, yellow, blue,  water (0–1, sum=1)
+    Return BGR tuple (0–255 each).
+    Uses subtractive absorbance mixing which is good for simulating opaque paints.
+    """
+    # RGB for pigments (non-zero to avoid collapse)
+    red_rgb    = np.array([1.0, 0.1, 0.1])
+    yellow_rgb = np.array([1.0, 1.0, 0.1])
+    blue_rgb   = np.array([0.1, 0.1, 1.0])
+    white_rgb  = np.array([1.0, 1.0, 1.0])
+
+    # Convert to absorbance: A = 1 - RGB
+    A_red    = 1 - red_rgb
+    A_yellow = 1 - yellow_rgb
+    A_blue   = 1 - blue_rgb
+    A_white  = 1 - white_rgb  # = 0
+
+    # Weighted linear mix of absorbance
+    A_mix = (
+        red * A_red +
+        yellow * A_yellow +
+        blue * A_blue +
+        water * A_white
+    )
+
+    # Convert back to RGB: RGB = 1 - absorbance
+    rgb = 1 - A_mix
+
+    # Scale to 0–255 and convert to int
+    rgb_255 = np.clip(rgb * 255, 0, 255).astype(np.uint8)
+
+    # Return in BGR order
+    return tuple(rgb_255[::-1])
+
+
+def dummy_mix_colours_red_yellow_blue_green_purple_water_to_bgr(red, yellow, blue, green, purple, water):
+    """
+    Mix red, yellow, blue, green, purple, and water (0–1 each, sum = 1).
+    Return BGR tuple (0–255 each).
+
+    Uses subtractive absorbance mixing (like opaque paints).
+    """
+    # RGB values of pigments (non-zero to avoid collapse)
+    red_rgb = np.array([1.0, 0.1, 0.1])
+    yellow_rgb = np.array([1.0, 1.0, 0.1])
+    blue_rgb = np.array([0.1, 0.1, 1.0])
+    green_rgb = np.array([0.1, 1.0, 0.1])
+    purple_rgb = np.array([1.0, 0.1, 1.0])
+    white_rgb = np.array([1.0, 1.0, 1.0])  # water/white
+
+    # Convert to absorbance: A = 1 - RGB
+    A_red = 1 - red_rgb
+    A_yellow = 1 - yellow_rgb
+    A_blue = 1 - blue_rgb
+    A_green = 1 - green_rgb
+    A_purple = 1 - purple_rgb
+    A_white = 1 - white_rgb  # = 0
+
+    # Weighted linear mix of absorbance
+    A_mix = (
+            red * A_red +
+            yellow * A_yellow +
+            blue * A_blue +
+            green * A_green +
+            purple * A_purple +
+            water * A_white
+    )
+
+    # Convert back to RGB: RGB = 1 - absorbance
+    rgb = 1 - A_mix
+
+    # Scale to 0–255 and convert to int
+    rgb_255 = np.clip(rgb * 255, 0, 255).astype(np.uint8)
+
+    # Return BGR tuple for OpenCV
+    return tuple(rgb_255[::-1])
+
+
+# ---------------------------
+# Camera Capture
+# ---------------------------
+def capture_camera_image(camera_index: int = 0):
+    """Capture and return a camera image in BGR"""
+    os_name = platform.system()
+    if os_name == "Windows":
+        # DirectShow backend (best for Windows)
+        cap = cv2.VideoCapture(camera_index, cv2.CAP_DSHOW)
+    elif os_name == "Linux":
+        # V4L2 backend (Linux)
+        cap = cv2.VideoCapture(camera_index, cv2.CAP_V4L2)
+    else:  # macOS
+        # AVFoundation (default, best on mac)
+        cap = cv2.VideoCapture(camera_index, cv2.CAP_AVFOUNDATION)
+    time.sleep(0.5)
+    if not cap.isOpened():
+        raise RuntimeError(f"Cannot open camera index {camera_index}")
+    cap.read()
+    ret, frame = cap.read()  # take second photo, first one might have weird autofocus issue
+    cap.release()
+    if not ret:
+        raise RuntimeError("Camera capture failed")
+    return frame
+
+
+# ---------------------------
+# LAB Distance Plot
+# ---------------------------
+def plot_lab_distance_live(rgbs: List[Tuple], target_rgb: Tuple):
+    """
+    Live-update a LAB a*b* plane plot during optimization.
+
+    Parameters
+    ----------
+    rgbs : List[Tuple[int, int, int]]
+        List of measured RGB colors (0–255) accumulated so far.
+    target_rgb : Tuple[int, int, int]
+        RGB color of the target (0–255).
+
+    Notes
+    -----
+    - This function clears the previous frame and redraws all points.
+    - Iteration numbers are displayed next to each measured color.
+    - Use plt.ion() before calling repeatedly in a loop for interactive updates.
+    - Does not save the figure; intended for live visualization only.
+    """
+    plt.clf()  # clear previous frame
+    lab_target = rgb_to_lab(target_rgb)
+
+    # Plot target
+    plt.scatter(lab_target[1], lab_target[2], color=np.array(target_rgb) / 255.0, s=200, label="Target")
+
+    # Plot measured points
+    for i, rgb_meas in enumerate(rgbs):
+        lab_meas = rgb_to_lab(rgb_meas)
+        plt.scatter(lab_meas[1], lab_meas[2], color=np.array(rgb_meas) / 255.0, s=100)
+        plt.plot([lab_meas[1], lab_target[1]], [lab_meas[2], lab_target[2]], 'k--', lw=1)
+        plt.text(lab_meas[1], lab_meas[2], str(i + 1), fontsize=8, ha='center', va='bottom')  # trial number
+
+    plt.xlabel("a*")
+    plt.ylabel("b*")
+    plt.title("Live LAB a*b* Plane")
+    plt.grid(True)
+    plt.axis('equal')
+    plt.pause(0.1)  # short pause to update
+
+
+def plot_lab_distance(rgbs: List[Tuple[int, int, int]], target_rgb: Tuple[int, int, int], save: bool = False, save_path: str = "lab_final.html") -> go.Figure:
+    """
+    Plot LAB a*b* distances of multiple RGB colors against a target color interactively using Plotly.
+
+    Parameters
+    ----------
+    rgbs : List[Tuple[int, int, int]]
+        List of RGB tuples (measured colors) with values in 0–255.
+    target_rgb : Tuple[int, int, int]
+        Target RGB tuple with values in 0–255.
+    save : bool, optional
+        If True, save the plot as an interactive and animated HTML file at save_path (default is False).
+    save_path : str, optional
+        File path for saving the plot HTML (default "lab_distance_plot.html").
+
+    Opens the animation in the browser after creating.
+    """
+    # Convert measured and target to Lab
+    labs_meas = [rgb_to_lab(rgb) for rgb in rgbs]
+    lab_target = rgb_to_lab(target_rgb)
+
+    # Compute axis ranges
+    all_a = [lab[1] for lab in labs_meas] + [lab_target[1]]
+    all_b = [lab[2] for lab in labs_meas] + [lab_target[2]]
+    padding_a = (max(all_a) - min(all_a)) * 0.1 or 1
+    padding_b = (max(all_b) - min(all_b)) * 0.1 or 1
+    x_range = [min(all_a) - padding_a, max(all_a) + padding_a]
+    y_range = [min(all_b) - padding_b, max(all_b) + padding_b]
+
+    frames = []
+    for i in range(len(rgbs)):
+        frame_data = [
+            go.Scatter(
+                x=[lab[1] for lab in labs_meas[:i + 1]],
+                y=[lab[2] for lab in labs_meas[:i + 1]],
+                mode='markers+text',
+                text=[str(j + 1) for j in range(i + 1)],
+                textposition='top center',
+                marker=dict(
+                    size=12,
+                    color=[f"rgb({r},{g},{b})" for r, g, b in rgbs[:i + 1]],
+                    line=dict(width=1, color='black')
+                ),
+                hovertemplate=[
+                    f"Point {j + 1}<br>RGB: {tuple(int(v) for v in rgbs[j])}<br>a*: {labs_meas[j][1]:.2f}<br>b*: {labs_meas[j][2]:.2f}"
+                    for j in range(i + 1)
+                ],
+                name='Measured'
+            ),
+            go.Scatter(
+                x=[lab_target[1]],
+                y=[lab_target[2]],
+                mode='markers+text',
+                text=['Target'],
+                textposition='bottom center',
+                marker=dict(size=18, color=f"rgb({target_rgb[0]},{target_rgb[1]},{target_rgb[2]})"),
+                hovertemplate=f"Target<br>RGB: {target_rgb}<br>a*: {lab_target[1]:.2f}<br>b*: {lab_target[2]:.2f}",
+                name='Target'
+            ),
+        ]
+        frames.append(go.Frame(data=frame_data, name=f'frame{i}'))
+
+    # Start figure at final frame
+    final_frame_data = frames[-1].data
+    fig = go.Figure(data=final_frame_data, frames=frames)
+
+    fig.update_layout(
+        title='LAB a*b* Plane Animation',
+        xaxis_title='a*',
+        yaxis_title='b*',
+        xaxis=dict(range=x_range, scaleanchor='y', scaleratio=1),
+        yaxis=dict(range=y_range, scaleanchor='x', scaleratio=1),
+        legend=dict(x=0.8, y=1.1),
+        updatemenus=[{
+            'type': 'buttons',
+            'buttons': [
+                {'label': 'Play',
+                 'method': 'animate',
+                 'args': [None, {'frame': {'duration': 500, 'redraw': True}, 'fromcurrent': True}]},
+                {'label': 'Pause',
+                 'method': 'animate',
+                 'args': [[None], {'frame': {'duration': 0}, 'mode': 'immediate'}]}
+            ],
+            'showactive': True,
+            'x': 0.1,
+            'y': -0.1,
+            'xanchor': 'right',
+            'yanchor': 'top'
+        }]
+    )
+
+    if save:
+        fig.write_html(save_path)
+        print(f"Saved plot to: {save_path}")
+
+    # fig.show(renderer="browser")
+
+    return fig
+
+
+