color change pt2

utils.py

@@ -39,60 +39,51 @@ TRANSPARENT_BG = dict(
 # Speaker sample helpers
 # ---------------------------------------------------------------------------
 
-def colorsCSS(n, startingHue=None, pool=None):
-    """Creates n visually distinct CSS hex colors for up to ~30 speakers.
+# ---------------------------------------------------------------------------
+# Fixed 24-color palette: 6 hues × 4 saturation/brightness tiers.
+# Hue order: red, yellow, green, cyan, blue, magenta — the 6 perceptually
+# distinct primaries. Cycling through all 6 hues before repeating a tier
+# means no two adjacent speakers ever share a similar hue.
+# Tiers (OpenCV HSV sat, val):
+#   1 — vivid saturated        (255, 200)
+#   2 — medium bright          (180, 230)
+#   3 — deep dark              (255, 140)
+#   4 — pale tint              (100, 240)
+# The palette is interleaved hue-first so index 0=red-vivid, 1=yellow-vivid,
+# 2=green-vivid ... 6=red-medium, 7=yellow-medium, etc.
+# ---------------------------------------------------------------------------
+def _build_palette():
+    # OpenCV HSV hue is 0-179 (half-degrees)
+    hues_deg = [0, 30, 60, 90, 120, 150]   # red, yellow, green, cyan, blue, magenta
+    tiers    = [(255, 200), (180, 230), (255, 140), (100, 240)]
+    palette  = []
+    for sat, val in tiers:
+        for h_deg in hues_deg:
+            h_cv = h_deg  # already 0-179 range
+            hsv = np.uint8([[[h_cv, sat, val]]])
+            bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+            b = f'{bgr[0][0][0].item():02x}'
+            g = f'{bgr[0][0][1].item():02x}'
+            r = f'{bgr[0][0][2].item():02x}'
+            palette.append('#' + b + g + r)
+    return palette   # 24 colors
+
+_PALETTE = _build_palette()
 
-    Strategy: generate a large pre-built palette of 30 colors using the full
-    360-degree hue wheel in two interleaved saturation/brightness tiers.
-    Tier 1 (even indices): high saturation, medium-high brightness — vivid colors.
-    Tier 2 (odd indices):  medium saturation, high brightness — lighter pastels.
-    Interleaving means adjacent speakers in the list always come from different
-    tiers, maximizing perceptual distance even with many speakers.
 
-    The palette is built once at a fixed seed for stability, then a random
-    rotation is applied via startingHue so different sessions get variety
-    while within a session all color pools stay coordinated.
+def colorsCSS(n, startingHue=None, pool=None):
+    """Return n CSS hex colors drawn from the fixed 24-color palette.
+
+    Colors are taken in palette order (red→yellow→green→cyan→blue→magenta,
+    then repeating across brightness tiers) so adjacent speakers always have
+    maximally different hues. Cycles if n > 24.
 
-    pool parameter is accepted but ignored — kept for backwards compatibility.
+    startingHue and pool are accepted for backwards compatibility but ignored —
+    the palette is fixed so colors are always distinct and deterministic.
     """
     if n == 0:
         return []
-
-    PALETTE_SIZE = 30
-    # Build the full palette at a neutral starting point
-    palette = []
-    tiers = [
-        (220, 200),   # tier 1: vivid — HSV saturation=220, value=200
-        (140, 230),   # tier 2: pastel — HSV saturation=140, value=230
-    ]
-    for i in range(PALETTE_SIZE):
-        hue = int(i * 360 / PALETTE_SIZE) % 360
-        # OpenCV HSV: hue is 0-179 (half degrees), so divide by 2
-        h_cv = hue // 2
-        sat, val = tiers[i % 2]
-        hsv = np.uint8([[[h_cv, sat, val]]])
-        bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
-        b = f'{bgr[0][0][0].item():02x}'
-        g = f'{bgr[0][0][1].item():02x}'
-        r = f'{bgr[0][0][2].item():02x}'
-        palette.append('#' + b + g + r)
-
-    # Apply rotation from startingHue so sessions get color variety
-    offset = 0
-    if startingHue is not None:
-        offset = int(startingHue / 180 * PALETTE_SIZE) % PALETTE_SIZE
-
-    # Pick n colors evenly spaced from the rotated palette
-    result = []
-    for i in range(min(n, PALETTE_SIZE)):
-        idx = (offset + int(i * PALETTE_SIZE / min(n, PALETTE_SIZE))) % PALETTE_SIZE
-        result.append(palette[idx])
-
-    # If n > PALETTE_SIZE (very unlikely), cycle
-    while len(result) < n:
-        result.extend(palette[:n - len(result)])
-
-    return result
+    return [_PALETTE[i % len(_PALETTE)] for i in range(n)]
 
 
 def extract_clip_bytes(waveform, sample_rate, seg_start, seg_end):
@@ -345,6 +336,17 @@ def build_fig_sunburst(df5, catTypeColors, speakerColors, get_display_name_fn, c
     df5 = df5.copy()
     df5["labels"]      = df5["labels"].apply(lambda s: get_display_name_fn(s, currFile))
     df5["parentNames"] = df5["parentNames"].apply(lambda s: get_display_name_fn(s, currFile))
+
+    # Build an explicit label->color map so every node gets a guaranteed color
+    # regardless of encounter order. color_discrete_sequence is position-based
+    # and can silently drop nodes when label count exceeds sequence length.
+    top_labels = ["No Voice", "Single Voice", "Multi Voice"]
+    speaker_labels = [l for l in df5["labels"] if l not in top_labels]
+    color_map = {lbl: catTypeColors[i % len(catTypeColors)]
+                 for i, lbl in enumerate(top_labels)}
+    for i, lbl in enumerate(speaker_labels):
+        color_map[lbl] = speakerColors[i % len(speakerColors)]
+
     fig = px.sunburst(
         df5,
         branchvalues="total",
@@ -353,7 +355,7 @@ def build_fig_sunburst(df5, catTypeColors, speakerColors, get_display_name_fn, c
         custom_data=["labels", "valueStrings", "percentiles", "parentNames", "parentPercentiles"],
         color="labels",
         title="Percentage of each Voice Category with Speakers",
-        color_discrete_sequence=catTypeColors + speakerColors,
+        color_discrete_map=color_map,
     )
     fig.update_traces(hovertemplate="<br>".join([
         "<b>%{customdata[0]}</b>",
@@ -371,6 +373,16 @@ def build_fig_treemap(df5, catTypeColors, speakerColors, get_display_name_fn, cu
     df5 = df5.copy()
     df5["labels"]      = df5["labels"].apply(lambda s: get_display_name_fn(s, currFile))
     df5["parentNames"] = df5["parentNames"].apply(lambda s: get_display_name_fn(s, currFile))
+
+    # Same explicit color map as sunburst — avoids silent node drops from
+    # position-based color_discrete_sequence running out of colors.
+    top_labels = ["No Voice", "Single Voice", "Multi Voice"]
+    speaker_labels = [l for l in df5["labels"] if l not in top_labels]
+    color_map = {lbl: catTypeColors[i % len(catTypeColors)]
+                 for i, lbl in enumerate(top_labels)}
+    for i, lbl in enumerate(speaker_labels):
+        color_map[lbl] = speakerColors[i % len(speakerColors)]
+
     fig = px.treemap(
         df5,
         branchvalues="total",
@@ -379,7 +391,7 @@ def build_fig_treemap(df5, catTypeColors, speakerColors, get_display_name_fn, cu
         custom_data=["labels", "valueStrings", "percentiles", "parentNames", "parentPercentiles"],
         color="labels",
         title="Division of Speakers in each Voice Category",
-        color_discrete_sequence=catTypeColors + speakerColors,
+        color_discrete_map=color_map,
     )
     fig.update_traces(hovertemplate="<br>".join([
         "<b>%{customdata[0]}</b>",