fixes to histograms

.vscode/settings.json

@@ -1,3 +1,3 @@
 {
-    "python.analysis.typeCheckingMode": "basic"
+    "python.analysis.typeCheckingMode": "off"
 }

app.py

@@ -5,6 +5,50 @@ from PIL import Image
 
 from src.skin_analyzer import analyze_skin_function
 from src.image import ImageBundle
+import plotly.express as px
+import plotly.graph_objects as go
+
+import matplotlib.pyplot as plt
+import io
+
+
+def resize_image(image, height=512):
+    # Calculate the new width to maintain the aspect ratio
+    aspect_ratio = image.width / image.height
+    new_width = int(height * aspect_ratio)
+    return image.resize((new_width, height), Image.Resampling.LANCZOS)
+
+
+def create_histogram(data, title):
+    fig = px.histogram(data, nbins=30, title=title)
+    fig.update_layout(title=dict(y=0.9))
+    fig.update_xaxes(title_text="Value")
+    fig.update_yaxes(title_text="Frequency")
+    return fig
+
+
+# Function to create pie chart using Plotly
+def create_pie_chart(data, title):
+    fig = px.pie(values=data.values(), names=data.keys(), title=title)
+    fig.update_layout(title=dict(y=0.9))
+    return fig
+
+
+# Function to create bar chart using Plotly
+def create_bar_chart(data, title, top_n=None):
+    sorted_data = dict(sorted(data.items(), key=lambda item: item[1], reverse=True))
+    colors = (
+        ["red" if i < top_n else "blue" for i in range(len(sorted_data))]
+        if top_n and top_n < len(sorted_data)
+        else "blue"
+    )
+    fig = px.bar(x=list(sorted_data.keys()), y=list(sorted_data.values()), title=title)
+    fig.update_traces(marker_color=colors)
+    fig.update_layout(
+        title=dict(y=0.9), xaxis_title=None, yaxis_title="Counts", showlegend=False
+    )
+    fig.update_xaxes(tickangle=45)
+    return fig
 
 
 def process_image(
@@ -57,16 +101,30 @@ def process_image(
         if "filtered_skin_mask" in skin_analysis:
             filtered_skin_mask = skin_analysis["filtered_skin_mask"]
             del skin_analysis["filtered_skin_mask"]
-        elif "l_hist" in skin_analysis:
+        if "l_hist" in skin_analysis:
             l_hist = skin_analysis["l_hist"]
             del skin_analysis["l_hist"]
-        elif "tonality_l_hist" in skin_analysis:
+        if "tonality_l_hist" in skin_analysis:
             tonality_l_hist = skin_analysis["tonality_l_hist"]
             del skin_analysis["tonality_l_hist"]
-        elif "chroma_hist" in skin_analysis:
+        if "chroma_hist" in skin_analysis:
             chroma_hist = skin_analysis["chroma_hist"]
             del skin_analysis["chroma_hist"]
-        analysis_results["skin_analysis"] = skin_analysis
+        # analysis_results["skin_analysis"] = skin_analysis
+        # Create bar charts for analysis results
+        chroma_chart = create_pie_chart(skin_analysis["chroma_counts"], "Chroma Counts")
+        undertone_chart = create_pie_chart(
+            skin_analysis["undertone_counts"], "Undertone Counts"
+        )
+        overtone_chart = create_bar_chart(
+            skin_analysis["overtone_counts"], "Overtone Counts", 1
+        )
+        tonality_chart = create_pie_chart(
+            skin_analysis["tonality_counts"], "Tonality Counts"
+        )
+        season_chart = create_bar_chart(
+            skin_analysis["season_counts"], "Season Counts", 3
+        )
 
         # overlay_images.append(skin_analysis["overlay_image"])
 
@@ -78,17 +136,44 @@ def process_image(
     # 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)
+    # Resize images before returning
+    combined_overlay = resize_image(combined_overlay)
+    # l_hist = resize_image(l_hist)
+    # tonality_l_hist = resize_image(tonality_l_hist)
+    # chroma_hist = resize_image(chroma_hist)
+    # chroma_chart = resize_image(chroma_chart)
+    # undertone_chart = resize_image(undertone_chart)
+    # overtone_chart = resize_image(overtone_chart)
+    # tonality_chart = resize_image(tonality_chart)
+    # season_chart = resize_image(season_chart)
 
-    return combined_overlay, analysis_results, l_hist, tonality_l_hist, chroma_hist
+    return (
+        combined_overlay,
+        l_hist,
+        tonality_l_hist,
+        chroma_hist,
+        # analysis_results,
+        chroma_chart,
+        undertone_chart,
+        overtone_chart,
+        tonality_chart,
+        season_chart,
+    )
 
 
 with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            skin_checkbox = gr.Checkbox(label="Skin Analysis", value=True)
+            submit_button = gr.Button("Submit")
+        with gr.Column():
+            eye_checkbox = gr.Checkbox(label="Eye Analysis", value=False)
+            hair_checkbox = gr.Checkbox(label="Hair Analysis", value=False)
     with gr.Row():
         with gr.Column():
             upload_image = gr.Image(type="numpy", label="Upload an Image")
@@ -96,163 +181,84 @@ with gr.Blocks() as demo:
             l_min_slider = gr.Slider(
                 minimum=0, maximum=100, value=10, label="L(%) Min Skin"
             )
-            l_hist_output = gr.Image(type="pil", label="L Histogram")
-        with gr.Column():
             l_max_slider = gr.Slider(
                 minimum=0, maximum=100, value=90, label="L(%) Max Skin"
             )
+            l_hist_output = gr.Plot(label="L Histogram")
+
+            # processed_image_output = gr.Image(type="pil", label="Processed Image")
+    with gr.Row():
+        with gr.Column():
+            processed_image_output = gr.Image(type="pil", label="Processed Image")
+        with gr.Column():
+            undertone_chart_output = gr.Plot(label="Undertone Counts")
+    with gr.Row():
         with gr.Column():
             tonality_min_slider = gr.Slider(
                 minimum=0, maximum=100, value=50, label="L(%) Min Tonality"
             )
-            tonality_hist_output = gr.Image(type="pil", label="Tonality L Histogram")
-        with gr.Column():
             tonality_max_slider = gr.Slider(
                 minimum=0, maximum=100, value=70, label="L(%) Max Tonality"
             )
+            tonality_hist_output = gr.Plot(label="Tonality L Histogram")
+        with gr.Column():
+            tonality_chart_output = gr.Plot(label="Tonality Counts")
+
+    # with gr.Row():
+    #     submit_button = gr.Button("Submit")
+
+    with gr.Row():
         with gr.Column():
             chroma_slider = gr.Slider(
                 minimum=0, maximum=100, value=50, label="Chroma(%) Threshold"
             )
-            chroma_hist_output = gr.Image(type="pil", label="Chroma Histogram")
+            chroma_hist_output = gr.Plot(label="Chroma Histogram")
+        with gr.Column():
+            chroma_chart_output = gr.Plot(label="Chroma Counts")
+
     with gr.Row():
-        skin_checkbox = gr.Checkbox(label="Skin Analysis", value=True)
-        eye_checkbox = gr.Checkbox(label="Eye Analysis", value=False)
-        hair_checkbox = gr.Checkbox(label="Hair Analysis", value=False)
-    analysis_results_output = gr.JSON(label="Analysis Results")
-    processed_image_output = gr.Image(type="pil", label="Processed Image")
-
-    gr.Interface(
-        fn=process_image,
-        inputs=[
-            upload_image,
-            l_min_slider,
-            l_max_slider,
-            tonality_min_slider,
-            tonality_max_slider,
-            chroma_slider,
-            skin_checkbox,
-            eye_checkbox,
-            hair_checkbox,
-        ],
-        outputs=[
-            processed_image_output,
-            l_hist_output,
-            tonality_hist_output,
-            chroma_hist_output,
-            analysis_results_output,
-        ],
-    )
+        with gr.Column():
+            overtone_chart_output = gr.Plot(label="Overtone Counts")
+        with gr.Column():
+            season_chart_output = gr.Plot(label="Season Counts")
 
-    # Set up change event triggers for the sliders
-    l_min_slider.change(
-        process_image,
-        inputs=[
-            upload_image,
-            l_min_slider,
-            l_max_slider,
-            tonality_min_slider,
-            tonality_max_slider,
-            chroma_slider,
-            skin_checkbox,
-            eye_checkbox,
-            hair_checkbox,
-        ],
-        outputs=[
-            processed_image_output,
-            l_hist_output,
-            tonality_hist_output,
-            chroma_hist_output,
-            analysis_results_output,
-        ],
-    )
+    inputs = [
+        upload_image,
+        l_min_slider,
+        l_max_slider,
+        tonality_min_slider,
+        tonality_max_slider,
+        chroma_slider,
+        skin_checkbox,
+        eye_checkbox,
+        hair_checkbox,
+    ]
+    outputs = [
+        processed_image_output,
+        l_hist_output,
+        tonality_hist_output,
+        chroma_hist_output,
+        chroma_chart_output,
+        undertone_chart_output,
+        overtone_chart_output,
+        tonality_chart_output,
+        season_chart_output,
+    ]
 
-    l_max_slider.change(
-        process_image,
-        inputs=[
-            upload_image,
-            l_min_slider,
-            l_max_slider,
-            tonality_min_slider,
-            tonality_max_slider,
-            chroma_slider,
-            skin_checkbox,
-            eye_checkbox,
-            hair_checkbox,
-        ],
-        outputs=[
-            processed_image_output,
-            l_hist_output,
-            tonality_hist_output,
-            chroma_hist_output,
-            analysis_results_output,
-        ],
-    )
+    # Set up change event triggers for the sliders
+    l_min_slider.change(process_image, inputs=inputs, outputs=outputs)
+    l_max_slider.change(process_image, inputs=inputs, outputs=outputs)
+    tonality_min_slider.change(process_image, inputs=inputs, outputs=outputs)
+    tonality_max_slider.change(process_image, inputs=inputs, outputs=outputs)
+    chroma_slider.change(process_image, inputs=inputs, outputs=outputs)
 
-    tonality_min_slider.change(
-        process_image,
-        inputs=[
-            upload_image,
-            l_min_slider,
-            l_max_slider,
-            tonality_min_slider,
-            tonality_max_slider,
-            chroma_slider,
-            skin_checkbox,
-            eye_checkbox,
-            hair_checkbox,
-        ],
-        outputs=[
-            processed_image_output,
-            l_hist_output,
-            tonality_hist_output,
-            chroma_hist_output,
-            analysis_results_output,
-        ],
-    )
+    # upload_image.change(process_image, inputs=inputs, outputs=outputs)
+    skin_checkbox.change(process_image, inputs=inputs, outputs=outputs)
+    eye_checkbox.change(process_image, inputs=inputs, outputs=outputs)
+    hair_checkbox.change(process_image, inputs=inputs, outputs=outputs)
 
-    tonality_max_slider.change(
-        process_image,
-        inputs=[
-            upload_image,
-            l_min_slider,
-            l_max_slider,
-            tonality_min_slider,
-            tonality_max_slider,
-            chroma_slider,
-            skin_checkbox,
-            eye_checkbox,
-            hair_checkbox,
-        ],
-        outputs=[
-            processed_image_output,
-            l_hist_output,
-            tonality_hist_output,
-            chroma_hist_output,
-            analysis_results_output,
-        ],
-    )
+    # Link the submit button to the analyze_image function
+    submit_button.click(process_image, inputs=inputs, outputs=outputs)
 
-    chroma_slider.change(
-        process_image,
-        inputs=[
-            upload_image,
-            l_min_slider,
-            l_max_slider,
-            tonality_min_slider,
-            tonality_max_slider,
-            chroma_slider,
-            skin_checkbox,
-            eye_checkbox,
-            hair_checkbox,
-        ],
-        outputs=[
-            processed_image_output,
-            l_hist_output,
-            tonality_hist_output,
-            chroma_hist_output,
-            analysis_results_output,
-        ],
-    )
 
 demo.launch()

requirements.txt

@@ -1,4 +1,5 @@
 absl-py==2.1.0
+plotly
 aiofiles==23.2.1
 altair==5.3.0
 annotated-types==0.7.0

src/skin_analyzer.py

@@ -40,26 +40,26 @@ def sample_skin_pixels(image, mask, l_min_percentile=10, l_max_percentile=90):
     mask_indices = np.where(mask > 0)
     filtered_mask[mask_indices[0][mask_l], mask_indices[1][mask_l]] = 255
 
-    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+    fig, ax = plt.subplots()
     # Plot the histogram of L channel in the second subplot
-    ax[0].hist(l_values, bins=100, color="blue", alpha=0.75)
-    ax[0].axvline(l_min, color="red", linestyle="--", label="10th percentile")
-    ax[0].axvline(l_max, color="green", linestyle="--", label="90th percentile")
-    ax[0].set_xlabel("L* Value")
-    ax[0].set_ylabel("Frequency")
-    ax[0].set_title("Histogram of L* Values in Skin Mask")
-    ax[0].legend()
-
-    # Save the plot to a file-like object
-    buf = io.BytesIO()
-    plt.savefig(buf, format="png")
-    plt.close(fig)
-    buf.seek(0)
-    # Convert the buffer to a PIL Image and then to a NumPy array
-    image = Image.open(buf)
-    l_hist = np.array(image)
-
-    return filtered_lab_pixels, filtered_mask, l_hist
+    ax.hist(l_values, bins=100, color="blue", alpha=0.75)
+    ax.axvline(l_min, color="red", linestyle="--", label="10th percentile")
+    ax.axvline(l_max, color="green", linestyle="--", label="90th percentile")
+    ax.set_xlabel("L* Value")
+    ax.set_ylabel("Frequency")
+    ax.set_title("Histogram of L* Values in Skin Mask")
+    ax.legend()
+
+    # # Save the plot to a file-like object
+    # buf = io.BytesIO()
+    # plt.savefig(buf, format="png")
+    # plt.close(fig)
+    # buf.seek(0)
+    # # Convert the buffer to a PIL Image and then to a NumPy array
+    # image = Image.open(buf)
+    # # l_hist = np.array(image)
+
+    return filtered_lab_pixels, filtered_mask, fig
 
 
 def rgb_to_lab_and_save(image, output_dir="workspace"):
@@ -290,41 +290,41 @@ def categorize_tonality(L_values, l_min_tonality, l_max_tonality):
     tonality_counts = {"Light": light_count, "True": true_count, "Deep": deep_count}
     predominant_tonality = max(tonality_counts, key=tonality_counts.get)
 
-    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+    fig, ax = plt.subplots()
 
     # Plot the histogram of filtered L channel in the third subplot
-    ax[0].hist(L_values, bins=100, color="blue", alpha=0.75)
-    ax[0].axvline(
+    ax.hist(L_values, bins=100, color="blue", alpha=0.75)
+    ax.axvline(
         l_abs_min,
         color="purple",
         linestyle="--",
         label="lower percentile",
     )
-    ax[0].axvline(
+    ax.axvline(
         l_abs_max,
         color="orange",
         linestyle="--",
         label="higher percentile",
     )
-    ax[0].set_xlabel("L* Value")
-    ax[0].set_ylabel("Frequency")
-    ax[0].set_title("Histogram of Filtered L* Values in Skin Mask")
-    ax[0].legend()
+    ax.set_xlabel("L* Value")
+    ax.set_ylabel("Frequency")
+    ax.set_title("Histogram of Filtered L* Values in Skin Mask")
+    ax.legend()
 
     # Save the plot to a file-like object
-    buf = io.BytesIO()
-    plt.savefig(buf, format="png")
-    plt.close(fig)
-    buf.seek(0)
-    # Convert the buffer to a PIL Image and then to a NumPy array
-    image = Image.open(buf)
-    tonality_l_hist = np.array(image)
+    # buf = io.BytesIO()
+    # plt.savefig(buf, format="png")
+    # plt.close(fig)
+    # buf.seek(0)
+    # # Convert the buffer to a PIL Image and then to a NumPy array
+    # image = Image.open(buf)
+    # tonality_l_hist = np.array(image)
 
     return (
         tonality_counts,
         predominant_tonality,
         tonality,
-        tonality_l_hist,
+        fig,
     )
 
 
@@ -372,28 +372,28 @@ def categorize_chroma(lab_pixels, chroma_thresh):
 
     predominant_chroma = max(chroma_counts, key=chroma_counts.get)
 
-    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
-    ax[0].hist(distances, bins=100, color="blue", alpha=0.75)
-    ax[0].set_xlabel("Chroma Value")
-    ax[0].set_ylabel("Frequency")
-    ax[0].set_title("Histogram of Chroma Values in Skin Mask")
-    ax[0].axvline(
+    fig, ax = plt.subplots()
+    ax.hist(distances, bins=100, color="blue", alpha=0.75)
+    ax.set_xlabel("Chroma Value")
+    ax.set_ylabel("Frequency")
+    ax.set_title("Histogram of Chroma Values in Skin Mask")
+    ax.axvline(
         chroma_thresh,
         color="red",
         linestyle="--",
         label="Threshold Value",
     )
 
-    # Save the plot to a file-like object
-    buf = io.BytesIO()
-    plt.savefig(buf, format="png")
-    plt.close(fig)
-    buf.seek(0)
-    # Convert the buffer to a PIL Image and then to a NumPy array
-    image = Image.open(buf)
-    chorma_hist = np.array(image)
+    # # Save the plot to a file-like object
+    # buf = io.BytesIO()
+    # plt.savefig(buf, format="png")
+    # plt.close(fig)
+    # buf.seek(0)
+    # # Convert the buffer to a PIL Image and then to a NumPy array
+    # image = Image.open(buf)
+    # # chorma_hist = np.array(image)
 
-    return chroma_counts, predominant_chroma, chroma, chorma_hist
+    return chroma_counts, predominant_chroma, chroma, fig
 
 
 def categorize_undertones(cluster_centers):
@@ -473,7 +473,7 @@ def analyze_skin_function(
     )
 
     # calculate chroma
-    chroma_counts, predominant_chroma, chroma, chorma_hist = categorize_chroma(
+    chroma_counts, predominant_chroma, chroma, chroma_hist = categorize_chroma(
         lab_pixels, chroma_thresh
     )
 
@@ -533,5 +533,5 @@ def analyze_skin_function(
         "season_counts": season_counts,
         "l_hist": l_hist,
         "tonality_l_hist": tonality_l_hist,
-        "chorma_hist": chorma_hist,
+        "chroma_hist": chroma_hist,
     }