Update app.py

app.py

@@ -377,86 +377,112 @@ def call_r_script(
 
 
 
-def plot_trust_driver_bubbles(trust_df, title):
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from PIL import Image
+import numpy as np
+import pandas as pd
+import io
+import math
+import os
+
+def plot_trust_driver_bubbles(trust_df, title, bubble_positions=None, gap=-0.2):
     """
-    Creates a bubble plot for Trust Drivers using preset positions and colors.
-    
+    Creates a bubble plot for Trust Drivers ensuring that all bubbles are proportionate in size (e.g., 20% is twice the area of 10%)
+    and slightly touch the Trust Core without overlapping.
+
     Args:
-        trust_df (DataFrame): DataFrame containing Trust driver data with an "Importance_percent" column.
+        trust_df (DataFrame): DataFrame with columns "Predictor" and "Importance_percent".
         title (str): Title of the plot.
-    
+        bubble_positions (dict, optional): Custom (x, y) positions for each trust driver.
+        gap (float): Fine-tuning for spacing around Trust Core.
+
     Returns:
-        Image: PIL Image of the bubble plot.
+        PIL.Image: Final image with plotted bubbles and Trust Core.
     """
-    # Set the background image path
+    # Load Trust Core image
     image_path = "./images/image.png"
-
-    # Load background image
     try:
-        img = Image.open(image_path)
+        trust_core_img = Image.open(image_path)
     except FileNotFoundError:
-        raise FileNotFoundError(f"❌ Error: Background image '{image_path}' not found!")
+        raise FileNotFoundError(f"❌ Error: Trust Core image '{image_path}' not found!")
 
-    # Define the fixed bubble order (for Trust Drivers)
+    # Define bubble order and colors
     bubble_order = ["Vision", "Development", "Benefit", "Competence", "Stability", "Relationship"]
-
-    # Colors for each bubble (in the same order)
     colors = ["#DF8859", "#E3B05B", "#418387", "#6D93AB", "#375570", "#C63F48"]
 
-    # Bubble positions (aligned with the background image)
-    bubble_positions = [
-        (0.66, 1.20),   # Vision Trust (Moved Up)
-        (1.43, -0.08),  # Development Trust (Kept Similar)
-        (0.66, -1.10),   # Benefit Trust (Kept Similar)
-        (-0.70, -1.20), # Competence Trust (Kept Similar)
-        (-1.30, -0.08), # Stability Trust (Kept Similar)
-        (-0.70, 1.15)  # Relationship Trust (Shifted Left)
-    ]
-
-    # Extract importance percentages for each predictor.
-    # If a predictor is missing, default to 0.
+    # Extract percentages
     values_dict = trust_df.set_index("Predictor")["Importance_percent"].to_dict()
     percentages = [values_dict.get(pred, 0) for pred in bubble_order]
 
-    # Scale bubble sizes dynamically based on the percentages
-    max_size = 0.30  # Maximum bubble size
-    min_size = 0.23  # Minimum bubble size
-    min_value, max_value = min(percentages), max(percentages)
-    bubble_sizes = [
-        min_size + (max_size - min_size) * ((p - min_value) / (max_value - min_value + 1e-5))
+    # Base for scaling (min value gets min_radius)
+    base_percentage = min(percentages) if min(percentages) > 0 else 1
+    min_radius = 0.18  # radius for the smallest bubble
+
+    # 🔧 Area-proportional radius calculation
+    bubble_radii = [
+        min_radius * math.sqrt(p / base_percentage)
         for p in percentages
     ]
 
-    # Create the figure and axis
-    fig, ax = plt.subplots(figsize=(8, 8))
+    # Central core radius (for image and collision checking)
+    central_radius = 0.8
+
+    # Default layout positions (can be overridden)
+    default_positions = {
+        "Vision": (0.6, 0.85),
+        "Development": (1.05, 0.0),
+        "Benefit": (0.6, -0.85),
+        "Competence": (-0.6, -0.85),
+        "Stability": (-1.05, 0.0),
+        "Relationship": (-0.6, 0.85)
+    }
+    bubble_positions = bubble_positions if bubble_positions else default_positions.copy()
+
+    # Adjust positions to ensure bubbles touch the Trust Core
+    for i, trust_driver in enumerate(bubble_order):
+        x, y = bubble_positions[trust_driver]
+        bubble_radius = bubble_radii[i]
+        distance_to_core = np.sqrt(x**2 + y**2)
+        scale_factor = (central_radius + bubble_radius + gap) / distance_to_core
+        bubble_positions[trust_driver] = (x * scale_factor, y * scale_factor)
+
+    # Plot setup
+    fig, ax = plt.subplots(figsize=(10, 10), dpi=300)
     ax.set_xlim(-2, 2)
     ax.set_ylim(-2, 2)
-    ax.set_aspect('equal')  # Lock the aspect ratio
+    ax.set_aspect('equal')
     ax.axis("off")
 
-    # Display the background image (ensure the extent aligns with your coordinate system)
-    ax.imshow(img, extent=[-1.5, 1.5, -1.5, 1.5])
+    # Draw Trust Core image
+    extent = [-central_radius, central_radius, -central_radius, central_radius]
+    ax.imshow(trust_core_img, extent=extent, alpha=1.0)
+
+    # Draw bubbles and text
+    for i, trust_driver in enumerate(bubble_order):
+        x, y = bubble_positions[trust_driver]
+        radius = bubble_radii[i]
 
-    # Draw bubbles and add centered percentage text
-    for i, (x, y) in enumerate(bubble_positions):
-        size = bubble_sizes[i]
-        circle = patches.Circle((x, y), size, facecolor=colors[i], alpha=1.0, lw=1.5)
+        # Draw bubble
+        circle = patches.Circle((x, y), radius, facecolor=colors[i], edgecolor='white', lw=1.5)
         ax.add_patch(circle)
+
+        # Text inside bubble
         ax.text(
-            x, y, f"{percentages[i]:.1f}%", fontsize=12, fontweight="bold",
-            ha="center", va="center", color="white"
+            x, y, f"{trust_driver.upper()}\n{percentages[i]:.1f}%",
+            fontsize=8.5, fontweight="bold", ha="center", va="center", color="white"
         )
 
-    # Optionally, add a title (if desired)
-    plt.title(title, fontsize=14)
+    # Title
+    plt.title(title, fontsize=12)
 
-    # Save the plot to a bytes buffer and return a PIL Image
+    # Export to image
     img_buffer = io.BytesIO()
     plt.savefig(img_buffer, format="png", bbox_inches="tight", facecolor=fig.get_facecolor())
     img_buffer.seek(0)
     plt.close(fig)
-    return Image.open(img_buffer)
 
+    return Image.open(img_buffer)
 
     
 def analyze_excel_single(file_path):