update color function

utils.py

@@ -40,34 +40,59 @@ TRANSPARENT_BG = dict(
 # ---------------------------------------------------------------------------
 
 def colorsCSS(n, startingHue=None, pool=None):
-    """Creates n distinctive CSS hex colors evenly spaced across the hue wheel.
+    """Creates n visually distinct CSS hex colors for up to ~30 speakers.
 
-    Drop-in replacement for su.colorsCSS that accepts an optional startingHue
-    so related color pools (catTypeColors, speakerColors, catColors) can share
-    the same starting point and stay visually consistent across rerenders.
+    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.
 
-    pool: if set, generate this many evenly-spaced colors first, then pick n
-    from them. This constrains the color space so colors are never too similar
-    even when n is small. Recommended value: 24.
+    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.
+
+    pool parameter is accepted but ignored — kept for backwards compatibility.
     """
     if n == 0:
         return []
-    h = startingHue if startingHue is not None else int(random.random() * 180)
-    num = pool if (pool and pool >= n) else n
-    step = 180 / num
-    all_colors = []
-    for _ in range(num):
-        h += step
-        h = int(h) % 180
-        hsv = np.uint8([[[h, 200, 200]]])
+
+    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}'
-        all_colors.append('#' + b + g + r)
-    # Pick n evenly-spaced colors from the pool
-    indices = [int(i * num / n) for i in range(n)]
-    return [all_colors[i] for i in indices]
+        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
 
 
 def extract_clip_bytes(waveform, sample_rate, seg_start, seg_end):