Upload TMIDIX.py

TMIDIX.py

@@ -9111,10 +9111,151 @@ def count_bad_chords_in_chordified_score(chordified_score,
       if tones_chord not in CHORDS:
         bad_chords_count += 1
 
-  return [bad_chords_count, len(chordified_score)] 
+  return [bad_chords_count, len(chordified_score)]
+
+###################################################################################
+
+def needleman_wunsch_aligner(seq1,
+                             seq2,
+                             align_idx,
+                             gap_penalty=-1,
+                             match_score=2,
+                             mismatch_penalty=-1
+                             ):
+    
+    n = len(seq1)
+    m = len(seq2)
+    
+    score_matrix = [[0] * (m + 1) for _ in range(n + 1)]
+
+    for i in range(1, n + 1):
+        score_matrix[i][0] = gap_penalty * i
+    for j in range(1, m + 1):
+        score_matrix[0][j] = gap_penalty * j
+
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            match = score_matrix[i-1][j-1] + (match_score if seq1[i-1][align_idx] == seq2[j-1][align_idx] else mismatch_penalty)
+            delete = score_matrix[i-1][j] + gap_penalty
+            insert = score_matrix[i][j-1] + gap_penalty
+            score_matrix[i][j] = max(match, delete, insert)
+
+    align1, align2 = [], []
+    i, j = n, m
+    
+    while i > 0 and j > 0:
+        
+        score = score_matrix[i][j]
+        score_diag = score_matrix[i-1][j-1]
+        score_up = score_matrix[i-1][j]
+        score_left = score_matrix[i][j-1]
+
+        if score == score_diag + (match_score if seq1[i-1][align_idx] == seq2[j-1][align_idx] else mismatch_penalty):
+            align1.append(seq1[i-1])
+            align2.append(seq2[j-1])
+            i -= 1
+            j -= 1
+        elif score == score_up + gap_penalty:
+            align1.append(seq1[i-1])
+            align2.append([None] * 6)
+            i -= 1
+        elif score == score_left + gap_penalty:
+            align1.append([None] * 6)
+            align2.append(seq2[j-1])
+            j -= 1
+
+    while i > 0:
+        align1.append(seq1[i-1])
+        align2.append([None] * 6)
+        i -= 1
+    while j > 0:
+        align1.append([None] * 6)
+        align2.append(seq2[j-1])
+        j -= 1
+
+    align1.reverse()
+    align2.reverse()
+
+    return align1, align2
+
+###################################################################################
+
+def align_escore_notes_to_escore_notes(src_escore_notes,
+                                       trg_escore_notes,
+                                       recalculate_scores_timings=True,
+                                       pitches_idx=4
+                                       ):
+    
+    if recalculate_scores_timings:
+        src_escore_notes = recalculate_score_timings(src_escore_notes)
+        trg_escore_notes = recalculate_score_timings(trg_escore_notes)
+        
+    src_align1, trg_align2 = needleman_wunsch_aligner(src_escore_notes, trg_escore_notes, pitches_idx)
+
+    aligned_scores = [[al[0], al[1]] for al in zip(src_align1, trg_align2) if al[0][0] is not None and al[1][0] is not None]
+    
+    return aligned_scores
+
+###################################################################################
+
+def t_to_n(arr, si, t):
+
+    ct = 0
+    ci = si
+    
+    while ct + arr[ci][1] < t and ci < len(arr)-1:
+        ct += arr[ci][1]
+        ci += 1
+
+    return ci+1
+
+###################################################################################
+
+def max_sum_chunk_idxs(arr, t=255):
+
+    n = t_to_n(arr, 0, t)
+    
+    if n > len(arr):
+        return [0, n]
+
+    max_sum = 0
+    max_sum_start_index = 0
+    
+    max_sum_start_idxs = [0, len(arr), sum([a[0] for a in arr])]
+
+    for i in range(len(arr)):
+
+        n = t_to_n(arr, i, t)
+
+        current_sum  = sum([a[0] for a in arr[i:n]])
+        current_time = sum([a[1] for a in arr[i:n]])
+
+        if current_sum > max_sum and current_time <= t:
+            max_sum = current_sum
+            max_sum_start_idxs = [i, n, max_sum]
+
+    return max_sum_start_idxs
+
+###################################################################################
+
+def find_highest_density_escore_notes_chunk(escore_notes, max_chunk_time=512):
+
+    dscore = delta_score_notes(escore_notes)
+    
+    cscore = chordify_score([d[1:] for d in dscore])
+
+    notes_counts = [[len(c), c[0][0]] for c in cscore]
+
+    msc_idxs = max_sum_chunk_idxs(notes_counts, max_chunk_time)
+
+    chunk_dscore = [['note'] + c for c in flatten(cscore[msc_idxs[0]:msc_idxs[1]])]
+
+    chunk_escore = recalculate_score_timings(delta_score_to_abs_score(chunk_dscore))
+    
+    return chunk_escore
 
 ###################################################################################
 #  
 # This is the end of the TMIDI X Python module
 #
-###################################################################################
+###################################################################################