Upload 2 files

TMIDIX.py

@@ -1484,6 +1484,7 @@ from abc import ABC, abstractmethod
 from difflib import SequenceMatcher as SM
 
 import statistics
+import math
 
 import matplotlib.pyplot as plt
 
@@ -6391,6 +6392,302 @@ def reverse_enhanced_score_notes(enhanced_score_notes):
 
 ###################################################################################
 
+def count_patterns(lst, sublist):
+    count = 0
+    idx = 0
+    for i in range(len(lst) - len(sublist) + 1):
+        if lst[idx:idx + len(sublist)] == sublist:
+            count += 1
+            idx += len(sublist)
+        else:
+          idx += 1
+    return count
+
+def find_lrno_patterns(seq):
+
+  all_seqs = Counter()
+
+  max_pat_len = math.ceil(len(seq) / 2)
+
+  num_iter = 0
+
+  for i in range(len(seq)):
+    for j in range(i+1, len(seq)+1):
+      if j-i <= max_pat_len:
+        all_seqs[tuple(seq[i:j])] += 1
+        num_iter += 1
+
+  max_count = 0
+  max_len = 0
+
+  for val, count in all_seqs.items():
+
+    if max_len < len(val):
+      max_count = max(2, count)
+
+    if count > 1:
+      max_len = max(max_len, len(val))
+      pval = val
+
+  max_pats = []
+
+  for val, count in all_seqs.items():
+    if count == max_count and len(val) == max_len:
+      max_pats.append(val)
+
+  found_patterns = []
+
+  for pat in max_pats:
+    count = count_patterns(seq, list(pat))
+    if count > 1:
+      found_patterns.append([count, len(pat), pat])
+
+  return found_patterns
+
+###################################################################################
+
+def delta_pitches(escore_notes, pitches_index=4):
+
+  pitches = [p[pitches_index] for p in escore_notes]
+  
+  return [a-b for a, b in zip(pitches[:-1], pitches[1:])]
+
+###################################################################################
+
+def split_list(lst, val):
+    return [lst[i:j] for i, j in zip([0] + [k + 1 for k, x in enumerate(lst) if x == val], [k for k, x in enumerate(lst) if x == val] + [len(lst)]) if j > i]
+
+###################################################################################
+
+def even_timings(escore_notes, 
+                 times_idx=1, 
+                 durs_idx=2
+                 ):
+
+  esn = copy.deepcopy(escore_notes)
+
+  for e in esn:
+
+    if e[times_idx] != 0:
+      if e[times_idx] % 2 != 0:
+        e[times_idx] += 1
+
+    if e[durs_idx] % 2 != 0:
+      e[durs_idx] += 1
+
+  return esn
+
+###################################################################################
+
+def delta_score_to_abs_score(delta_score_notes, 
+                            times_idx=1
+                            ):
+
+  abs_score = copy.deepcopy(delta_score_notes)
+
+  abs_time = 0
+
+  for i, e in enumerate(delta_score_notes):
+
+    dtime = e[times_idx]
+    
+    abs_time += dtime
+
+    abs_score[i][times_idx] = abs_time
+    
+  return abs_score
+
+###################################################################################
+
+
+def adjust_numbers_to_sum(numbers, target_sum):
+
+  current_sum = sum(numbers)
+  difference = target_sum - current_sum
+
+  non_zero_elements = [(i, num) for i, num in enumerate(numbers) if num != 0]
+
+  total_non_zero = sum(num for _, num in non_zero_elements)
+
+  increments = []
+  for i, num in non_zero_elements:
+      proportion = num / total_non_zero
+      increment = proportion * difference
+      increments.append(increment)
+
+  for idx, (i, num) in enumerate(non_zero_elements):
+      numbers[i] += int(round(increments[idx]))
+
+  current_sum = sum(numbers)
+  difference = target_sum - current_sum
+  non_zero_indices = [i for i, num in enumerate(numbers) if num != 0]
+
+  for i in range(abs(difference)):
+      numbers[non_zero_indices[i % len(non_zero_indices)]] += 1 if difference > 0 else -1
+
+  return numbers
+
+###################################################################################
+
+def find_next_bar(escore_notes, bar_time, start_note_idx, cur_bar):
+  for e in escore_notes[start_note_idx:]:
+    if e[1] // bar_time > cur_bar:
+      return e, escore_notes.index(e)
+
+###################################################################################
+
+def align_escore_notes_to_bars(escore_notes,
+                               bar_time=4000,
+                               trim_durations=False,
+                               split_durations=False
+                               ):
+
+  #=============================================================================
+
+  aligned_escore_notes = copy.deepcopy(escore_notes)
+
+  abs_time = 0
+  nidx = 0
+  delta = 0
+  bcount = 0
+  next_bar = [0]
+
+  #=============================================================================
+
+  while next_bar:
+
+    next_bar = find_next_bar(escore_notes, bar_time, nidx, bcount)
+
+    if next_bar:
+
+      gescore_notes = escore_notes[nidx:next_bar[1]]
+    else:
+      gescore_notes = escore_notes[nidx:]
+
+    original_timings = [delta] + [(b[1]-a[1]) for a, b in zip(gescore_notes[:-1], gescore_notes[1:])]
+    adj_timings = adjust_numbers_to_sum(original_timings, bar_time)
+
+    for t in adj_timings:
+
+      abs_time += t
+
+      aligned_escore_notes[nidx][1] = abs_time
+      aligned_escore_notes[nidx][2] -= int(bar_time // 200)
+
+      nidx += 1
+
+    if next_bar:
+      delta = escore_notes[next_bar[1]][1]-escore_notes[next_bar[1]-1][1]
+    bcount += 1
+
+  #=============================================================================
+
+  aligned_adjusted_escore_notes = []
+  bcount = 0
+
+  for a in aligned_escore_notes:
+    bcount = a[1] // bar_time
+    nbtime = bar_time * (bcount+1)
+
+    if a[1]+a[2] > nbtime and a[3] != 9:
+      if trim_durations or split_durations:
+        ddiff = ((a[1]+a[2])-nbtime)
+        aa = copy.deepcopy(a)
+        aa[2] = a[2] - ddiff
+        aligned_adjusted_escore_notes.append(aa)
+
+        if split_durations:
+          aaa = copy.deepcopy(a)
+          aaa[1] = a[1]+aa[2]
+          aaa[2] = ddiff
+
+          aligned_adjusted_escore_notes.append(aaa)
+
+      else:
+        aligned_adjusted_escore_notes.append(a)
+
+    else:
+      aligned_adjusted_escore_notes.append(a)
+
+  #=============================================================================
+
+  return aligned_adjusted_escore_notes
+
+###################################################################################
+
+def normalize_chord_durations(chord, 
+                              dur_idx=2, 
+                              norm_factor=100
+                              ):
+
+  nchord = copy.deepcopy(chord)
+  
+  for c in nchord:
+    c[dur_idx] = int(round(max(1 / norm_factor, c[dur_idx] // norm_factor) * norm_factor))
+
+  return nchord
+
+###################################################################################
+
+def normalize_chordified_score_durations(chordified_score, 
+                                         dur_idx=2, 
+                                         norm_factor=100
+                                         ):
+
+  ncscore = copy.deepcopy(chordified_score)
+  
+  for cc in ncscore:
+    for c in cc:
+      c[dur_idx] = int(round(max(1 / norm_factor, c[dur_idx] // norm_factor) * norm_factor))
+
+  return ncscore
+
+###################################################################################
+
+def horizontal_ordered_list_search(list_of_lists, 
+                                    query_list, 
+                                    start_idx=0,
+                                    end_idx=-1
+                                    ):
+
+  lol = list_of_lists
+
+  results = []
+
+  if start_idx > 0:
+    lol = list_of_lists[start_idx:]
+
+  if start_idx == -1:
+    idx = -1
+    for i, l in enumerate(list_of_lists):
+      try:
+        idx = l.index(query_list[0])
+        lol = list_of_lists[i:]
+        break
+      except:
+        continue
+
+    if idx == -1:
+      results.append(-1)
+      return results
+    else:
+      results.append(i)
+
+  if end_idx != -1:
+    lol = list_of_lists[start_idx:start_idx+max(end_idx, len(query_list))]
+
+  for i, q in enumerate(query_list):
+    try:
+      idx = lol[i].index(q)
+      results.append(idx)
+    except:
+      results.append(-1)
+      return results
+
+  return results
+
+###################################################################################
+
 # This is the end of the TMIDI X Python module
 
 ###################################################################################

pitches_chords_progressions_5_3_15.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2483e8388086f8c9e9c345e3bb9d14f6df7a8004428d671e74606b04c19a51c0
+size 98809865