update multifile analysis with plot normalization

utils.py

@@ -461,10 +461,10 @@ def build_multifile_category_df(validNames, results, summaries, categories, cate
             ] if i < len(categorySelect) else []
             valid_sps = [sp for sp in assigned_sps if sp in currAnnotation.labels()]
             if valid_sps:
-                val = su.sumTimes(currAnnotation.subset(valid_sps)) / safe_total * 100
+                val = su.sumTimes(currAnnotation.subset(valid_sps)) / safe_total
             else:
                 val = 0.0
-            df6_dict[category].append(min(val, 100.0))
+            df6_dict[category].append(min(val, 1.0))
             filled.add(category)
 
         # For unassigned speakers: each gets their own column
@@ -477,8 +477,8 @@ def build_multifile_category_df(validNames, results, summaries, categories, cate
         unassigned = [sp for sp in currAnnotation.labels() if sp not in assigned_all]
         for sp in unassigned:
             display = renames.get(sp, sp)
-            val = su.sumTimes(currAnnotation.subset([sp])) / safe_total * 100
-            df6_dict[display].append(min(val, 100.0))
+            val = su.sumTimes(currAnnotation.subset([sp])) / safe_total
+            df6_dict[display].append(min(val, 1.0))
             filled.add(display)
 
         # Fill 0 for every allCategories column not touched this row
@@ -486,21 +486,26 @@ def build_multifile_category_df(validNames, results, summaries, categories, cate
             if category not in filled:
                 df6_dict[category].append(0)
 
-    return pd.DataFrame(df6_dict), allCategories
+    # Normalize each file's row so values sum to 100
+    df6 = pd.DataFrame(df6_dict)
+    value_cols = [c for c in df6.columns if c != "files"]
+    row_sums = df6[value_cols].sum(axis=1).replace(0, 1)
+    df6[value_cols] = df6[value_cols].div(row_sums, axis=0) * 100
+    return df6, allCategories
 
 
 def build_multifile_role_voice_df(validNames, results, summaries, categories,
                                   categorySelect, speakerRenames=None):
-    """Build df8: per-file percentages split by role plus Multi Voice and No Voice.
+    """Build df8: per-file proportions split by role for single voice, plus
+    Multi Voice and No Voice.
 
-    All values are on a 0-100 scale (% of file duration).
+    Single Voice time is broken down into each role and an Unassigned bucket
+    (speakers in single-voice segments that haven't been assigned to any role).
+    Multi Voice and No Voice come from df5 percentiles (0-100 scale) converted
+    to 0-1 proportions.
 
-    Multi Voice and No Voice are computed directly from the raw annotation using
-    pyannote timeline intersection — this avoids the index-step scale mismatch
-    from annotationToNoiseList/df5 percentiles.
-
-    Role columns use sumTimes on the union of role speaker segments (overlaps
-    within a role counted once).
+    This is the combination of df6 (role proportions) and df7 (voice categories)
+    where Single Voice is replaced by its constituent roles.
     """
     speakerRenames = speakerRenames or {}
     col_names = list(categories) + ["Unassigned", "Multi Voice", "No Voice"]
@@ -510,45 +515,11 @@ def build_multifile_role_voice_df(validNames, results, summaries, categories,
 
     for fn in validNames:
         currAnnotation, totalSeconds = results[fn]
-        # Use annotation's actual span as denominator to avoid truncation issues
-        annotation_end = max(
-            (s.end for s in currAnnotation.itersegments()),
-            default=totalSeconds
-        )
-        safe_total = max(annotation_end, totalSeconds, 1)
-        prefix = fn + ": "
-        renames = speakerRenames.get(fn, {})
+        safe_total = max(totalSeconds, 1)
+        prefix     = fn + ": "
+        renames    = speakerRenames.get(fn, {})
 
-        # Compute Multi Voice directly: time where 2+ speakers overlap
-        # by intersecting all pairs of speaker timelines
-        labels = [l for l in currAnnotation.labels()]
-        multi_voice_tl = currAnnotation.get_timeline(copy=False)
-        # Build per-speaker timelines and find overlapping regions
-        speaker_timelines = [
-            currAnnotation.subset([sp]).get_timeline(copy=False)
-            for sp in labels
-        ]
-        # Multi Voice = union of all pairwise intersections
-        from pyannote.core import Timeline
-        multi_segments = []
-        for i in range(len(speaker_timelines)):
-            for j in range(i + 1, len(speaker_timelines)):
-                for seg_i in speaker_timelines[i]:
-                    for seg_j in speaker_timelines[j]:
-                        overlap = seg_i & seg_j
-                        if overlap:
-                            multi_segments.append(overlap)
-        multi_tl = Timeline(segments=multi_segments).support()
-        multi_voice_pct = multi_tl.duration() / safe_total * 100
-
-        # No Voice = total duration minus any-speaker coverage
-        any_voice_duration = currAnnotation.get_timeline(copy=False).support().duration()
-        no_voice_pct = max((safe_total - any_voice_duration) / safe_total * 100, 0.0)
-
-        df8_dict["Multi Voice"].append(min(multi_voice_pct, 100.0))
-        df8_dict["No Voice"].append(min(no_voice_pct, 100.0))
-
-        # Role proportions — sumTimes on union of role speakers (0-100 scale)
+        # Role proportions — same logic as build_multifile_category_df
         assigned_all = set()
         for i, category in enumerate(categories):
             assigned_sps = [
@@ -559,73 +530,46 @@ def build_multifile_role_voice_df(validNames, results, summaries, categories,
             valid_sps = [sp for sp in assigned_sps if sp in currAnnotation.labels()]
             assigned_all.update(valid_sps)
             if valid_sps:
-                val = su.sumTimes(currAnnotation.subset(valid_sps)) / safe_total * 100
+                val = su.sumTimes(currAnnotation.subset(valid_sps)) / safe_total
             else:
                 val = 0.0
-            df8_dict[category].append(min(val, 100.0))
+            df8_dict[category].append(min(val, 1.0))
 
         # Unassigned speakers
         unassigned_sps = [sp for sp in currAnnotation.labels() if sp not in assigned_all]
         if unassigned_sps:
-            val = su.sumTimes(currAnnotation.subset(unassigned_sps)) / safe_total * 100
+            val = su.sumTimes(currAnnotation.subset(unassigned_sps)) / safe_total
         else:
             val = 0.0
-        df8_dict["Unassigned"].append(min(val, 100.0))
+        df8_dict["Unassigned"].append(min(val, 1.0))
 
-    return pd.DataFrame(df8_dict), col_names
+        # Multi Voice and No Voice from df5 percentiles (0-100 → 0-1)
+        partial = summaries[fn]["df5"]
+        df8_dict["No Voice"].append(partial["percentiles"][0] / 100)
+        df8_dict["Multi Voice"].append(partial["percentiles"][2] / 100)
 
+    # Normalize each file's row so values sum to 100
+    df8 = pd.DataFrame(df8_dict)
+    row_sums = df8[col_names].sum(axis=1).replace(0, 1)
+    df8[col_names] = df8[col_names].div(row_sums, axis=0) * 100
+    return df8, col_names
 
-def build_multifile_voice_df(validNames, results):
-    """Build df7 (no/single/multi voice percentages per file) for the multi-file expander.
 
-    All values are on a 0-100 scale (% of file duration).
-
-    Computed directly from the raw annotation using pyannote timeline methods
-    to avoid the index-step scale mismatch in annotationToNoiseList/df5:
-      - Multi Voice: union of all pairwise speaker timeline intersections
-      - Any Voice:   support of the full annotation timeline
-      - No Voice:    file duration minus Any Voice
-      - Single Voice: Any Voice minus Multi Voice
+def build_multifile_voice_df(validNames, summaries):
+    """Build df7 (no/one/multi voice percentages per file) for the multi-file expander.
+    Values are normalized to sum to 100 per file.
     """
-    from pyannote.core import Timeline
     voiceNames = ["No Voice", "Single Voice", "Multi Voice"]
     df7_dict   = {"files": validNames}
     for name in voiceNames:
         df7_dict[name] = []
 
     for fn in validNames:
-        currAnnotation, totalSeconds = results[fn]
-        annotation_end = max(
-            (s.end for s in currAnnotation.itersegments()),
-            default=totalSeconds
-        )
-        safe_total = max(annotation_end, totalSeconds, 1)
-
-        labels = list(currAnnotation.labels())
-        speaker_timelines = [
-            currAnnotation.subset([sp]).get_timeline(copy=False)
-            for sp in labels
-        ]
-
-        # Multi Voice = union of all pairwise overlaps
-        multi_segments = []
-        for i in range(len(speaker_timelines)):
-            for j in range(i + 1, len(speaker_timelines)):
-                for seg_i in speaker_timelines[i]:
-                    for seg_j in speaker_timelines[j]:
-                        overlap = seg_i & seg_j
-                        if overlap:
-                            multi_segments.append(overlap)
-        multi_tl = Timeline(segments=multi_segments).support()
-        multi_pct = multi_tl.duration() / safe_total * 100
-
-        # Any Voice = support of full annotation
-        any_voice = currAnnotation.get_timeline(copy=False).support().duration()
-        no_voice_pct  = max((safe_total - any_voice) / safe_total * 100, 0.0)
-        single_pct    = max(any_voice / safe_total * 100 - multi_pct, 0.0)
-
-        df7_dict["No Voice"].append(min(no_voice_pct, 100.0))
-        df7_dict["Single Voice"].append(min(single_pct, 100.0))
-        df7_dict["Multi Voice"].append(min(multi_pct, 100.0))
-
-    return pd.DataFrame(df7_dict), voiceNames
+        partial = summaries[fn]["df5"]
+        for i, name in enumerate(voiceNames):
+            df7_dict[name].append(partial["percentiles"][i])
+
+    df7 = pd.DataFrame(df7_dict)
+    row_sums = df7[voiceNames].sum(axis=1).replace(0, 1)
+    df7[voiceNames] = df7[voiceNames].div(row_sums, axis=0) * 100
+    return df7, voiceNames