Update app.py

app.py

@@ -73,6 +73,7 @@ df_builder_pivot_str = ""
 
 
 
+
 def plot_model_results(results_df, average_value, title, model_type):
     """
     Plot model results with specific orders and colors for Trust and NPS models.
@@ -140,8 +141,8 @@ def plot_model_results(results_df, average_value, title, model_type):
 
         # Calculate the x-axis limits
         half_range = max(average_value - actual_min, actual_max - average_value)
-        x_min = average_value - half_range - 3  # Adding some padding for text
-        x_max = average_value + half_range + 3  # Adding some padding for text
+        x_min = 0  # start from zero
+        x_max = actual_max + 5  # a bit beyond max
         plt.xlim(x_min, x_max)
 
         # Set the x-axis ticks at every 5% interval and add dotted lines
@@ -154,37 +155,26 @@ def plot_model_results(results_df, average_value, title, model_type):
                 x=tick, color="grey", linestyle="--", linewidth=0.5, zorder=2
             )  # Add dotted lines
 
-        # Create bars in the bar chart
+        # Create bars: all from 0 → value (left-to-right only)
         for i, row in enumerate(results_df.itertuples(index=False)):
             color = color_map[row.Predictor]
-            if row.Importance_percent < average_value:
-                # For values less than the average, the bar starts at the value and extends to the average
-                bar_length = average_value - row.Importance_percent
-                left_edge = row.Importance_percent
-                text_x = left_edge - 0.5  # Text to the left of the bar
-                ha = "right"
-            else:
-                # For values greater than the average, the bar starts at the average and extends to the value
-                bar_length = row.Importance_percent - average_value
-                left_edge = average_value
-                text_x = row.Importance_percent + 0.5  # Text to the right of the bar
-                ha = "left"
 
             ax.barh(
                 row.Predictor,
-                bar_length,
-                left=left_edge,
+                row.Importance_percent,
+                left=0,
                 color=color,
                 edgecolor="white",
                 height=0.6,
-                zorder=3,  # Set zorder to a value higher than the default for lines
+                zorder=3,
             )
+
             ax.text(
-                text_x,
+                row.Importance_percent + 0.5,
                 i,
                 f"{row.Importance_percent:.1f}%",
                 va="center",
-                ha=ha,
+                ha="left",
                 color="#8c8b8c",
             )
 
@@ -212,12 +202,11 @@ def plot_model_results(results_df, average_value, title, model_type):
         plt.close(fig)
 
         return img
+
     except Exception as e:
         logger.error("Error plotting model results: %s", e)
         raise
 
-
-
 def plot_bucket_fullness(driver_df, title):
     # Determine required trust buckets
     buckets = [
@@ -377,84 +366,113 @@ def call_r_script(
 
 
 
-def plot_trust_driver_bubbles(trust_df, title):
+
+
+
+
+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 size of 10%) 
+    and slightly touch the Trust Core without overlapping.
     Args:
         trust_df (DataFrame): DataFrame containing Trust driver data with an "Importance_percent" column.
         title (str): Title of the plot.
-    
+        trust_core_image_path (str): Path to the image to be placed inside the Trust Core circle.
+        bubble_positions (dict, optional): Dictionary specifying manual positions for each trust driver.
+        gap (float): Small gap adjustment to fine-tune bubble placement.
     Returns:
         Image: PIL Image of the bubble plot.
     """
-    # 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 '{trust_core_img}' not found!")
 
-    # Define the fixed bubble order (for Trust Drivers)
+    # Define the Trust Drivers
     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 importance percentages (default to 0 if missing)
     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))
-        for p in percentages
-    ]
+    # Scale bubble sizes proportionally (e.g., 20% should be twice the size of 10%)
+    min_radius = 0.15  # Set minimum bubble size to 0.18
+    base_percentage = min(percentages) if min(percentages) > 0 else 1  # Prevent division by zero
+    #bubble_radii = [min_radius * (p / base_percentage) ** 0.5 for p in percentages]  # Area-based scaling
+    import math
+    
+    bubble_radii = [
+    min_radius * (p / base_percentage) ** 0.75  # 0.7–0.8 range is ideal
+    for p in percentages]
+
+    # Central circle radius (Trust Core)
+    central_radius = 0.8
+
+    #Default positions ensuring bubbles slightly touch the Trust Core
+    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)
+    }
+   
+    # Use user-defined positions if provided, else default positions
+    bubble_positions = bubble_positions if bubble_positions else default_positions
+
+    # Adjust positions dynamically based on bubble sizes to ensure touching Trust Core
+    # for i, trust_driver in enumerate(bubble_order):
+    #     x, y = bubble_positions[trust_driver]
+    #     bubble_radius = bubble_radii[i]
+    #     scale_factor = (central_radius + bubble_radius + gap) / np.sqrt(x**2 + y**2)
+    #     bubble_positions[trust_driver] = (x * scale_factor, y * scale_factor)
+    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)
+
 
     # Create the figure and axis
-    fig, ax = plt.subplots(figsize=(8, 8))
+    fig, ax = plt.subplots(figsize=(10, 10), dpi=300)  # Increased resolution
     ax.set_xlim(-2, 2)
     ax.set_ylim(-2, 2)
-    ax.set_aspect('equal')  # Lock the aspect ratio
+    ax.set_aspect('equal')  # Lock aspect ratio
     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 inside the central circle
+    extent = [-central_radius, central_radius, -central_radius, central_radius]  # Trust Core image size
+    ax.imshow(trust_core_img, extent=extent, alpha=1.0)
 
-    # 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 bubbles ensuring they only touch but do not overlap
+    for i, trust_driver in enumerate(bubble_order):
+        x, y = bubble_positions[trust_driver]
+        radius = bubble_radii[i]
+        circle = patches.Circle((x, y), radius, facecolor=colors[i], alpha=1.0, lw=1.5)
         ax.add_patch(circle)
         ax.text(
-            x, y, f"{percentages[i]:.1f}%", fontsize=12, fontweight="bold",
+            x, y, f"{percentages[i]:.1f}%", fontsize=10, fontweight="bold",
             ha="center", va="center", color="white"
         )
 
-    # Optionally, add a title (if desired)
-    plt.title(title, fontsize=14)
+    # Add title
+    plt.title(title, fontsize=12)
 
     # Save the plot to a bytes buffer and return a PIL 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)