Update multi-file visualization

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
+                val = su.sumTimes(currAnnotation.subset(valid_sps)) / safe_total * 100
             else:
                 val = 0.0
-            df6_dict[category].append(min(val, 1.0))
+            df6_dict[category].append(min(val, 100.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
-            df6_dict[display].append(min(val, 1.0))
+            val = su.sumTimes(currAnnotation.subset([sp])) / safe_total * 100
+            df6_dict[display].append(min(val, 100.0))
             filled.add(display)
 
         # Fill 0 for every allCategories column not touched this row
@@ -491,16 +491,16 @@ def build_multifile_category_df(validNames, results, summaries, categories, cate
 
 def build_multifile_role_voice_df(validNames, results, summaries, categories,
                                   categorySelect, speakerRenames=None):
-    """Build df8: per-file proportions split by role for single voice, plus
-    Multi Voice and No Voice.
+    """Build df8: per-file percentages split by role plus Multi Voice and No Voice.
 
-    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.
+    All values are on a 0-100 scale (% of file duration).
 
-    This is the combination of df6 (role proportions) and df7 (voice categories)
-    where Single Voice is replaced by its constituent roles.
+    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).
     """
     speakerRenames = speakerRenames or {}
     col_names = list(categories) + ["Unassigned", "Multi Voice", "No Voice"]
@@ -510,11 +510,45 @@ def build_multifile_role_voice_df(validNames, results, summaries, categories,
 
     for fn in validNames:
         currAnnotation, totalSeconds = results[fn]
-        safe_total = max(totalSeconds, 1)
-        prefix     = fn + ": "
-        renames    = speakerRenames.get(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, {})
 
-        # Role proportions — same logic as build_multifile_category_df
+        # 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)
         assigned_all = set()
         for i, category in enumerate(categories):
             assigned_sps = [
@@ -525,37 +559,73 @@ 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
+                val = su.sumTimes(currAnnotation.subset(valid_sps)) / safe_total * 100
             else:
                 val = 0.0
-            df8_dict[category].append(min(val, 1.0))
+            df8_dict[category].append(min(val, 100.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
+            val = su.sumTimes(currAnnotation.subset(unassigned_sps)) / safe_total * 100
         else:
             val = 0.0
-        df8_dict["Unassigned"].append(min(val, 1.0))
-
-        # 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)
+        df8_dict["Unassigned"].append(min(val, 100.0))
 
     return pd.DataFrame(df8_dict), col_names
 
 
-def build_multifile_voice_df(validNames, summaries):
-    """Build df7 (no/one/multi voice percentages per file) for the multi-file expander."""
+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
+    """
+    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:
-        partial = summaries[fn]["df5"]
-        for i, name in enumerate(voiceNames):
-            df7_dict[name].append(partial["percentiles"][i])
+        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