Upload TMIDIX.py

TMIDIX.py

@@ -8423,6 +8423,270 @@ def proportions_counter(list_of_values):
 
   return [[c[0], c[1], c[1] / clen] for c in counts]
 
+###################################################################################
+
+def smooth_escore_notes(escore_notes):
+
+  values = [e[4] % 24 for e in escore_notes]
+
+  smoothed = [values[0]]
+
+  for i in range(1, len(values)):
+      if abs(smoothed[-1] - values[i]) >= 12:
+          if smoothed[-1] < values[i]:
+              smoothed.append(values[i] - 12)
+          else:
+              smoothed.append(values[i] + 12)
+      else:
+          smoothed.append(values[i])
+
+  smoothed_score = copy.deepcopy(escore_notes)
+
+  for i, e in enumerate(smoothed_score):
+    esn_octave = escore_notes[i][4] // 12
+    e[4] = (esn_octave * 12) + smoothed[i]
+
+  return smoothed_score
+
+###################################################################################
+
+def add_base_to_escore_notes(escore_notes,
+                             base_octave=2, 
+                             base_channel=2, 
+                             base_patch=35, 
+                             base_max_velocity=120,
+                             return_base=False
+                             ):
+  
+
+  score = copy.deepcopy(escore_notes)
+
+  cscore = chordify_score([1000, score])
+
+  base_score = []
+
+  for c in cscore:
+    chord = sorted([e for e in c if e[3] != 9], key=lambda x: x[4], reverse=True)
+    base_score.append(chord[-1])
+
+  base_score = smooth_escore_notes(base_score)
+
+  for e in base_score:
+    e[3] = base_channel
+    e[4] = (base_octave * 12) + (e[4] % 12)
+    e[5] = e[4]
+    e[6] = base_patch
+
+  adjust_score_velocities(base_score, base_max_velocity)
+
+  if return_base:
+    final_score = sorted(base_score, key=lambda x: (x[1], -x[4], x[6]))
+
+  else:
+    final_score = sorted(escore_notes + base_score, key=lambda x: (x[1], -x[4], x[6]))
+
+  return final_score
+
+###################################################################################
+
+def add_drums_to_escore_notes(escore_notes, 
+                              heavy_drums_pitches=[36, 38, 47],
+                              heavy_drums_velocity=110,
+                              light_drums_pitches=[51, 54],
+                              light_drums_velocity=127,
+                              drums_max_velocity=127,
+                              drums_ratio_time_divider=4,
+                              return_drums=False
+                              ):
+
+  score = copy.deepcopy([e for e in escore_notes if e[3] != 9])
+
+  cscore = chordify_score([1000, score])
+
+  drums_score = []
+
+  for c in cscore:
+    min_dur = max(1, min([e[2] for e in c]))
+    if not (c[0][1] % drums_ratio_time_divider):
+      drum_note = ['note', c[0][1], min_dur, 9, heavy_drums_pitches[c[0][4] % len(heavy_drums_pitches)], heavy_drums_velocity, 128]
+    else:
+      drum_note = ['note', c[0][1], min_dur, 9, light_drums_pitches[c[0][4] % len(light_drums_pitches)], light_drums_velocity, 128]
+    drums_score.append(drum_note)
+
+  adjust_score_velocities(drums_score, drums_max_velocity)
+
+  if return_drums:
+    final_score = sorted(drums_score, key=lambda x: (x[1], -x[4], x[6]))
+
+  else:
+    final_score = sorted(score + drums_score, key=lambda x: (x[1], -x[4], x[6]))
+
+  return final_score
+
+###################################################################################
+
+def find_pattern_start_indexes(values, pattern):
+
+  start_indexes = []
+
+  count = 0
+
+  for i in range(len(values)- len(pattern)):
+    chunk = values[i:i+len(pattern)]
+
+    if chunk == pattern:
+      start_indexes.append(i)
+
+  return start_indexes
+
+###################################################################################
+
+def escore_notes_lrno_pattern(escore_notes, mode='chords'):
+
+  cscore = chordify_score([1000, escore_notes])
+
+  checked_cscore = advanced_check_and_fix_chords_in_chordified_score(cscore)
+
+  chords_toks = []
+  chords_idxs = []
+
+  for i, c in enumerate(checked_cscore[0]):
+
+    pitches = sorted([p[4] for p in c if p[3] != 9], reverse=True)
+    tchord = pitches_to_tones_chord(pitches)
+
+    if tchord:
+      
+      if mode == 'chords':
+        token = ALL_CHORDS_FILTERED.index(tchord)
+      
+      elif mode == 'high pitches':
+        token = pitches[0]
+
+      elif mode == 'high pitches tones':
+        token = pitches[0] % 12
+
+      else:
+        token = ALL_CHORDS_FILTERED.index(tchord)
+
+      chords_toks.append(token)
+      chords_idxs.append(i)
+
+  lrno_pattern = list(find_lrno_patterns(chords_toks)[0][2])
+
+  if lrno_pattern:
+
+    start_idx = chords_idxs[find_pattern_start_indexes(chords_toks, lrno_pattern)[0]]
+    end_idx = chords_idxs[start_idx + len(lrno_pattern)]
+
+    return recalculate_score_timings(flatten(checked_cscore[0][start_idx:end_idx]))
+
+  else:
+    return None
+
+###################################################################################
+
+def chordified_score_pitches(chordified_score, 
+                             mode='dominant',
+                             return_tones=False,
+                             omit_drums=True,
+                             score_patch=-1,
+                             channels_index=3,
+                             pitches_index=4,
+                             patches_index=6                          
+                            ):
+
+  results = []
+
+  for c in chordified_score:
+    
+    if -1 < score_patch < 128:
+      ptcs = sorted([e[pitches_index] for e in c if e[channels_index] != 9 and e[patches_index] == score_patch], reverse=True)
+    
+    else:
+      ptcs = sorted([e[pitches_index] for e in c if e[channels_index] != 9], reverse=True)
+
+    if ptcs:
+
+      if mode == 'dominant':
+        
+        mtone = statistics.mode([p % 12 for p in ptcs])
+        
+        if return_tones:
+          results.append(mtone)
+        
+        else:
+          results.append(sorted(set([p for p in ptcs if p % 12 == mtone]), reverse=True))
+      
+      elif mode == 'high':
+        
+        if return_tones:
+          results.append(ptcs[0] % 12)
+
+        else:
+          results.append([ptcs[0]])
+
+      elif mode == 'base':
+
+        if return_tones:
+          results.append(ptcs[-1] % 12)
+
+        else:
+          results.append([ptcs[-1]])
+
+      elif mode == 'average':
+
+        if return_tones:
+          results.append(statistics.mean(ptcs) % 12)
+
+        else:
+          results.append([statistics.mean(ptcs)])
+
+      else:
+
+        mtone = statistics.mode([p % 12 for p in ptcs])
+        
+        if return_tones:
+          results.append(mtone)
+        
+        else:
+          results.append(sorted(set([p for p in ptcs if p % 12 == mtone]), reverse=True))
+
+    else:
+
+      if not omit_drums:
+        
+        if return_tones:
+          results.append(-1)
+        
+        else:
+          results.append([-1])
+
+  return results
+  
+###################################################################################
+
+def escore_notes_times_tones(escore_notes, 
+                             tones_mode='dominant', 
+                             return_abs_times=True,
+                             omit_drums=False
+                             ):
+
+  cscore = chordify_score([1000, escore_notes])
+  
+  tones = chordified_score_pitches(cscore, return_tones=True, mode=tones_mode, omit_drums=omit_drums)
+
+  if return_abs_times:
+    times = sorted([c[0][1] for c in cscore])
+  
+  else:
+    times = escore_notes_delta_times(escore_notes, omit_zeros=True, omit_drums=omit_drums)
+    
+    if len(times) != len(tones):
+      times = [0] + times
+
+  return [[t, to] for t, to in zip(times, tones)]
+
 ###################################################################################
 #  
 # This is the end of the TMIDI X Python module