Upload 2 files

TMIDIX.py

@@ -471,19 +471,6 @@ def grep(score=None, channels=None):
         itrack += 1
     return new_score
 
-def play_score(score=None):
-    r'''Converts the "score" to midi, and feeds it into 'aplaymidi -'
-'''
-    if score == None:
-        return
-    import subprocess
-    pipe = subprocess.Popen(['aplaymidi','-'], stdin=subprocess.PIPE)
-    if score_type(score) == 'opus':
-        pipe.stdin.write(opus2midi(score))
-    else:
-        pipe.stdin.write(score2midi(score))
-    pipe.stdin.close()
-
 def score2stats(opus_or_score=None):
     r'''Returns a dict of some basic stats about the score, like
 bank_select (list of tuples (msb,lsb)),
@@ -1832,6 +1819,7 @@ def plot_ms_SONG(ms_song,
         plt.close()
 
     if return_plt:
+      plt.close(fig)
       return fig
 
     plt.show()
@@ -2059,7 +2047,7 @@ def Optimus_MIDI_TXT_Processor(MIDI_file,
 
     #print('Loading MIDI file...')
     midi_file = open(MIDI_file, 'rb')
-    if debug: print('Processing File:', file_address)
+    if debug: print('Processing File:', MIDI_file)
     
     try:
       opus = midi2opus(midi_file.read())
@@ -4608,88 +4596,48 @@ def ascii_text_words_counter(ascii_text):
     
 ###################################################################################
 
-def check_and_fix_tones_chord(tones_chord):
-
-    lst = tones_chord
+def check_and_fix_tones_chord(tones_chord, use_full_chords=True):
 
-    if len(lst) == 2:
-      if lst[1] - lst[0] == 1:
-        return [lst[-1]]
-      else:
-        if 0 in lst and 11 in lst:
-          lst.remove(0)
-        return lst
+  tones_chord_combs = [list(comb) for i in range(len(tones_chord), 0, -1) for comb in combinations(tones_chord, i)]
 
-    non_consecutive = [lst[0]]
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
 
-    if len(lst) > 2: 
-      for i in range(1, len(lst) - 1):
-          if lst[i-1] + 1 != lst[i] and lst[i] + 1 != lst[i+1]:
-              non_consecutive.append(lst[i])
-      non_consecutive.append(lst[-1])
+  else:
+    CHORDS = ALL_CHORDS_SORTED
 
-    if 0 in non_consecutive and 11 in non_consecutive:
-      non_consecutive.remove(0)
+  for c in tones_chord_combs:
+    if c in CHORDS:
+      checked_tones_chord = c
+      break
 
-    return non_consecutive
+  return sorted(checked_tones_chord)
 
 ###################################################################################
 
 def find_closest_tone(tones, tone):
   return min(tones, key=lambda x:abs(x-tone))
 
-def advanced_check_and_fix_tones_chord(tones_chord, high_pitch=0):
+###################################################################################
 
-    lst = tones_chord
+def advanced_check_and_fix_tones_chord(tones_chord, high_pitch=0, use_full_chords=True):
 
-    if 0 < high_pitch < 128: 
-      ht = high_pitch % 12
-    else:
-      ht = 12
+  tones_chord_combs = [list(comb) for i in range(len(tones_chord), 0, -1) for comb in combinations(tones_chord, i)]
 
-    cht = find_closest_tone(lst, ht)
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
 
-    if len(lst) == 2:
-      if lst[1] - lst[0] == 1:
-        return [cht]
-      else:
-        if 0 in lst and 11 in lst:
-          if find_closest_tone([0, 11], cht) == 11:
-            lst.remove(0)
-          else:
-            lst.remove(11)
-        return lst
-
-    non_consecutive = []
-
-    if len(lst) > 2: 
-      for i in range(0, len(lst) - 1):
-          if lst[i] + 1 != lst[i+1]:
-            non_consecutive.append(lst[i])
-      if lst[-1] - lst[-2] > 1:
-        non_consecutive.append(lst[-1])
-
-    if cht not in non_consecutive:
-      non_consecutive.append(cht)
-      non_consecutive.sort()
-      if any(abs(non_consecutive[i+1] - non_consecutive[i]) == 1 for i in range(len(non_consecutive) - 1)):
-        final_list = [x for x in non_consecutive if x == cht or abs(x - cht) > 1]
-      else:
-        final_list = non_consecutive
+  else:
+    CHORDS = ALL_CHORDS_SORTED
 
-    else:
-      final_list = non_consecutive
+  for c in tones_chord_combs:
+    if c in CHORDS:
+      tchord = c
 
-    if 0 in final_list and 11 in final_list:
-      if find_closest_tone([0, 11], cht) == 11:
-        final_list.remove(0)
-      else:
-        final_list.remove(11)
+  if 0 < high_pitch < 128 and len(tchord) == 1:
+    tchord = [high_pitch % 12]
 
-    if cht in final_list or ht in final_list:
-      return final_list
-    else:
-      return ['Error']
+  return tchord
 
 ###################################################################################
 
@@ -4727,7 +4675,9 @@ def augment_enhanced_score_notes(enhanced_score_notes,
                                   full_sorting=True,
                                   timings_shift=0,
                                   pitch_shift=0,
-                                  legacy_timings=False
+                                  ceil_timings=False,
+                                  round_timings=False,
+                                  legacy_timings=True
                                 ):
 
     esn = copy.deepcopy(enhanced_score_notes)
@@ -4740,11 +4690,15 @@ def augment_enhanced_score_notes(enhanced_score_notes,
       
       dtime = (e[1] / timings_divider) - (pe[1] / timings_divider)
 
-      if 0.5 < dtime < 1:
-        dtime = 1
+      if round_timings:
+        dtime = round(dtime)
       
       else:
-        dtime = int(dtime)
+        if ceil_timings:
+          dtime = math.ceil(dtime)
+        
+        else:
+          dtime = int(dtime)
 
       if legacy_timings:
         abs_time = int(e[1] / timings_divider) + timings_shift
@@ -4754,7 +4708,14 @@ def augment_enhanced_score_notes(enhanced_score_notes,
 
       e[1] = max(0, abs_time + timings_shift)
 
-      e[2] = max(1, int(e[2] / timings_divider)) + timings_shift
+      if round_timings:
+        e[2] = max(1, round(e[2] / timings_divider)) + timings_shift
+      
+      else:
+        if ceil_timings:
+          e[2] = max(1, math.ceil(e[2] / timings_divider)) + timings_shift
+        else:
+          e[2] = max(1, int(e[2] / timings_divider)) + timings_shift
       
       e[4] = max(1, min(127, e[4] + pitch_shift))
 
@@ -5204,8 +5165,11 @@ def advanced_check_and_fix_chords_in_chordified_score(chordified_score,
                                                       channels_index=3,
                                                       pitches_index=4,
                                                       patches_index=6,
-                                                      use_filtered_chords=True,
+                                                      use_filtered_chords=False,
+                                                      use_full_chords=False,
                                                       remove_duplicate_pitches=True,
+                                                      fix_bad_tones_chords=False,
+                                                      fix_bad_pitches=False,
                                                       skip_drums=False
                                                       ):
   fixed_chordified_score = []
@@ -5218,16 +5182,21 @@ def advanced_check_and_fix_chords_in_chordified_score(chordified_score,
   else:
     CHORDS = ALL_CHORDS_SORTED
 
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
   for c in chordified_score:
 
+    chord = copy.deepcopy(c)
+
     if remove_duplicate_pitches:
 
-      c.sort(key = lambda x: x[pitches_index], reverse=True)
+      chord.sort(key = lambda x: x[pitches_index], reverse=True)
 
       seen = set()
       ddchord = []
 
-      for cc in c:
+      for cc in chord:
         if cc[channels_index] != 9:
 
           if tuple([cc[pitches_index], cc[patches_index]]) not in seen:
@@ -5239,9 +5208,9 @@ def advanced_check_and_fix_chords_in_chordified_score(chordified_score,
         else:
           ddchord.append(cc)
       
-      c = copy.deepcopy(ddchord)
+      chord = copy.deepcopy(ddchord)
       
-    tones_chord = sorted(set([t[pitches_index] % 12 for t in c if t[channels_index] != 9]))
+    tones_chord = sorted(set([t[pitches_index] % 12 for t in chord if t[channels_index] != 9]))
 
     if tones_chord:
 
@@ -5253,34 +5222,127 @@ def advanced_check_and_fix_chords_in_chordified_score(chordified_score,
             tones_counts = Counter([p % 12 for p in pitches_chord]).most_common()
 
             if tones_counts[0][1] > 1:
-              tones_chord = [tones_counts[0][0]]
+              good_tone = tones_counts[0][0]
+              bad_tone = tones_counts[1][0]
+            
             elif tones_counts[1][1] > 1:
-              tones_chord = [tones_counts[1][0]]
+              good_tone = tones_counts[1][0]
+              bad_tone = tones_counts[0][0]
+            
             else:
-              tones_chord = [pitches_chord[0] % 12]
+              good_tone = pitches_chord[0] % 12
+              bad_tone = [t for t in tones_chord if t != good_tone][0]
 
-          else:
-            tones_chord_combs = [list(comb) for i in range(len(tones_chord)-2, 0, -1) for comb in combinations(tones_chord, i+1)]
+            tones_chord = [good_tone]
+
+            if fix_bad_tones_chords:
+
+              if good_tone > bad_tone:
+
+                if sorted([good_tone, (12+(bad_tone+1)) % 12]) in CHORDS:
+                  tones_chord = sorted([good_tone, (12+(bad_tone-1)) % 12])
+
+                elif sorted([good_tone, (12+(bad_tone-1)) % 12]) in CHORDS:
+                  tones_chord = sorted([good_tone, (12+(bad_tone+1)) % 12])
+
+              else:
+
+                if sorted([good_tone, (12+(bad_tone-1)) % 12]) in CHORDS:
+                  tones_chord = sorted([good_tone, (12+(bad_tone-1)) % 12])
+
+                elif sorted([good_tone, (12+(bad_tone+1)) % 12]) in CHORDS:
+                  tones_chord = sorted([good_tone, (12+(bad_tone+1)) % 12])          
+
+          if len(tones_chord) > 2:
+            tones_chord_combs = [list(comb) for i in range(len(tones_chord)-1, 0, -1) for comb in combinations(tones_chord, i)]
 
             for co in tones_chord_combs:
               if co in CHORDS:
-                tones_chord = co
                 break
 
+            if fix_bad_tones_chords:
+
+              dt_chord = list(set(co) ^ set(tones_chord))
+
+              for t in dt_chord:
+                tones_chord.append((12+(t+1)) % 12)
+                tones_chord.append((12+(t-1)) % 12)
+
+              ex_tones_chord = sorted(set(tones_chord))
+
+              tones_chord_combs = [list(comb) for i in range(4, 0, -2) for comb in combinations(ex_tones_chord, i) if all(t in list(comb) for t in co)]
+              
+              for eco in tones_chord_combs:
+                if eco in CHORDS:
+                  tones_chord = eco
+                  break              
+
+            else:
+              tones_chord = co
+
+          if len(tones_chord) == 1:
+            tones_chord = [pitches_chord[0] % 12]
+            
           bad_chords_counter += 1
 
-    new_chord = []
+    chord.sort(key = lambda x: x[pitches_index], reverse=True)
 
-    c.sort(key = lambda x: x[pitches_index], reverse=True)
+    new_chord = set()
+    pipa = []
 
-    for e in c:
+    for e in chord:
       if e[channels_index] != 9:
         if e[pitches_index] % 12 in tones_chord:
-          new_chord.append(e)
+          new_chord.add(tuple(e))
+          pipa.append([e[pitches_index], e[patches_index]])
 
-      else:
-        if not skip_drums:
-          new_chord.append(e)
+        elif (e[pitches_index]+1) % 12 in tones_chord:
+          e[pitches_index] += 1
+          new_chord.add(tuple(e))
+          pipa.append([e[pitches_index], e[patches_index]])
+
+        elif (e[pitches_index]-1) % 12 in tones_chord:
+          e[pitches_index] -= 1
+          new_chord.add(tuple(e))
+          pipa.append([e[pitches_index], e[patches_index]])
+
+    if fix_bad_pitches:
+
+      bad_chord = set()
+
+      for e in chord:
+        if e[channels_index] != 9:
+          
+          if e[pitches_index] % 12 not in tones_chord:
+            bad_chord.add(tuple(e))
+          
+          elif (e[pitches_index]+1) % 12 not in tones_chord:
+            bad_chord.add(tuple(e))
+          
+          elif (e[pitches_index]-1) % 12 not in tones_chord:
+            bad_chord.add(tuple(e))
+      
+      for bc in bad_chord:
+
+        bc = list(bc)
+
+        tone = find_closest_tone(tones_chord, bc[pitches_index] % 12)
+
+        new_pitch =  ((bc[pitches_index] // 12) * 12) + tone
+
+        if [new_pitch, bc[patches_index]] not in pipa:
+          bc[pitches_index] = new_pitch
+          new_chord.add(tuple(bc))
+          pipa.append([[new_pitch], bc[patches_index]])
+
+    if not skip_drums:
+      for e in c:
+        if e[channels_index] == 9:
+          new_chord.add(tuple(e))
+
+    new_chord = [list(e) for e in new_chord]
+
+    new_chord.sort(key = lambda x: (-x[pitches_index], x[patches_index]))
 
     fixed_chordified_score.append(new_chord)
 
@@ -5476,11 +5538,11 @@ def harmonize_enhanced_melody_score_notes(enhanced_melody_score_notes):
     cur_chord.append(m)
     cc = sorted(set(cur_chord))
 
-    if cc in ALL_CHORDS_FILTERED:
+    if cc in ALL_CHORDS_FULL:
       song.append(cc)
 
     else:
-      while sorted(set(cur_chord)) not in ALL_CHORDS_FILTERED:
+      while sorted(set(cur_chord)) not in ALL_CHORDS_FULL:
         cur_chord.pop(0)
       cc = sorted(set(cur_chord))
       song.append(cc)
@@ -5617,7 +5679,7 @@ def basic_enhanced_delta_score_notes_tokenizer(enhanced_delta_score_notes,
   final_score_tokens_ints_seq = flatten(score_tokens_ints_seq)
 
   if max_seq_len > -1:
-    final_score_tokens_ints_seq = flat_score_tokens_ints_seq[:max_seq_len]
+    final_score_tokens_ints_seq = final_score_tokens_ints_seq[:max_seq_len]
 
   if seq_pad_value > -1:
     final_score_tokens_ints_seq += [seq_pad_value] * (max_seq_len - len(final_score_tokens_ints_seq))
@@ -5680,7 +5742,8 @@ def basic_enhanced_delta_score_notes_detokenizer(tokenized_seq,
 def enhanced_chord_to_chord_token(enhanced_chord, 
                                   channels_index=3, 
                                   pitches_index=4, 
-                                  use_filtered_chords=True
+                                  use_filtered_chords=False,
+                                  use_full_chords=True
                                   ):
   
   bad_chords_counter = 0
@@ -5691,6 +5754,9 @@ def enhanced_chord_to_chord_token(enhanced_chord,
   else:
     CHORDS = ALL_CHORDS_SORTED
 
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
   tones_chord = sorted(set([t[pitches_index] % 12 for t in enhanced_chord if t[channels_index] != 9]))
 
   original_tones_chord = copy.deepcopy(tones_chord)
@@ -7134,7 +7200,8 @@ CHORDS_TYPES = ['WHITE', 'BLACK', 'UNKNOWN', 'MIXED WHITE', 'MIXED BLACK', 'MIXE
 
 def tones_chord_type(tones_chord, 
                      return_chord_type_index=True,
-                     use_filtered_chords=True
+                     use_filtered_chords=False,
+                     use_full_chords=True
                      ):
 
   WN = WHITE_NOTES
@@ -7147,6 +7214,9 @@ def tones_chord_type(tones_chord,
   else:
     CHORDS = ALL_CHORDS_SORTED
 
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
   tones_chord = sorted(tones_chord)
 
   ctype = 'UNKNOWN'
@@ -7237,7 +7307,8 @@ def find_best_tones_chord(src_tones_chords,
 def find_matching_tones_chords(tones_chord,
                                matching_chord_length=-1,
                                match_chord_type=True,
-                               use_filtered_chords=True
+                               use_filtered_chords=True,
+                               use_full_chords=True
                                ):
 
   if use_filtered_chords:
@@ -7245,6 +7316,9 @@ def find_matching_tones_chords(tones_chord,
   else:
     CHORDS = ALL_CHORDS_SORTED
 
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
   tones_chord = sorted(tones_chord)
 
   tclen = len(tones_chord)
@@ -7427,46 +7501,104 @@ def harmonize_enhanced_melody_score_notes_to_ms_SONG(escore_notes,
 ###################################################################################
 
 def check_and_fix_pitches_chord(pitches_chord,
-                                use_filtered_chords=True
+                                remove_duplicate_pitches=True,
+                                use_filtered_chords=False,
+                                use_full_chords=True,
+                                fix_bad_pitches=False,
                                 ):
   
-  pitches_chord = sorted(pitches_chord, reverse=True)
+  if remove_duplicate_pitches:
+    pitches_chord = sorted(set(pitches_chord), reverse=True)
+  else:
+    pitches_chord = sorted(pitches_chord, reverse=True)
 
   if use_filtered_chords:
     CHORDS = ALL_CHORDS_FILTERED
   else:
     CHORDS = ALL_CHORDS_SORTED
 
-  tones_chord = sorted(set([p % 12 for p in pitches_chord]))
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
 
-  if tones_chord not in CHORDS:
+  chord = copy.deepcopy(pitches_chord)
+    
+  tones_chord = sorted(set([t % 12 for t in chord]))
+
+  if tones_chord:
 
-    if len(tones_chord) == 2:
+      if tones_chord not in CHORDS:
+        
+        if len(tones_chord) == 2:
+          tones_counts = Counter([p % 12 for p in pitches_chord]).most_common()
 
-      tones_counts = Counter([p % 12 for p in pitches_chord]).most_common()
+          if tones_counts[0][1] > 1:
+            tones_chord = [tones_counts[0][0]]
+          
+          elif tones_counts[1][1] > 1:
+            tones_chord = [tones_counts[1][0]]
+          
+          else:
+            tones_chord = [pitches_chord[0] % 12]
 
-      if tones_counts[0][1] > 1:
-        tones_chord = [tones_counts[0][0]]
-      elif tones_counts[1][1] > 1:
-        tones_chord = [tones_counts[1][0]]
-      else:
-        tones_chord = [pitches_chord[0] % 12]
+        else:
+          tones_chord_combs = [list(comb) for i in range(len(tones_chord)-1, 0, -1) for comb in combinations(tones_chord, i)]
+
+          for co in tones_chord_combs:
+            if co in CHORDS:
+              tones_chord = co
+              break
 
-    if len(tones_chord) > 2:
+          if len(tones_chord) == 1:
+            tones_chord = [pitches_chord[0] % 12]
+              
+  chord.sort(reverse=True)
 
-      tones_chord_combs = [list(comb) for i in range(len(tones_chord)-2, 0, -1) for comb in combinations(tones_chord, i+1)]
+  new_chord = set()
+  pipa = []
 
-      for co in tones_chord_combs:
-        if co in CHORDS:
-          tones_chord = co
-          break
+  for e in chord:
+    if e % 12 in tones_chord:
+      new_chord.add(tuple([e]))
+      pipa.append(e)
 
-  new_pitches_chord = []
+    elif (e+1) % 12 in tones_chord:
+      e += 1
+      new_chord.add(tuple([e]))
+      pipa.append(e)
 
-  for p in pitches_chord:
+    elif (e-1) % 12 in tones_chord:
+      e -= 1
+      new_chord.add(tuple([e]))
+      pipa.append(e)
 
-    if p % 12 in tones_chord:
-      new_pitches_chord.append(p)
+  if fix_bad_pitches:
+
+    bad_chord = set()
+
+    for e in chord:
+    
+      if e % 12 not in tones_chord:
+        bad_chord.add(tuple([e]))
+      
+      elif (e+1) % 12 not in tones_chord:
+        bad_chord.add(tuple([e]))
+      
+      elif (e-1) % 12 not in tones_chord:
+        bad_chord.add(tuple([e]))
+          
+    for bc in bad_chord:
+
+      bc = list(bc)
+
+      tone = find_closest_tone(tones_chord, bc[0] % 12)
+
+      new_pitch = ((bc[0] // 12) * 12) + tone
+
+      if new_pitch not in pipa:
+        new_chord.add(tuple([new_pitch]))
+        pipa.append(new_pitch)
+
+  new_pitches_chord = [e[0] for e in new_chord]
 
   return sorted(new_pitches_chord, reverse=True)
 
@@ -7658,7 +7790,8 @@ def tones_chords_to_types(tones_chords,
 
 def morph_tones_chord(tones_chord, 
                       trg_tone, 
-                      use_filtered_chords=True
+                      use_filtered_chords=True,
+                      use_full_chords=True
                       ):
 
   src_tones_chord = sorted(sorted(set(tones_chord)) + [trg_tone])
@@ -7673,6 +7806,9 @@ def morph_tones_chord(tones_chord,
   else:
     CHORDS = ALL_CHORDS_SORTED
 
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
   for c in combs:
     if sorted(set(c)) in CHORDS:
       matches.append(sorted(set(c)))
@@ -8061,7 +8197,7 @@ def compress_patches_in_escore_notes(escore_notes,
     n_patches = num_patches
 
   if group_patches:
-    patches_set = sorted(set([e[6] for e in c]))
+    patches_set = sorted(set([e[6] for e in escore_notes]))
     trg_patch_list = []
     seen = []
     for p in patches_set:
@@ -8072,7 +8208,7 @@ def compress_patches_in_escore_notes(escore_notes,
     trg_patch_list = sorted(trg_patch_list)
 
   else:
-    trg_patch_list = sorted(set([e[6] for e in c]))
+    trg_patch_list = sorted(set([e[6] for e in escore_notes]))
 
   if 128 in trg_patch_list and n_patches > 1:
     trg_patch_list = trg_patch_list[:n_patches-1] + [128]
@@ -8423,6 +8559,547 @@ 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_FULL.index(tchord)
+      
+      elif mode == 'high pitches':
+        token = pitches[0]
+
+      elif mode == 'high pitches tones':
+        token = pitches[0] % 12
+
+      else:
+        token = ALL_CHORDS_FULL.index(tchord)
+
+      chords_toks.append(token)
+      chords_idxs.append(i)
+
+  lrno_pats = find_lrno_patterns(chords_toks)
+
+  if lrno_pats:
+
+    lrno_pattern = list(lrno_pats[0][2])
+
+    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(cscore[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)]
+
+###################################################################################
+
+def escore_notes_middle(escore_notes, 
+                        length=10, 
+                        use_chords=True
+                        ):
+
+  if use_chords:
+    score = chordify_score([1000, escore_notes])
+
+  else:
+    score = escore_notes
+
+  middle_idx = len(score) // 2
+
+  slen = min(len(score) // 2, length // 2)
+
+  start_idx = middle_idx - slen
+  end_idx = middle_idx + slen
+
+  if use_chords:
+    return flatten(score[start_idx:end_idx])
+
+  else:
+    return score[start_idx:end_idx]
+
+###################################################################################
+
+ALL_CHORDS_FULL = [[0], [0, 3], [0, 3, 5], [0, 3, 5, 8], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 6],
+                  [0, 3, 6, 9], [0, 3, 6, 10], [0, 3, 7], [0, 3, 7, 10], [0, 3, 8], [0, 3, 9],
+                  [0, 3, 10], [0, 4], [0, 4, 6], [0, 4, 6, 9], [0, 4, 6, 10], [0, 4, 7],
+                  [0, 4, 7, 10], [0, 4, 8], [0, 4, 9], [0, 4, 10], [0, 5], [0, 5, 8], [0, 5, 9],
+                  [0, 5, 10], [0, 6], [0, 6, 9], [0, 6, 10], [0, 7], [0, 7, 10], [0, 8], [0, 9],
+                  [0, 10], [1], [1, 4], [1, 4, 6], [1, 4, 6, 9], [1, 4, 6, 10], [1, 4, 6, 11],
+                  [1, 4, 7], [1, 4, 7, 10], [1, 4, 7, 11], [1, 4, 8], [1, 4, 8, 11], [1, 4, 9],
+                  [1, 4, 10], [1, 4, 11], [1, 5], [1, 5, 8], [1, 5, 8, 11], [1, 5, 9],
+                  [1, 5, 10], [1, 5, 11], [1, 6], [1, 6, 9], [1, 6, 10], [1, 6, 11], [1, 7],
+                  [1, 7, 10], [1, 7, 11], [1, 8], [1, 8, 11], [1, 9], [1, 10], [1, 11], [2],
+                  [2, 5], [2, 5, 8], [2, 5, 8, 11], [2, 5, 9], [2, 5, 10], [2, 5, 11], [2, 6],
+                  [2, 6, 9], [2, 6, 10], [2, 6, 11], [2, 7], [2, 7, 10], [2, 7, 11], [2, 8],
+                  [2, 8, 11], [2, 9], [2, 10], [2, 11], [3], [3, 5], [3, 5, 8], [3, 5, 8, 11],
+                  [3, 5, 9], [3, 5, 10], [3, 5, 11], [3, 6], [3, 6, 9], [3, 6, 10], [3, 6, 11],
+                  [3, 7], [3, 7, 10], [3, 7, 11], [3, 8], [3, 8, 11], [3, 9], [3, 10], [3, 11],
+                  [4], [4, 6], [4, 6, 9], [4, 6, 10], [4, 6, 11], [4, 7], [4, 7, 10], [4, 7, 11],
+                  [4, 8], [4, 8, 11], [4, 9], [4, 10], [4, 11], [5], [5, 8], [5, 8, 11], [5, 9],
+                  [5, 10], [5, 11], [6], [6, 9], [6, 10], [6, 11], [7], [7, 10], [7, 11], [8],
+                  [8, 11], [9], [10], [11]]
+
+###################################################################################
+
+def escore_notes_to_parsons_code(escore_notes,
+                                 times_index=1,
+                                 pitches_index=4,
+                                 return_as_list=False
+                                 ):
+  
+  parsons = "*"
+  parsons_list = []
+
+  prev = ['note', -1, -1, -1, -1, -1, -1]
+
+  for e in escore_notes:
+    if e[times_index] != prev[times_index]:
+
+      if e[pitches_index] > prev[pitches_index]:
+          parsons += "U"
+          parsons_list.append(1)
+
+      elif e[pitches_index] < prev[pitches_index]:
+          parsons += "D"
+          parsons_list.append(-1)
+
+      elif e[pitches_index] == prev[pitches_index]:
+          parsons += "R"
+          parsons_list.append(0)
+      
+      prev = e
+
+  if return_as_list:
+    return parsons_list
+  
+  else:
+    return parsons
+
+###################################################################################
+
+def all_consequtive(list_of_values):
+  return all(b > a for a, b in zip(list_of_values[:-1], list_of_values[1:]))
+
+###################################################################################
+
+def escore_notes_patches(escore_notes, patches_index=6):
+  return sorted(set([e[patches_index] for e in escore_notes]))
+
+###################################################################################
+
+def build_suffix_array(lst):
+
+    n = len(lst)
+
+    suffixes = [(lst[i:], i) for i in range(n)]
+    suffixes.sort()
+    suffix_array = [suffix[1] for suffix in suffixes]
+
+    return suffix_array
+
+###################################################################################
+
+def build_lcp_array(lst, suffix_array):
+
+    n = len(lst)
+    rank = [0] * n
+    lcp = [0] * n
+
+    for i, suffix in enumerate(suffix_array):
+      rank[suffix] = i
+
+    h = 0
+
+    for i in range(n):
+      if rank[i] > 0:
+
+        j = suffix_array[rank[i] - 1]
+
+        while i + h < n and j + h < n and lst[i + h] == lst[j + h]:
+          h += 1
+
+        lcp[rank[i]] = h
+
+        if h > 0:
+          h -= 1
+
+    return lcp
+
+###################################################################################
+
+def find_lrno_pattern_fast(lst):
+    n = len(lst)
+    if n == 0:
+      return []
+
+    suffix_array = build_suffix_array(lst)
+    lcp_array = build_lcp_array(lst, suffix_array)
+
+    max_len = 0
+    start_index = 0
+
+    for i in range(1, n):
+      if lcp_array[i] > max_len:
+        if suffix_array[i] + lcp_array[i] <= suffix_array[i - 1] or suffix_array[i - 1] + lcp_array[i - 1] <= suffix_array[i]:
+          max_len = lcp_array[i]
+          start_index = suffix_array[i]
+
+    return lst[start_index:start_index + max_len]
+
+###################################################################################
+
+def find_chunk_indexes(original_list, chunk, ignore_index=-1):
+
+  chunk_length = len(chunk)
+
+  for i in range(len(original_list) - chunk_length + 1):
+
+    chunk_index = 0
+    start_index = ignore_index
+
+    for j in range(i, len(original_list)):
+      if original_list[j] == chunk[chunk_index]:
+
+        if start_index == ignore_index:
+          start_index = j
+
+        chunk_index += 1
+
+        if chunk_index == chunk_length:
+          return [start_index, j]
+
+      elif original_list[j] != ignore_index:
+        break
+
+  return None
+
+###################################################################################
+
+def escore_notes_lrno_pattern_fast(escore_notes, 
+                                   channels_index=3, 
+                                   pitches_index=4, 
+                                   zero_start_time=True
+                                  ):
+
+  cscore = chordify_score([1000, escore_notes])
+
+  score_chords = []
+
+  for c in cscore:
+
+    tchord = sorted(set([e[pitches_index] % 12 for e in c if e[channels_index] != 9]))
+
+    chord_tok = -1
+
+    if tchord:
+
+      if tchord not in ALL_CHORDS_FULL:
+        tchord = check_and_fix_tones_chord(tchord)
+
+      chord_tok = ALL_CHORDS_FULL.index(tchord)
+
+    score_chords.append(chord_tok)
+
+  schords = [c for c in score_chords if c != -1]
+
+  lrno = find_lrno_pattern_fast(schords)
+
+  if lrno:
+
+    sidx, eidx = find_chunk_indexes(score_chords, lrno)
+
+    escore_notes_lrno_pattern = flatten(cscore[sidx:eidx+1])
+
+    if escore_notes_lrno_pattern is not None:
+
+      if zero_start_time:
+        return recalculate_score_timings(escore_notes_lrno_pattern)
+
+      else:
+        return escore_notes_lrno_pattern
+
+    else:
+      return None
+  
+  else:
+    return None
+
+###################################################################################
+
+def escore_notes_durations_counter(escore_notes, 
+                                   min_duration=0, 
+                                   durations_index=2, 
+                                   channels_index=3
+                                   ):
+  
+  escore = [e for e in escore_notes if e[channels_index] != 9]
+  durs = [e[durations_index] for e in escore if e[durations_index] >= min_duration]
+  zero_durs = sum([1 for e in escore if e[durations_index] == 0])
+  
+  return [len(durs), len(escore), zero_durs, Counter(durs).most_common()]
+
+###################################################################################
+
+def count_bad_chords_in_chordified_score(chordified_score,  
+                                         pitches_index=4,
+                                         patches_index=6,
+                                         max_patch=127, 
+                                         use_full_chords=False
+                                         ):
+
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
+  else:
+    CHORDS = ALL_CHORDS_SORTED
+
+  bad_chords_count = 0
+
+  for c in chordified_score:
+
+    cpitches = [e[pitches_index] for e in c if e[patches_index] <= max_patch]
+    tones_chord = sorted(set([p % 12 for p in cpitches]))
+
+    if tones_chord:
+      if tones_chord not in CHORDS:
+        bad_chords_count += 1
+
+  return [bad_chords_count, len(chordified_score)] 
+
 ###################################################################################
 #  
 # This is the end of the TMIDI X Python module

TPLOTS.py

@@ -80,24 +80,25 @@ from PIL import Image
 # Constants
 ################################################################################
 
-ALL_CHORDS_FILTERED = [[0], [0, 3], [0, 3, 5], [0, 3, 5, 8], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 7],
-                      [0, 3, 7, 10], [0, 3, 8], [0, 3, 9], [0, 3, 10], [0, 4], [0, 4, 6],
-                      [0, 4, 6, 9], [0, 4, 6, 10], [0, 4, 7], [0, 4, 7, 10], [0, 4, 8], [0, 4, 9],
-                      [0, 4, 10], [0, 5], [0, 5, 8], [0, 5, 9], [0, 5, 10], [0, 6], [0, 6, 9],
-                      [0, 6, 10], [0, 7], [0, 7, 10], [0, 8], [0, 9], [0, 10], [1], [1, 4],
-                      [1, 4, 6], [1, 4, 6, 9], [1, 4, 6, 10], [1, 4, 6, 11], [1, 4, 7],
-                      [1, 4, 7, 10], [1, 4, 7, 11], [1, 4, 8], [1, 4, 8, 11], [1, 4, 9], [1, 4, 10],
-                      [1, 4, 11], [1, 5], [1, 5, 8], [1, 5, 8, 11], [1, 5, 9], [1, 5, 10],
-                      [1, 5, 11], [1, 6], [1, 6, 9], [1, 6, 10], [1, 6, 11], [1, 7], [1, 7, 10],
-                      [1, 7, 11], [1, 8], [1, 8, 11], [1, 9], [1, 10], [1, 11], [2], [2, 5],
-                      [2, 5, 8], [2, 5, 8, 11], [2, 5, 9], [2, 5, 10], [2, 5, 11], [2, 6], [2, 6, 9],
-                      [2, 6, 10], [2, 6, 11], [2, 7], [2, 7, 10], [2, 7, 11], [2, 8], [2, 8, 11],
-                      [2, 9], [2, 10], [2, 11], [3], [3, 5], [3, 5, 8], [3, 5, 8, 11], [3, 5, 9],
-                      [3, 5, 10], [3, 5, 11], [3, 7], [3, 7, 10], [3, 7, 11], [3, 8], [3, 8, 11],
-                      [3, 9], [3, 10], [3, 11], [4], [4, 6], [4, 6, 9], [4, 6, 10], [4, 6, 11],
-                      [4, 7], [4, 7, 10], [4, 7, 11], [4, 8], [4, 8, 11], [4, 9], [4, 10], [4, 11],
-                      [5], [5, 8], [5, 8, 11], [5, 9], [5, 10], [5, 11], [6], [6, 9], [6, 10],
-                      [6, 11], [7], [7, 10], [7, 11], [8], [8, 11], [9], [10], [11]]
+ALL_CHORDS_FULL = [[0], [0, 3], [0, 3, 5], [0, 3, 5, 8], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 6],
+                  [0, 3, 6, 9], [0, 3, 6, 10], [0, 3, 7], [0, 3, 7, 10], [0, 3, 8], [0, 3, 9],
+                  [0, 3, 10], [0, 4], [0, 4, 6], [0, 4, 6, 9], [0, 4, 6, 10], [0, 4, 7],
+                  [0, 4, 7, 10], [0, 4, 8], [0, 4, 9], [0, 4, 10], [0, 5], [0, 5, 8], [0, 5, 9],
+                  [0, 5, 10], [0, 6], [0, 6, 9], [0, 6, 10], [0, 7], [0, 7, 10], [0, 8], [0, 9],
+                  [0, 10], [1], [1, 4], [1, 4, 6], [1, 4, 6, 9], [1, 4, 6, 10], [1, 4, 6, 11],
+                  [1, 4, 7], [1, 4, 7, 10], [1, 4, 7, 11], [1, 4, 8], [1, 4, 8, 11], [1, 4, 9],
+                  [1, 4, 10], [1, 4, 11], [1, 5], [1, 5, 8], [1, 5, 8, 11], [1, 5, 9],
+                  [1, 5, 10], [1, 5, 11], [1, 6], [1, 6, 9], [1, 6, 10], [1, 6, 11], [1, 7],
+                  [1, 7, 10], [1, 7, 11], [1, 8], [1, 8, 11], [1, 9], [1, 10], [1, 11], [2],
+                  [2, 5], [2, 5, 8], [2, 5, 8, 11], [2, 5, 9], [2, 5, 10], [2, 5, 11], [2, 6],
+                  [2, 6, 9], [2, 6, 10], [2, 6, 11], [2, 7], [2, 7, 10], [2, 7, 11], [2, 8],
+                  [2, 8, 11], [2, 9], [2, 10], [2, 11], [3], [3, 5], [3, 5, 8], [3, 5, 8, 11],
+                  [3, 5, 9], [3, 5, 10], [3, 5, 11], [3, 6], [3, 6, 9], [3, 6, 10], [3, 6, 11],
+                  [3, 7], [3, 7, 10], [3, 7, 11], [3, 8], [3, 8, 11], [3, 9], [3, 10], [3, 11],
+                  [4], [4, 6], [4, 6, 9], [4, 6, 10], [4, 6, 11], [4, 7], [4, 7, 10], [4, 7, 11],
+                  [4, 8], [4, 8, 11], [4, 9], [4, 10], [4, 11], [5], [5, 8], [5, 8, 11], [5, 9],
+                  [5, 10], [5, 11], [6], [6, 9], [6, 10], [6, 11], [7], [7, 10], [7, 11], [8],
+                  [8, 11], [9], [10], [11]]
 
 ################################################################################
 
@@ -128,7 +129,7 @@ def tones_chord_type(tones_chord,
   MX = WHITE_NOTES + BLACK_NOTES
 
 
-  CHORDS = ALL_CHORDS_FILTERED
+  CHORDS = ALL_CHORDS_FULL
 
   tones_chord = sorted(tones_chord)
 
@@ -1130,6 +1131,129 @@ def downsample_square_matrix(square_matrix, downsampling_factor=4):
 
   return dmatrix.tolist()
 
+################################################################################
+
+def plot_parsons_code(parsons_code, 
+                      start_pitch=60, 
+                      return_plot_dict=False, 
+                      return_plot_string=False,
+                      plot_size=(10, 10),
+                      labels_size=16,
+                      save_plot=''
+                      ):
+  
+  '''
+  Plot parsons code string
+  '''
+
+  if parsons_code[0] != "*":
+      return None
+
+  contour_dict = {}
+  pitch = 0
+  index = 0
+
+  maxp = 0
+  minp = 0
+
+  contour_dict[(pitch, index)] = "*"
+
+  for point in parsons_code:
+      if point == "R":
+          index += 1
+          contour_dict[(pitch, index)] = "-"
+
+          index += 1
+          contour_dict[(pitch, index)] = "*"
+          
+      elif point == "U":
+          index += 1
+          pitch -= 1
+          contour_dict[(pitch, index)] = "/"
+
+          index += 1
+          pitch -= 1
+          contour_dict[(pitch, index)] = "*"
+
+          if pitch < maxp:
+              maxp = pitch
+
+      elif point == "D":
+          index += 1
+          pitch += 1
+          contour_dict[(pitch, index)] = "\\"
+
+          index += 1
+          pitch += 1
+          contour_dict[(pitch, index)] = "*"
+
+          if pitch > minp:
+              minp = pitch
+
+  if return_plot_dict:
+    return contour_dict
+  
+  if return_plot_string:
+
+    plot_string = ''
+
+    for pitch in range(maxp, minp+1):
+        line = [" " for _ in range(index + 1)]
+        for pos in range(index + 1):
+            if (pitch, pos) in contour_dict:
+                line[pos] = contour_dict[(pitch, pos)]
+
+        plot_string = "".join(line)
+
+    return plot_string
+
+  labels = []
+  pitches = []
+  positions = []
+  cur_pitch = start_pitch
+  pitch_idx = 0
+
+  for k, v in contour_dict.items():
+
+    if v != '*':
+
+      pitches.append(cur_pitch)
+      positions.append(pitch_idx)
+
+      if v == '/':
+        cur_pitch += 1
+        labels.append('U')
+      
+      elif v == '\\':
+        cur_pitch -= 1
+        labels.append('D')
+
+      elif v == '-':
+        labels.append('R')
+
+      pitch_idx += 1
+
+  plt.figure(figsize=plot_size)
+
+  
+  plt.plot(pitches)
+
+  for i, point in enumerate(zip(positions, pitches)):
+    plt.annotate(labels[i], point, fontsize=labels_size)
+  
+
+  plt.title('Parsons Code with Labels', fontsize=labels_size)
+  plt.xlabel('Position', fontsize=labels_size)
+  plt.ylabel('Pitch', fontsize=labels_size)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+  
 ################################################################################
 # [WIP] Future dev functions
 ################################################################################