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
 
@@ -1762,7 +1763,10 @@ def plot_ms_SONG(ms_song,
                   note_height = 0.75,
                   show_grid_lines=False,
                   return_plt = False,
-                  timings_multiplier=1
+                  timings_multiplier=1,
+                  save_plt='',
+                  save_only_plt_image=True,
+                  save_transparent=False
                   ):
 
   '''Tegridy ms SONG plotter/vizualizer'''
@@ -1816,10 +1820,22 @@ def plot_ms_SONG(ms_song,
 
     plt.title(plot_title)
 
+    if save_plt != '':
+      if save_only_plt_image:
+        plt.axis('off')
+        plt.title('')
+        plt.savefig(save_plt, transparent=save_transparent, bbox_inches='tight', pad_inches=0, facecolor='black')
+        plt.close()
+      
+      else:
+        plt.savefig(save_plt)
+        plt.close()
+
     if return_plt:
       return fig
 
     plt.show()
+    plt.close()
 
 ###################################################################################
 
@@ -1932,7 +1948,7 @@ def Tegridy_Any_Pickle_File_Reader(input_file_name='TMIDI_Pickle_File', ext='.pi
 
   '''Tegridy Pickle File Loader
      
-  Input: Full path and file name without extention
+  Input: Full path and file name with or without extention
          File extension if different from default .pickle
        
   Output: Standard Python 3 unpickled data object
@@ -1944,7 +1960,13 @@ def Tegridy_Any_Pickle_File_Reader(input_file_name='TMIDI_Pickle_File', ext='.pi
     print('Tegridy Pickle File Loader')
     print('Loading the pickle file. Please wait...')
 
-  with open(input_file_name + ext, 'rb') as pickle_file:
+  if os.path.basename(input_file_name).endswith(ext):
+    fname = input_file_name
+  
+  else:
+    fname = input_file_name + ext
+
+  with open(fname, 'rb') as pickle_file:
     content = pickle.load(pickle_file)
 
   if verbose:
@@ -3519,12 +3541,19 @@ def Tegridy_Split_List(list_to_split, split_value=0):
 
 # Binary chords functions
 
-def tones_chord_to_bits(chord):
+def tones_chord_to_bits(chord, reverse=True):
+
     bits = [0] * 12
+
     for num in chord:
         bits[num] = 1
     
-    return bits
+    if reverse:
+      bits.reverse()
+      return bits
+    
+    else:
+      return bits
 
 def bits_to_tones_chord(bits):
     return [i for i, bit in enumerate(bits) if bit == 1]
@@ -4687,23 +4716,53 @@ def create_similarity_matrix(list_of_values, matrix_length=0):
 
 ###################################################################################
 
+def ceil_with_precision(value, decimal_places):
+    factor = 10 ** decimal_places
+    return math.ceil(value * factor) / factor
+
+###################################################################################
+
 def augment_enhanced_score_notes(enhanced_score_notes,
                                   timings_divider=16,
                                   full_sorting=True,
                                   timings_shift=0,
-                                  pitch_shift=0
+                                  pitch_shift=0,
+                                  legacy_timings=False
                                 ):
 
     esn = copy.deepcopy(enhanced_score_notes)
 
-    for e in esn:
-      e[1] = int(e[1] / timings_divider) + timings_shift
-      e[2] = int(e[2] / timings_divider) + timings_shift
-      e[4] = e[4] + pitch_shift
+    pe = enhanced_score_notes[0]
+
+    abs_time = max(0, int(enhanced_score_notes[0][1] / timings_divider))
+
+    for i, e in enumerate(esn):
+      
+      dtime = (e[1] / timings_divider) - (pe[1] / timings_divider)
+
+      if 0.5 < dtime < 1:
+        dtime = 1
+      
+      else:
+        dtime = int(dtime)
+
+      if legacy_timings:
+        abs_time = int(e[1] / timings_divider) + timings_shift
+
+      else:
+        abs_time += dtime
+
+      e[1] = max(0, abs_time + timings_shift)
+
+      e[2] = max(1, int(e[2] / timings_divider)) + timings_shift
+      
+      e[4] = max(1, min(127, e[4] + pitch_shift))
+
+      pe = enhanced_score_notes[i]
 
     if full_sorting:
 
-      # Sorting by patch, pitch, then by start-time
+      # Sorting by patch, reverse pitch and start-time
       esn.sort(key=lambda x: x[6])
       esn.sort(key=lambda x: x[4], reverse=True)
       esn.sort(key=lambda x: x[1])
@@ -4894,25 +4953,26 @@ def patch_list_from_enhanced_score_notes(enhanced_score_notes,
   patches = [-1] * 16
 
   for idx, e in enumerate(enhanced_score_notes):
-    if e[3] != 9:
-        if patches[e[3]] == -1:
-            patches[e[3]] = e[6]
-        else:
-            if patches[e[3]] != e[6]:
-              if e[6] in patches:
-                e[3] = patches.index(e[6])
-              else:
-                if -1 in patches:
-                    patches[patches.index(-1)] = e[6]
+    if e[0] == 'note':
+      if e[3] != 9:
+          if patches[e[3]] == -1:
+              patches[e[3]] = e[6]
+          else:
+              if patches[e[3]] != e[6]:
+                if e[6] in patches:
+                  e[3] = patches.index(e[6])
                 else:
-                  patches[-1] = e[6]
+                  if -1 in patches:
+                      patches[patches.index(-1)] = e[6]
+                  else:
+                    patches[-1] = e[6]
 
-                  if verbose:
-                    print('=' * 70)
-                    print('WARNING! Composition has more than 15 patches!')
-                    print('Conflict note number:', idx)
-                    print('Conflict channel number:', e[3])
-                    print('Conflict patch number:', e[6])
+                    if verbose:
+                      print('=' * 70)
+                      print('WARNING! Composition has more than 15 patches!')
+                      print('Conflict note number:', idx)
+                      print('Conflict channel number:', e[3])
+                      print('Conflict patch number:', e[6])
 
   patches = [p if p != -1 else default_patch for p in patches]
 
@@ -4945,19 +5005,20 @@ def patch_enhanced_score_notes(enhanced_score_notes,
     overflow_idx = -1
 
     for idx, e in enumerate(enhanced_score_notes):
-      if e[3] != 9:
-          if patches[e[3]] == -1:
-              patches[e[3]] = e[6]
-          else:
-              if patches[e[3]] != e[6]:
-                if e[6] in patches:
-                  e[3] = patches.index(e[6])
-                else:
-                  if -1 in patches:
-                      patches[patches.index(-1)] = e[6]
+      if e[0] == 'note':
+        if e[3] != 9:
+            if patches[e[3]] == -1:
+                patches[e[3]] = e[6]
+            else:
+                if patches[e[3]] != e[6]:
+                  if e[6] in patches:
+                    e[3] = patches.index(e[6])
                   else:
-                      overflow_idx = idx
-                      break
+                    if -1 in patches:
+                        patches[patches.index(-1)] = e[6]
+                    else:
+                        overflow_idx = idx
+                        break
 
       enhanced_score_notes_with_patch_changes.append(e)
 
@@ -4967,15 +5028,16 @@ def patch_enhanced_score_notes(enhanced_score_notes,
 
     if overflow_idx != -1:
       for idx, e in enumerate(enhanced_score_notes[overflow_idx:]):
-        if e[3] != 9:
-          if e[6] not in patches:
-            if e[6] not in overflow_patches:
-              overflow_patches.append(e[6])
-              enhanced_score_notes_with_patch_changes.append(['patch_change', e[1], e[3], e[6]])
-          else:
-            e[3] = patches.index(e[6])
+        if e[0] == 'note':
+          if e[3] != 9:
+            if e[6] not in patches:
+              if e[6] not in overflow_patches:
+                overflow_patches.append(e[6])
+                enhanced_score_notes_with_patch_changes.append(['patch_change', e[1], e[3], e[6]])
+            else:
+              e[3] = patches.index(e[6])
 
-        enhanced_score_notes_with_patch_changes.append(e)
+          enhanced_score_notes_with_patch_changes.append(e)
 
     #===========================================================================
 
@@ -5258,7 +5320,8 @@ def add_melody_to_enhanced_score_notes(enhanced_score_notes,
                                       melody_patch=40,
                                       melody_max_velocity=110,
                                       acc_max_velocity=90,
-                                      pass_drums=True
+                                      pass_drums=True,
+                                      return_melody=False
                                       ):
   
     if pass_drums:
@@ -5336,7 +5399,11 @@ def add_melody_to_enhanced_score_notes(enhanced_score_notes,
 
     adjust_score_velocities(smoothed_melody, melody_max_velocity)
 
-    final_score = sorted(smoothed_melody + acc_score, key=lambda x: (x[1], -x[4]))
+    if return_melody:
+      final_score = sorted(smoothed_melody, key=lambda x: (x[1], -x[4]))
+
+    else:
+      final_score = sorted(smoothed_melody + acc_score, key=lambda x: (x[1], -x[4]))
 
     return final_score
     
@@ -5349,7 +5416,10 @@ def find_paths(list_of_lists, path=[]):
 
 ###################################################################################
 
-def recalculate_score_timings(score, start_time=0):
+def recalculate_score_timings(score, 
+                              start_time=0, 
+                              timings_index=1
+                              ):
 
   rscore = copy.deepcopy(score)
 
@@ -5359,10 +5429,10 @@ def recalculate_score_timings(score, start_time=0):
 
   for e in rscore:
 
-    dtime = e[1] - pe[1]
+    dtime = e[timings_index] - pe[timings_index]
     pe = copy.deepcopy(e)
     abs_time += dtime
-    e[1] = abs_time
+    e[timings_index] = abs_time
     
   return rscore
 
@@ -6359,38 +6429,2002 @@ def transpose_pitches(pitches, transpose_value=0):
 
 ###################################################################################
 
-def reverse_enhanced_score_notes(enhanced_score_notes):
+def reverse_enhanced_score_notes(escore_notes):
+
+  score = recalculate_score_timings(escore_notes)
+
+  ematrix = escore_notes_to_escore_matrix(score, reverse_matrix=True)
+  e_score = escore_matrix_to_original_escore_notes(ematrix)
 
-  score = recalculate_score_timings(enhanced_score_notes)
+  reversed_score = recalculate_score_timings(e_score)
 
-  cscore = chordify_score([1000, score])
+  return reversed_score
 
-  abs_dtimes = []
+###################################################################################
 
-  for i, t in enumerate(cscore[:-1]):
-    abs_dtimes.append(cscore[i+1][0][1])
-  abs_dtimes.append(cscore[-1][0][1]+cscore[-1][0][2])
+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
 
-  new_dtimes = []
-  pt = abs_dtimes[-1]
+###################################################################################
 
-  for t in abs_dtimes[::-1]:
-    new_dtimes.append(abs(pt-t))
-    pt = t
+def find_lrno_patterns(seq):
 
-  new_mel = copy.deepcopy(cscore[::-1])
+  all_seqs = Counter()
 
-  time = 0
+  max_pat_len = math.ceil(len(seq) / 2)
 
-  for i, t in enumerate(new_mel):
-    time += new_dtimes[i]
-    for tt in t:
-      tt[1] = time
+  num_iter = 0
 
-  return recalculate_score_timings(flatten(new_mel))
+  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
 
 ###################################################################################
 
-# This is the end of the TMIDI X Python module
+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
+
+###################################################################################
+
+def escore_notes_to_escore_matrix(escore_notes,
+                                  alt_velocities=False,
+                                  flip_matrix=False,
+                                  reverse_matrix=False
+                                  ):
+
+  last_time = escore_notes[-1][1]
+  last_notes = [e for e in escore_notes if e[1] == last_time]
+  max_last_dur = max([e[2] for e in last_notes])
+
+  time_range = last_time+max_last_dur
+
+  channels_list = sorted(set([e[3] for e in escore_notes]))
+
+  escore_matrixes = []
+
+  for cha in channels_list:
+
+    escore_matrix = [[[-1, -1]] * 128 for _ in range(time_range)]
+
+    pe = escore_notes[0]
+
+    for i, note in enumerate(escore_notes):
+
+        etype, time, duration, channel, pitch, velocity, patch = note
+
+        time = max(0, time)
+        duration = max(1, duration)
+        channel = max(0, min(15, channel))
+        pitch = max(0, min(127, pitch))
+        velocity = max(0, min(127, velocity))
+        patch = max(0, min(128, patch))
+
+        if alt_velocities:
+            velocity -= (i % 2)
+
+        if channel == cha:
+
+          for t in range(time, min(time + duration, time_range)):
+
+            escore_matrix[t][pitch] = [velocity, patch]
+
+        pe = note
+
+    if flip_matrix:
+
+      temp_matrix = []
+
+      for m in escore_matrix:
+        temp_matrix.append(m[::-1])
+
+      escore_matrix = temp_matrix
+
+    if reverse_matrix:
+      escore_matrix = escore_matrix[::-1]
+
+    escore_matrixes.append(escore_matrix)
+
+  return [channels_list, escore_matrixes]
+
+###################################################################################
+
+def escore_matrix_to_merged_escore_notes(full_escore_matrix,
+                                        max_note_duration=4000
+                                        ):
+
+  merged_escore_notes = []
+
+  mat_channels_list = full_escore_matrix[0]
+  
+  for m, cha in enumerate(mat_channels_list):
+
+    escore_matrix = full_escore_matrix[1][m]
+
+    result = []
+
+    for j in range(len(escore_matrix[0])):
+
+        count = 1
+
+        for i in range(1, len(escore_matrix)):
+
+          if escore_matrix[i][j] != [-1, -1] and escore_matrix[i][j][1] == escore_matrix[i-1][j][1] and count < max_note_duration:
+              count += 1
+
+          else:
+              if count > 1:  
+                result.append([i-count, count, j, escore_matrix[i-1][j]])
+
+              count = 1
+
+        if count > 1:
+            result.append([len(escore_matrix)-count, count, j, escore_matrix[-1][j]])
+
+    result.sort(key=lambda x: (x[0], -x[2]))
+
+    for r in result:
+      merged_escore_notes.append(['note', r[0], r[1], cha, r[2], r[3][0], r[3][1]])
+
+  return sorted(merged_escore_notes, key=lambda x: (x[1], -x[4], x[6]))
+
+###################################################################################
+
+def escore_matrix_to_original_escore_notes(full_escore_matrix):
+
+  merged_escore_notes = []
+
+  mat_channels_list = full_escore_matrix[0]
+
+  for m, cha in enumerate(mat_channels_list):
+
+    escore_matrix = full_escore_matrix[1][m]
+
+    result = []
+
+    for j in range(len(escore_matrix[0])):
+
+        count = 1
+
+        for i in range(1, len(escore_matrix)):
+
+          if escore_matrix[i][j] != [-1, -1] and escore_matrix[i][j] == escore_matrix[i-1][j]:
+              count += 1
+
+          else:
+              if count > 1:
+                result.append([i-count, count, j, escore_matrix[i-1][j]])
+
+              count = 1
+
+        if count > 1:
+            result.append([len(escore_matrix)-count, count, j, escore_matrix[-1][j]])
+
+    result.sort(key=lambda x: (x[0], -x[2]))
+
+    for r in result:
+      merged_escore_notes.append(['note', r[0], r[1], cha, r[2], r[3][0], r[3][1]])
+
+  return sorted(merged_escore_notes, key=lambda x: (x[1], -x[4], x[6]))
+
+###################################################################################
+
+def escore_notes_to_binary_matrix(escore_notes, 
+                                  channel=0, 
+                                  patch=0,
+                                  flip_matrix=False,
+                                  reverse_matrix=False
+                                  ):
+
+  escore = [e for e in escore_notes if e[3] == channel and e[6] == patch]
+
+  if escore:
+    last_time = escore[-1][1]
+    last_notes = [e for e in escore if e[1] == last_time]
+    max_last_dur = max([e[2] for e in last_notes])
+
+    time_range = last_time+max_last_dur
+
+    escore_matrix = []
+
+    escore_matrix = [[0] * 128 for _ in range(time_range)]
+
+    for note in escore:
+
+        etype, time, duration, chan, pitch, velocity, pat = note
+
+        time = max(0, time)
+        duration = max(1, duration)
+        chan = max(0, min(15, chan))
+        pitch = max(0, min(127, pitch))
+        velocity = max(0, min(127, velocity))
+        pat = max(0, min(128, pat))
+
+        if channel == chan and patch == pat:
+
+          for t in range(time, min(time + duration, time_range)):
+
+            escore_matrix[t][pitch] = 1
 
+    if flip_matrix:
+
+      temp_matrix = []
+
+      for m in escore_matrix:
+        temp_matrix.append(m[::-1])
+
+      escore_matrix = temp_matrix
+
+    if reverse_matrix:
+      escore_matrix = escore_matrix[::-1]
+
+    return escore_matrix
+
+  else:
+    return None
+
+###################################################################################
+
+def binary_matrix_to_original_escore_notes(binary_matrix, 
+                                           channel=0, 
+                                           patch=0, 
+                                           velocity=-1
+                                           ):
+
+  result = []
+
+  for j in range(len(binary_matrix[0])):
+
+      count = 1
+
+      for i in range(1, len(binary_matrix)):
+
+        if binary_matrix[i][j] != 0 and binary_matrix[i][j] == binary_matrix[i-1][j]:
+            count += 1
+
+        else:
+          if count > 1:
+            result.append([i-count, count, j, binary_matrix[i-1][j]])
+          
+          else:
+            if binary_matrix[i-1][j] != 0:
+              result.append([i-count, count, j, binary_matrix[i-1][j]])
+
+          count = 1
+
+      if count > 1:
+          result.append([len(binary_matrix)-count, count, j, binary_matrix[-1][j]])
+      
+      else:
+        if binary_matrix[i-1][j] != 0:
+          result.append([i-count, count, j, binary_matrix[i-1][j]])
+
+  result.sort(key=lambda x: (x[0], -x[2]))
+
+  original_escore_notes = []
+
+  vel = velocity
+
+  for r in result:
+    
+    if velocity == -1:
+      vel = max(40, r[2])
+
+    original_escore_notes.append(['note', r[0], r[1], channel, r[2], vel, patch])
+
+  return sorted(original_escore_notes, key=lambda x: (x[1], -x[4], x[6]))
+
+###################################################################################
+
+def escore_notes_averages(escore_notes, 
+                          times_index=1, 
+                          durs_index=2,
+                          chans_index=3, 
+                          ptcs_index=4, 
+                          vels_index=5,
+                          average_drums=False,
+                          score_is_delta=False,
+                          return_ptcs_and_vels=False
+                          ):
+  
+  if score_is_delta:
+    if average_drums:
+      times = [e[times_index] for e in escore_notes if e[times_index] != 0]
+    else:
+      times = [e[times_index] for e in escore_notes if e[times_index] != 0 and e[chans_index] != 9]
+
+  else:
+    descore_notes = delta_score_notes(escore_notes)
+    if average_drums:
+      times = [e[times_index] for e in descore_notes if e[times_index] != 0]
+    else:
+      times = [e[times_index] for e in descore_notes if e[times_index] != 0 and e[chans_index] != 9]
+      
+  if average_drums:
+    durs = [e[durs_index] for e in escore_notes]
+  else:
+    durs = [e[durs_index] for e in escore_notes if e[chans_index] != 9]
+
+  if return_ptcs_and_vels:
+    if average_drums:
+      ptcs = [e[ptcs_index] for e in escore_notes]
+      vels = [e[vels_index] for e in escore_notes]
+    else:
+      ptcs = [e[ptcs_index] for e in escore_notes if e[chans_index] != 9]
+      vels = [e[vels_index] for e in escore_notes if e[chans_index] != 9]      
+
+    return [sum(times) / len(times), sum(durs) / len(durs), sum(ptcs) / len(ptcs), sum(vels) / len(vels)]
+  
+  else:
+    return [sum(times) / len(times), sum(durs) / len(durs)]
+
+###################################################################################
+
+def adjust_escore_notes_timings(escore_notes, 
+                                adj_k=1, 
+                                times_index=1, 
+                                durs_index=2, 
+                                score_is_delta=False, 
+                                return_delta_scpre=False
+                                ):
+
+  if score_is_delta:
+    adj_escore_notes = copy.deepcopy(escore_notes)
+  else:
+    adj_escore_notes = delta_score_notes(escore_notes)
+
+  for e in adj_escore_notes:
+
+    if e[times_index] != 0:
+      e[times_index] = max(1, round(e[times_index] * adj_k))
+
+    e[durs_index] = max(1, round(e[durs_index] * adj_k))
+
+  if return_delta_scpre:
+    return adj_escore_notes
+
+  else:
+    return delta_score_to_abs_score(adj_escore_notes)
+
+###################################################################################
+
+def escore_notes_delta_times(escore_notes,
+                             times_index=1
+                             ):
+
+  descore_notes = delta_score_notes(escore_notes)
+
+  return [e[times_index] for e in descore_notes]
+
+###################################################################################
+
+def escore_notes_durations(escore_notes,
+                            durs_index=1
+                            ):
+
+  descore_notes = delta_score_notes(escore_notes)
+
+  return [e[durs_index] for e in descore_notes]
+
+###################################################################################
+
+def ordered_lists_match_ratio(src_list, trg_list):
+
+  zlist = list(zip(src_list, trg_list))
+
+  return sum([a == b for a, b in zlist]) / len(list(zlist))
+
+###################################################################################
+
+def lists_intersections(src_list, trg_list):
+  return list(set(src_list) & set(trg_list))
+
+###################################################################################
+
+def transpose_escore_notes(escore_notes, 
+                            transpose_value=0, 
+                            channel_index=3, 
+                            pitches_index=4
+                            ):
+
+  tr_escore_notes = copy.deepcopy(escore_notes)
+
+  for e in tr_escore_notes:
+    if e[channel_index] != 9:
+      e[pitches_index] = max(1, min(127, e[pitches_index] + transpose_value))
+
+  return tr_escore_notes
+
+###################################################################################
+
+def transpose_escore_notes_to_pitch(escore_notes, 
+                                    target_pitch_value=60, 
+                                    channel_index=3, 
+                                    pitches_index=4
+                                    ):
+
+  tr_escore_notes = copy.deepcopy(escore_notes)
+
+  transpose_delta = int(round(target_pitch_value)) - int(round(escore_notes_averages(escore_notes, return_ptcs_and_vels=True)[2]))
+
+  for e in tr_escore_notes:
+    if e[channel_index] != 9:
+      e[pitches_index] = max(1, min(127, e[pitches_index] + transpose_delta))
+
+  return tr_escore_notes
+
+###################################################################################
+
+CHORDS_TYPES = ['WHITE', 'BLACK', 'UNKNOWN', 'MIXED WHITE', 'MIXED BLACK', 'MIXED GRAY']
+
+###################################################################################
+
+def tones_chord_type(tones_chord, 
+                     return_chord_type_index=True,
+                     use_filtered_chords=True
+                     ):
+
+  WN = WHITE_NOTES
+  BN = BLACK_NOTES
+  MX = WHITE_NOTES + BLACK_NOTES
+
+  if use_filtered_chords:
+    CHORDS = ALL_CHORDS_FILTERED
+  
+  else:
+    CHORDS = ALL_CHORDS_SORTED
+
+  tones_chord = sorted(tones_chord)
+
+  ctype = 'UNKNOWN'
+
+  if tones_chord in CHORDS:
+
+    if sorted(set(tones_chord) & set(WN)) == tones_chord:
+      ctype = 'WHITE'
+
+    elif sorted(set(tones_chord) & set(BN)) == tones_chord:
+      ctype = 'BLACK'
+
+    if len(tones_chord) > 1 and sorted(set(tones_chord) & set(MX)) == tones_chord:
+
+      if len(sorted(set(tones_chord) & set(WN))) == len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED GRAY'
+
+      elif len(sorted(set(tones_chord) & set(WN))) > len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED WHITE'
+
+      elif len(sorted(set(tones_chord) & set(WN))) < len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED BLACK'
+
+  if return_chord_type_index:
+    return CHORDS_TYPES.index(ctype)
+
+  else:
+    return ctype
+
+###################################################################################
+
+def tone_type(tone, 
+              return_tone_type_index=True
+              ):
+
+  tone = tone % 12
+
+  if tone in BLACK_NOTES:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('BLACK')
+    else:
+      return "BLACK"
+
+  else:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('WHITE')
+    else:
+      return "WHITE"
+
+###################################################################################
+
+def lists_sym_differences(src_list, trg_list):
+  return list(set(src_list) ^ set(trg_list))
+
+###################################################################################
+
+def lists_differences(long_list, short_list):
+  return list(set(long_list) - set(short_list))
+
+###################################################################################
+
+def find_best_tones_chord(src_tones_chords,
+                          trg_tones_chords,
+                          find_longest=True
+                          ):
+
+  not_seen_trg_chords = []
+
+  max_len = 0
+
+  for tc in trg_tones_chords:
+    if sorted(tc) in src_tones_chords:
+      not_seen_trg_chords.append(sorted(tc))
+      max_len = max(max_len, len(tc))
+
+  if not not_seen_trg_chords:
+    max_len = len(max(trg_tones_chords, key=len))
+    not_seen_trg_chords = trg_tones_chords
+
+  if find_longest:
+    return random.choice([c for c in not_seen_trg_chords if len(c) == max_len])
+
+  else:
+    return random.choice(not_seen_trg_chords)
+
+###################################################################################
+
+def find_matching_tones_chords(tones_chord,
+                               matching_chord_length=-1,
+                               match_chord_type=True,
+                               use_filtered_chords=True
+                               ):
+
+  if use_filtered_chords:
+    CHORDS = ALL_CHORDS_FILTERED
+  else:
+    CHORDS = ALL_CHORDS_SORTED
+
+  tones_chord = sorted(tones_chord)
+
+  tclen = len(tones_chord)
+
+  tctype = tones_chord_type(tones_chord, use_filtered_chords=use_filtered_chords)
+
+  matches = []
+
+  for tc in CHORDS:
+
+    if matching_chord_length == -1:
+      if len(tc) > tclen:
+        if sorted(lists_intersections(tc, tones_chord)) == tones_chord:
+          if match_chord_type:
+            if tones_chord_type(tc, use_filtered_chords=use_filtered_chords) == tctype:
+              tcdiffs = lists_differences(tc, tones_chord)
+              if all(tone_type(d) == tctype % 3 for d in tcdiffs):
+                matches.append(tc)
+          else:
+            matches.append(tc)
+
+    else:
+
+      if len(tc) == max(tclen, matching_chord_length):
+        if sorted(lists_intersections(tc, tones_chord)) == tones_chord:
+          if match_chord_type:
+            if tones_chord_type(tc, use_filtered_chords=use_filtered_chords) == tctype:
+              tcdiffs = lists_differences(tc, tones_chord)
+              if all(tone_type(d) == tctype % 3 for d in tcdiffs):
+                matches.append(tc)
+          else:
+            matches.append(tc)
+
+  return sorted(matches, key=len)
+
+###################################################################################
+
+def adjust_list_of_values_to_target_average(list_of_values, 
+                                            trg_avg, 
+                                            min_value, 
+                                            max_value
+                                            ):
+
+    filtered_values = [value for value in list_of_values if min_value <= value <= max_value]
+
+    if not filtered_values:
+        return list_of_values
+
+    current_avg = sum(filtered_values) / len(filtered_values)
+    scale_factor = trg_avg / current_avg
+
+    adjusted_values = [value * scale_factor for value in filtered_values]
+
+    total_difference = trg_avg * len(filtered_values) - sum(adjusted_values)
+    adjustment_per_value = total_difference / len(filtered_values)
+
+    final_values = [value + adjustment_per_value for value in adjusted_values]
+
+    while abs(sum(final_values) / len(final_values) - trg_avg) > 1e-6:
+        total_difference = trg_avg * len(final_values) - sum(final_values)
+        adjustment_per_value = total_difference / len(final_values)
+        final_values = [value + adjustment_per_value for value in final_values]
+
+    final_values = [round(value) for value in final_values]
+
+    adjusted_values = copy.deepcopy(list_of_values)
+
+    j = 0
+
+    for i in range(len(adjusted_values)):
+        if min_value <= adjusted_values[i] <= max_value:
+            adjusted_values[i] = final_values[j]
+            j += 1
+
+    return adjusted_values
+
+###################################################################################
+
+def adjust_escore_notes_to_average(escore_notes,
+                                   trg_avg,
+                                   min_value=1,
+                                   max_value=4000,
+                                   times_index=1,
+                                   durs_index=2,
+                                   score_is_delta=False,
+                                   return_delta_scpre=False
+                                   ):
+    if score_is_delta:
+      delta_escore_notes = copy.deepcopy(escore_notes)
+
+    else:
+      delta_escore_notes = delta_score_notes(escore_notes)
+
+    times = [[e[times_index], e[durs_index]] for e in delta_escore_notes]
+
+    filtered_values = [value for value in times if min_value <= value[0] <= max_value]
+
+    if not filtered_values:
+        return escore_notes
+
+    current_avg = sum([v[0] for v in filtered_values]) / len([v[0] for v in filtered_values])
+    scale_factor = trg_avg / current_avg
+
+    adjusted_values = [[value[0] * scale_factor, value[1] * scale_factor] for value in filtered_values]
+
+    total_difference = trg_avg * len([v[0] for v in filtered_values]) - sum([v[0] for v in adjusted_values])
+    adjustment_per_value = total_difference / len(filtered_values)
+
+    final_values = [[value[0] + adjustment_per_value, value[1] + adjustment_per_value] for value in adjusted_values]
+
+    while abs(sum([v[0] for v in final_values]) / len(final_values) - trg_avg) > 1e-6:
+        total_difference = trg_avg * len(final_values) - sum([v[0] for v in final_values])
+        adjustment_per_value = total_difference / len(final_values)
+        final_values = [[value[0] + adjustment_per_value, value[1] + adjustment_per_value] for value in final_values]
+
+    final_values = [[round(value[0]), round(value[1])] for value in final_values]
+
+    adjusted_delta_score = copy.deepcopy(delta_escore_notes)
+
+    j = 0
+
+    for i in range(len(adjusted_delta_score)):
+        if min_value <= adjusted_delta_score[i][1] <= max_value:
+            adjusted_delta_score[i][times_index] = final_values[j][0]
+            adjusted_delta_score[i][durs_index] = final_values[j][1]
+            j += 1
+
+    adjusted_escore_notes = delta_score_to_abs_score(adjusted_delta_score)
+
+    if return_delta_scpre:
+      return adjusted_delta_score
+
+    else:
+      return adjusted_escore_notes
+
+###################################################################################
+
+def harmonize_enhanced_melody_score_notes_to_ms_SONG(escore_notes,
+                                                      melody_velocity=-1,
+                                                      melody_channel=3,
+                                                      melody_patch=40,
+                                                      melody_base_octave=4,
+                                                      harmonized_tones_chords_velocity=-1,
+                                                      harmonized_tones_chords_channel=0,
+                                                      harmonized_tones_chords_patch=0
+                                                    ):
+
+  harmonized_tones_chords = harmonize_enhanced_melody_score_notes(escore_notes)
+
+  harm_escore_notes = []
+
+  time = 0
+
+  for i, note in enumerate(escore_notes):
+
+    time = note[1]
+    dur = note[2]
+    ptc = note[4]
+
+    if melody_velocity == -1:
+      vel = int(110 + ((ptc % 12) * 1.5))
+    else:
+      vel = melody_velocity
+
+    harm_escore_notes.append(['note', time, dur, melody_channel, ptc, vel, melody_patch])
+
+    for t in harmonized_tones_chords[i]:
+
+      ptc = (melody_base_octave * 12) + t
+
+      if harmonized_tones_chords_velocity == -1:
+        vel = int(80 + ((ptc % 12) * 1.5))
+      else:
+        vel = harmonized_tones_chords_velocity
+
+      harm_escore_notes.append(['note', time, dur, harmonized_tones_chords_channel, ptc, vel, harmonized_tones_chords_patch])
+
+  return sorted(harm_escore_notes, key=lambda x: (x[1], -x[4], x[6]))
+
+###################################################################################
+
+def check_and_fix_pitches_chord(pitches_chord,
+                                use_filtered_chords=True
+                                ):
+  
+  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 tones_chord not in CHORDS:
+
+    if len(tones_chord) == 2:
+
+      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 len(tones_chord) > 2:
+
+      tones_chord_combs = [list(comb) for i in range(len(tones_chord)-2, 0, -1) for comb in combinations(tones_chord, i+1)]
+
+      for co in tones_chord_combs:
+        if co in CHORDS:
+          tones_chord = co
+          break
+
+  new_pitches_chord = []
+
+  for p in pitches_chord:
+
+    if p % 12 in tones_chord:
+      new_pitches_chord.append(p)
+
+  return sorted(new_pitches_chord, reverse=True)
+
+###################################################################################
+
+ALL_CHORDS_TRANS = [[0], [0, 4], [0, 4, 7], [0, 4, 8], [0, 5], [0, 6], [0, 7], [0, 8], [1], [1, 5],
+                    [1, 5, 9], [1, 6], [1, 7], [1, 8], [1, 9], [2], [2, 6], [2, 6, 10], [2, 7],
+                    [2, 8], [2, 9], [2, 10], [3], [3, 7], [3, 7, 11], [3, 8], [3, 9], [3, 10],
+                    [3, 11], [4], [4, 7], [4, 7, 11], [4, 8], [4, 9], [4, 10], [4, 11], [5],
+                    [5, 9], [5, 10], [5, 11], [6], [6, 10], [6, 11], [7], [7, 11], [8], [9], [10],
+                    [11]]
+
+###################################################################################
+
+def minkowski_distance(x, y, p=3, pad_value=float('inf')):
+
+    if len(x) != len(y):
+      return -1
+    
+    distance = 0
+    
+    for i in range(len(x)):
+
+        if x[i] == pad_value or y[i] == pad_value:
+          continue
+
+        distance += abs(x[i] - y[i]) ** p
+
+    return distance ** (1 / p)
+
+###################################################################################
+
+def dot_product(x, y, pad_value=None):
+    return sum(xi * yi for xi, yi in zip(x, y) if xi != pad_value and yi != pad_value)
+
+def norm(vector, pad_value=None):
+    return sum(xi ** 2 for xi in vector if xi != pad_value) ** 0.5
+
+def cosine_similarity(x, y, pad_value=None):
+    if len(x) != len(y):
+        return -1
+    
+    dot_prod = dot_product(x, y, pad_value)
+    norm_x = norm(x, pad_value)
+    norm_y = norm(y, pad_value)
+    
+    if norm_x == 0 or norm_y == 0:
+        return 0.0
+    
+    return dot_prod / (norm_x * norm_y)
+
+###################################################################################
+
+def hamming_distance(arr1, arr2, pad_value):
+    return sum(el1 != el2 for el1, el2 in zip(arr1, arr2) if el1 != pad_value and el2 != pad_value)
+
+###################################################################################
+
+def jaccard_similarity(arr1, arr2, pad_value):
+    intersection = sum(el1 and el2 for el1, el2 in zip(arr1, arr2) if el1 != pad_value and el2 != pad_value)
+    union = sum((el1 or el2) for el1, el2 in zip(arr1, arr2) if el1 != pad_value or el2 != pad_value)
+    return intersection / union if union != 0 else 0
+
+###################################################################################
+
+def pearson_correlation(arr1, arr2, pad_value):
+    filtered_pairs = [(el1, el2) for el1, el2 in zip(arr1, arr2) if el1 != pad_value and el2 != pad_value]
+    if not filtered_pairs:
+        return 0
+    n = len(filtered_pairs)
+    sum1 = sum(el1 for el1, el2 in filtered_pairs)
+    sum2 = sum(el2 for el1, el2 in filtered_pairs)
+    sum1_sq = sum(el1 ** 2 for el1, el2 in filtered_pairs)
+    sum2_sq = sum(el2 ** 2 for el1, el2 in filtered_pairs)
+    p_sum = sum(el1 * el2 for el1, el2 in filtered_pairs)
+    num = p_sum - (sum1 * sum2 / n)
+    den = ((sum1_sq - sum1 ** 2 / n) * (sum2_sq - sum2 ** 2 / n)) ** 0.5
+    if den == 0:
+        return 0
+    return num / den
+
+###################################################################################
+
+def calculate_combined_distances(array_of_arrays,
+                                  combine_hamming_distance=True,
+                                  combine_jaccard_similarity=True, 
+                                  combine_pearson_correlation=True,
+                                  pad_value=None
+                                  ):
+
+  binary_arrays = array_of_arrays
+  binary_array_len = len(binary_arrays)
+
+  hamming_distances = [[0] * binary_array_len for _ in range(binary_array_len)]
+  jaccard_similarities = [[0] * binary_array_len for _ in range(binary_array_len)]
+  pearson_correlations = [[0] * binary_array_len for _ in range(binary_array_len)]
+
+  for i in range(binary_array_len):
+      for j in range(i + 1, binary_array_len):
+          hamming_distances[i][j] = hamming_distance(binary_arrays[i], binary_arrays[j], pad_value)
+          hamming_distances[j][i] = hamming_distances[i][j]
+          
+          jaccard_similarities[i][j] = jaccard_similarity(binary_arrays[i], binary_arrays[j], pad_value)
+          jaccard_similarities[j][i] = jaccard_similarities[i][j]
+          
+          pearson_correlations[i][j] = pearson_correlation(binary_arrays[i], binary_arrays[j], pad_value)
+          pearson_correlations[j][i] = pearson_correlations[i][j]
+
+  max_hamming = max(max(row) for row in hamming_distances)
+  min_hamming = min(min(row) for row in hamming_distances)
+  normalized_hamming = [[(val - min_hamming) / (max_hamming - min_hamming) for val in row] for row in hamming_distances]
+
+  max_jaccard = max(max(row) for row in jaccard_similarities)
+  min_jaccard = min(min(row) for row in jaccard_similarities)
+  normalized_jaccard = [[(val - min_jaccard) / (max_jaccard - min_jaccard) for val in row] for row in jaccard_similarities]
+
+  max_pearson = max(max(row) for row in pearson_correlations)
+  min_pearson = min(min(row) for row in pearson_correlations)
+  normalized_pearson = [[(val - min_pearson) / (max_pearson - min_pearson) for val in row] for row in pearson_correlations]
+
+  selected_metrics = 0
+
+  if combine_hamming_distance:
+    selected_metrics += normalized_hamming[i][j]
+  
+  if combine_jaccard_similarity:
+    selected_metrics += (1 - normalized_jaccard[i][j])
+
+  if combine_pearson_correlation:
+    selected_metrics += (1 - normalized_pearson[i][j])
+
+  combined_metric = [[selected_metrics for i in range(binary_array_len)] for j in range(binary_array_len)]
+
+  return combined_metric
+
+###################################################################################
+
+def tones_chords_to_bits(tones_chords):
+
+  bits_tones_chords = []
+
+  for c in tones_chords:
+
+    c.sort()
+
+    bits = tones_chord_to_bits(c)
+
+    bits_tones_chords.append(bits)
+
+  return bits_tones_chords
+
+###################################################################################
+
+def tones_chords_to_ints(tones_chords):
+
+  ints_tones_chords = []
+
+  for c in tones_chords:
+
+    c.sort()
+
+    bits = tones_chord_to_bits(c)
+
+    number = bits_to_int(bits)
+
+    ints_tones_chords.append(number)
+
+  return ints_tones_chords
+
+###################################################################################
+
+def tones_chords_to_types(tones_chords, 
+                          return_chord_type_index=False
+                          ):
+
+  types_tones_chords = []
+
+  for c in tones_chords:
+
+    c.sort()
+
+    ctype = tones_chord_type(c, return_chord_type_index=return_chord_type_index)
+
+    types_tones_chords.append(ctype)
+
+  return types_tones_chords
+
+###################################################################################
+
+def morph_tones_chord(tones_chord, 
+                      trg_tone, 
+                      use_filtered_chords=True
+                      ):
+
+  src_tones_chord = sorted(sorted(set(tones_chord)) + [trg_tone])
+
+  combs = [list(comb) for i in range(len(src_tones_chord), 0, -1) for comb in combinations(src_tones_chord, i) if trg_tone in list(comb)]
+
+  matches = []
+
+  if use_filtered_chords:
+    CHORDS = ALL_CHORDS_FILTERED
+  
+  else:
+    CHORDS = ALL_CHORDS_SORTED
+
+  for c in combs:
+    if sorted(set(c)) in CHORDS:
+      matches.append(sorted(set(c)))
+
+  max_len = len(max(matches, key=len))
+
+  return random.choice([m for m in matches if len(m) == max_len])
+
+###################################################################################
+
+def compress_binary_matrix(binary_matrix, 
+                           only_compress_zeros=False,
+                           return_compression_ratio=False
+                           ):
+
+  compressed_bmatrix = []
+
+  zm = [0] * len(binary_matrix[0])
+  pm = [0] * len(binary_matrix[0])
+
+  mcount = 0
+
+  for m in binary_matrix:
+    
+    if only_compress_zeros:
+      if m != zm:
+        compressed_bmatrix.append(m)
+        mcount += 1
+    
+    else:
+      if m != pm:
+        compressed_bmatrix.append(m)
+        mcount += 1
+    
+    pm = m
+
+  if return_compression_ratio:
+    return [compressed_bmatrix, mcount / len(binary_matrix)]
+
+  else:
+    return compressed_bmatrix
+
+###################################################################################
+
+def solo_piano_escore_notes(escore_notes,
+                            channels_index=3,
+                            pitches_index=4,
+                            patches_index=6,
+                            keep_drums=False,
+                            ):
+
+  cscore = chordify_score([1000, escore_notes])
+
+  sp_escore_notes = []
+
+  for c in cscore:
+
+    seen = []
+    chord = []
+
+    for cc in c:
+      if cc[pitches_index] not in seen:
+
+          if cc[channels_index] != 9:
+            cc[channels_index] = 0
+            cc[patches_index] = 0
+            
+            chord.append(cc)
+            seen.append(cc[pitches_index])
+          
+          else:
+            if keep_drums:
+              chord.append(cc)
+              seen.append(cc[pitches_index])
+
+    sp_escore_notes.append(chord)
+
+  return flatten(sp_escore_notes)
+
+###################################################################################
+
+def strip_drums_from_escore_notes(escore_notes, 
+                                  channels_index=3
+                                  ):
+  
+  return [e for e in escore_notes if e[channels_index] != 9]
+
+###################################################################################
+
+def fixed_escore_notes_timings(escore_notes,
+                               fixed_durations=False,
+                               fixed_timings_multiplier=1,
+                               custom_fixed_time=-1,
+                               custom_fixed_dur=-1
+                               ):
+
+  fixed_timings_escore_notes = delta_score_notes(escore_notes, even_timings=True)
+
+  mode_time = round(Counter([e[1] for e in fixed_timings_escore_notes if e[1] != 0]).most_common()[0][0] * fixed_timings_multiplier)
+
+  if mode_time % 2 != 0:
+    mode_time += 1
+
+  mode_dur = round(Counter([e[2] for e in fixed_timings_escore_notes if e[2] != 0]).most_common()[0][0] * fixed_timings_multiplier)
+
+  if mode_dur % 2 != 0:
+    mode_dur += 1
+
+  for e in fixed_timings_escore_notes:
+    if e[1] != 0:
+      
+      if custom_fixed_time > 0:
+        e[1] = custom_fixed_time
+      
+      else:
+        e[1] = mode_time
+
+    if fixed_durations:
+      
+      if custom_fixed_dur > 0:
+        e[2] = custom_fixed_dur
+      
+      else:
+        e[2] = mode_dur
+
+  return delta_score_to_abs_score(fixed_timings_escore_notes)
+
+###################################################################################
+
+def cubic_kernel(x):
+    abs_x = abs(x)
+    if abs_x <= 1:
+        return 1.5 * abs_x**3 - 2.5 * abs_x**2 + 1
+    elif abs_x <= 2:
+        return -0.5 * abs_x**3 + 2.5 * abs_x**2 - 4 * abs_x + 2
+    else:
+        return 0
+
+###################################################################################
+
+def resize_matrix(matrix, new_height, new_width):
+    old_height = len(matrix)
+    old_width = len(matrix[0])
+    resized_matrix = [[0] * new_width for _ in range(new_height)]
+    
+    for i in range(new_height):
+        for j in range(new_width):
+            old_i = i * old_height / new_height
+            old_j = j * old_width / new_width
+            
+            value = 0
+            total_weight = 0
+            for m in range(-1, 3):
+                for n in range(-1, 3):
+                    i_m = min(max(int(old_i) + m, 0), old_height - 1)
+                    j_n = min(max(int(old_j) + n, 0), old_width - 1)
+                    
+                    if matrix[i_m][j_n] == 0:
+                        continue
+                    
+                    weight = cubic_kernel(old_i - i_m) * cubic_kernel(old_j - j_n)
+                    value += matrix[i_m][j_n] * weight
+                    total_weight += weight
+            
+            if total_weight > 0:
+                value /= total_weight
+            
+            resized_matrix[i][j] = int(value > 0.5)
+    
+    return resized_matrix
+
+###################################################################################
+
+def square_binary_matrix(binary_matrix, 
+                         matrix_size=128,
+                         use_fast_squaring=False,
+                         return_plot_points=False
+                         ):
+
+  if use_fast_squaring:
+
+    step = round(len(binary_matrix) / matrix_size)
+
+    samples = []
+
+    for i in range(0, len(binary_matrix), step):
+      samples.append(tuple([tuple(d) for d in binary_matrix[i:i+step]]))
+
+    resized_matrix = []
+
+    zmatrix = [[0] * matrix_size]
+
+    for s in samples:
+
+      samples_counts = Counter(s).most_common()
+
+      best_sample = tuple([0] * matrix_size)
+      pm = tuple(zmatrix[0])
+
+      for sc in samples_counts:
+        if sc[0] != tuple(zmatrix[0]) and sc[0] != pm:
+          best_sample = sc[0]
+          pm = sc[0]
+          break
+        
+        pm = sc[0]
+
+      resized_matrix.append(list(best_sample))
+
+    resized_matrix = resized_matrix[:matrix_size]
+    resized_matrix += zmatrix * (matrix_size - len(resized_matrix))
+    
+  else:
+    resized_matrix = resize_matrix(binary_matrix, matrix_size, matrix_size)
+
+  points = [(i, j) for i in range(matrix_size) for j in range(matrix_size) if resized_matrix[i][j] == 1]
+
+  if return_plot_points:
+    return [resized_matrix, points]
+
+  else:
+    return resized_matrix
+
+###################################################################################
+
+def mean(matrix):
+    return sum(sum(row) for row in matrix) / (len(matrix) * len(matrix[0]))
+
+###################################################################################
+
+def variance(matrix, mean_value):
+    return sum(sum((element - mean_value) ** 2 for element in row) for row in matrix) / (len(matrix) * len(matrix[0]))
+    
+###################################################################################
+
+def covariance(matrix1, matrix2, mean1, mean2):
+    return sum(sum((matrix1[i][j] - mean1) * (matrix2[i][j] - mean2) for j in range(len(matrix1[0]))) for i in range(len(matrix1))) / (len(matrix1) * len(matrix1[0]))
+
+###################################################################################
+
+def ssim_index(matrix1, matrix2, bit_depth=1):
+
+    if len(matrix1) != len(matrix2) and len(matrix1[0]) != len(matrix2[0]):
+      return -1
+
+    K1, K2 = 0.01, 0.03
+    L = bit_depth
+    C1 = (K1 * L) ** 2
+    C2 = (K2 * L) ** 2
+    
+    mu1 = mean(matrix1)
+    mu2 = mean(matrix2)
+    
+    sigma1_sq = variance(matrix1, mu1)
+    sigma2_sq = variance(matrix2, mu2)
+    
+    sigma12 = covariance(matrix1, matrix2, mu1, mu2)
+    
+    ssim = ((2 * mu1 * mu2 + C1) * (2 * sigma12 + C2)) / ((mu1 ** 2 + mu2 ** 2 + C1) * (sigma1_sq + sigma2_sq + C2))
+    
+    return ssim
+
+###################################################################################
+
+def find_most_similar_matrix(array_of_matrices, 
+                             trg_matrix,
+                             matrices_bit_depth=1,
+                             return_most_similar_index=False
+                             ):
+   
+    max_ssim = -float('inf')
+    most_similar_index = -1
+
+    for i, matrix in enumerate(array_of_matrices):
+
+        ssim = ssim_index(matrix, trg_matrix, bit_depth=matrices_bit_depth)
+        
+        if ssim > max_ssim:
+            max_ssim = ssim
+            most_similar_index = i
+    
+    if return_most_similar_index:
+      return most_similar_index
+    
+    else:
+      return array_of_matrices[most_similar_index]
+
+###################################################################################
+
+def chord_to_pchord(chord):
+
+  pchord = []
+
+  for cc in chord:
+    if cc[3] != 9:
+      pchord.append(cc[4])
+
+  return pchord
+
+###################################################################################
+
+def summarize_escore_notes(escore_notes, 
+                           summary_length_in_chords=128, 
+                           preserve_timings=True,
+                           preserve_durations=False,
+                           time_threshold=12,
+                           min_sum_chord_len=2,
+                           use_tones_chords=True
+                           ):
+
+    cscore = chordify_score([d[1:] for d in delta_score_notes(escore_notes)])
+
+    summary_length_in_chords = min(len(cscore), summary_length_in_chords)
+
+    ltthresh = time_threshold // 2
+    uttresh = time_threshold * 2
+
+    mc_time = Counter([c[0][0] for c in cscore if c[0][2] != 9 and ltthresh < c[0][0] < uttresh]).most_common()[0][0]
+
+    pchords = []
+
+    for c in cscore:
+      if use_tones_chords:
+        pchords.append([c[0][0]] + pitches_to_tones_chord(chord_to_pchord(c)))
+        
+      else:
+        pchords.append([c[0][0]] + chord_to_pchord(c))
+
+    step = round(len(pchords) / summary_length_in_chords)
+
+    samples = []
+
+    for i in range(0, len(pchords), step):
+      samples.append(tuple([tuple(d) for d in pchords[i:i+step]]))
+
+    summarized_escore_notes = []
+
+    for i, s in enumerate(samples):
+
+      best_chord = list([v[0] for v in Counter(s).most_common() if v[0][0] == mc_time and len(v[0]) > min_sum_chord_len])
+
+      if not best_chord:
+        best_chord = list([v[0] for v in Counter(s).most_common() if len(v[0]) > min_sum_chord_len])
+        
+        if not best_chord:
+          best_chord = list([Counter(s).most_common()[0][0]])
+
+      chord = copy.deepcopy(cscore[[ss for ss in s].index(best_chord[0])+(i*step)])
+
+      if preserve_timings:
+
+        if not preserve_durations:
+
+          if i > 0:
+
+            pchord = summarized_escore_notes[-1]
+
+            for pc in pchord:
+              pc[1] = min(pc[1], chord[0][0])
+
+      else:
+
+        chord[0][0] = 1
+
+        for c in chord:
+          c[1] = 1  
+
+      summarized_escore_notes.append(chord)
+
+    summarized_escore_notes = summarized_escore_notes[:summary_length_in_chords]
+
+    return [['note'] + d for d in delta_score_to_abs_score(flatten(summarized_escore_notes), times_idx=0)]
+
+###################################################################################
+
+def compress_patches_in_escore_notes(escore_notes,
+                                     num_patches=4,
+                                     group_patches=False
+                                     ):
+
+  if num_patches > 4:
+    n_patches = 4
+  elif num_patches < 1:
+    n_patches = 1
+  else:
+    n_patches = num_patches
+
+  if group_patches:
+    patches_set = sorted(set([e[6] for e in c]))
+    trg_patch_list = []
+    seen = []
+    for p in patches_set:
+      if p // 8 not in seen:
+        trg_patch_list.append(p)
+        seen.append(p // 8)
+
+    trg_patch_list = sorted(trg_patch_list)
+
+  else:
+    trg_patch_list = sorted(set([e[6] for e in c]))
+
+  if 128 in trg_patch_list and n_patches > 1:
+    trg_patch_list = trg_patch_list[:n_patches-1] + [128]
+  else:
+    trg_patch_list = trg_patch_list[:n_patches]
+
+  new_escore_notes = []
+
+  for e in escore_notes:
+    if e[6] in trg_patch_list:
+      new_escore_notes.append(e)
+
+  return new_escore_notes
+
+###################################################################################
+
+def compress_patches_in_escore_notes_chords(escore_notes,
+                                            max_num_patches_per_chord=4,
+                                            group_patches=True,
+                                            root_grouped_patches=False
+                                            ):
+
+  if max_num_patches_per_chord > 4:
+    n_patches = 4
+  elif max_num_patches_per_chord < 1:
+    n_patches = 1
+  else:
+    n_patches = max_num_patches_per_chord
+
+  cscore = chordify_score([1000, sorted(escore_notes, key=lambda x: (x[1], x[6]))])
+
+  new_escore_notes = []
+
+  for c in cscore:
+
+    if group_patches:
+      patches_set = sorted(set([e[6] for e in c]))
+      trg_patch_list = []
+      seen = []
+      for p in patches_set:
+        if p // 8 not in seen:
+          trg_patch_list.append(p)
+          seen.append(p // 8)
+
+      trg_patch_list = sorted(trg_patch_list)
+
+    else:
+      trg_patch_list = sorted(set([e[6] for e in c]))
+
+    if 128 in trg_patch_list and n_patches > 1:
+      trg_patch_list = trg_patch_list[:n_patches-1] + [128]
+    else:
+      trg_patch_list = trg_patch_list[:n_patches]
+
+    for ccc in c:
+
+      cc = copy.deepcopy(ccc)
+
+      if group_patches:
+        if cc[6] // 8 in [t // 8 for t in trg_patch_list]:
+          if root_grouped_patches:
+            cc[6] = (cc[6] // 8) * 8
+          new_escore_notes.append(cc)
+
+      else:
+        if cc[6] in trg_patch_list:
+          new_escore_notes.append(cc)
+
+  return new_escore_notes
+
+###################################################################################
+
+def escore_notes_to_image_matrix(escore_notes,
+                                  num_img_channels=3,
+                                  filter_out_zero_rows=False,
+                                  filter_out_duplicate_rows=False,
+                                  flip_matrix=False,
+                                  reverse_matrix=False
+                                  ):
+
+  escore_notes = sorted(escore_notes, key=lambda x: (x[1], x[6]))
+
+  if num_img_channels > 1:
+    n_mat_channels = 3
+  else:
+    n_mat_channels = 1
+
+  if escore_notes:
+    last_time = escore_notes[-1][1]
+    last_notes = [e for e in escore_notes if e[1] == last_time]
+    max_last_dur = max([e[2] for e in last_notes])
+
+    time_range = last_time+max_last_dur
+
+    escore_matrix = []
+
+    escore_matrix = [[0] * 128 for _ in range(time_range)]
+
+    for note in escore_notes:
+
+        etype, time, duration, chan, pitch, velocity, pat = note
+
+        time = max(0, time)
+        duration = max(2, duration)
+        chan = max(0, min(15, chan))
+        pitch = max(0, min(127, pitch))
+        velocity = max(0, min(127, velocity))
+        patch = max(0, min(128, pat))
+
+        if chan != 9:
+          pat = patch + 128
+        else:
+          pat = 127
+
+        seen_pats = []
+
+        for t in range(time, min(time + duration, time_range)):
+
+          mat_value = escore_matrix[t][pitch]
+
+          mat_value_0 = (mat_value // (256 * 256)) % 256
+          mat_value_1 = (mat_value // 256) % 256
+
+          cur_num_chans = 0
+
+          if 0 < mat_value < 256 and pat not in seen_pats:
+            cur_num_chans = 1
+          elif 256 < mat_value < (256 * 256) and pat not in seen_pats:
+            cur_num_chans = 2
+
+          if cur_num_chans < n_mat_channels:
+
+            if n_mat_channels == 1:
+
+              escore_matrix[t][pitch] = pat
+              seen_pats.append(pat)
+
+            elif n_mat_channels == 3:
+
+              if cur_num_chans == 0:
+                escore_matrix[t][pitch] = pat
+                seen_pats.append(pat)
+              elif cur_num_chans == 1:
+                escore_matrix[t][pitch] = (256 * 256 * mat_value_0) + (256 * pat)
+                seen_pats.append(pat)
+              elif cur_num_chans == 2:
+                escore_matrix[t][pitch] = (256 * 256 * mat_value_0) + (256 * mat_value_1) + pat
+                seen_pats.append(pat)
+
+    if filter_out_zero_rows:
+      escore_matrix = [e for e in escore_matrix if sum(e) != 0]
+
+    if filter_out_duplicate_rows:
+
+      dd_escore_matrix = []
+
+      pr = [-1] * 128
+      for e in escore_matrix:
+        if e != pr:
+          dd_escore_matrix.append(e)
+          pr = e
+      
+      escore_matrix = dd_escore_matrix
+
+    if flip_matrix:
+
+      temp_matrix = []
+
+      for m in escore_matrix:
+        temp_matrix.append(m[::-1])
+
+      escore_matrix = temp_matrix
+
+    if reverse_matrix:
+      escore_matrix = escore_matrix[::-1]
+
+    return escore_matrix
+
+  else:
+    return None
+
+###################################################################################
+
+def find_value_power(value, number):
+    return math.floor(math.log(value, number))
+
+###################################################################################
+
+def image_matrix_to_original_escore_notes(image_matrix,
+                                          velocity=-1
+                                          ):
+
+  result = []
+
+  for j in range(len(image_matrix[0])):
+
+      count = 1
+
+      for i in range(1, len(image_matrix)):
+
+        if image_matrix[i][j] != 0 and image_matrix[i][j] == image_matrix[i-1][j]:
+            count += 1
+
+        else:
+          if count > 1:
+            result.append([i-count, count, j, image_matrix[i-1][j]])
+
+          else:
+            if image_matrix[i-1][j] != 0:
+              result.append([i-count, count, j, image_matrix[i-1][j]])
+
+          count = 1
+
+      if count > 1:
+          result.append([len(image_matrix)-count, count, j, image_matrix[-1][j]])
+
+      else:
+        if image_matrix[i-1][j] != 0:
+          result.append([i-count, count, j, image_matrix[i-1][j]])
+
+  result.sort(key=lambda x: (x[0], -x[2]))
+
+  original_escore_notes = []
+
+  vel = velocity
+
+  for r in result:
+
+    if velocity == -1:
+      vel = max(40, r[2])
+
+    ptc0 = 0
+    ptc1 = 0
+    ptc2 = 0
+
+    if find_value_power(r[3], 256) == 0:
+      ptc0 = r[3] % 256
+
+    elif find_value_power(r[3], 256) == 1:
+      ptc0 = r[3] // 256
+      ptc1 = (r[3] // 256) % 256
+
+    elif find_value_power(r[3], 256) == 2:
+      ptc0 = (r[3] // 256) // 256
+      ptc1 = (r[3] // 256) % 256
+      ptc2 = r[3] % 256
+
+    ptcs = [ptc0, ptc1, ptc2]
+    patches = [p for p in ptcs if p != 0]
+
+    for i, p in enumerate(patches):
+
+      if p < 128:
+        patch = 128
+        channel = 9
+
+      else:
+        patch = p % 128
+        chan = p // 8
+
+        if chan == 9:
+          chan += 1
+
+        channel = min(15, chan)
+
+      original_escore_notes.append(['note', r[0], r[1], channel, r[2], vel, patch])
+
+  output_score = sorted(original_escore_notes, key=lambda x: (x[1], -x[4], x[6]))
+
+  adjust_score_velocities(output_score, 127)
+
+  return output_score
+
+###################################################################################
+
+def escore_notes_delta_times(escore_notes, 
+                             timings_index=1, 
+                             channels_index=3, 
+                             omit_zeros=False, 
+                             omit_drums=False
+                            ):
+
+  if omit_drums:
+
+    score = [e for e in escore_notes if e[channels_index] != 9]
+    dtimes = [score[0][timings_index]] + [b[timings_index]-a[timings_index] for a, b in zip(score[:-1], score[1:])]
+
+  else:
+    dtimes = [escore_notes[0][timings_index]] + [b[timings_index]-a[timings_index] for a, b in zip(escore_notes[:-1], escore_notes[1:])]
+  
+  if omit_zeros:
+    dtimes = [d for d in dtimes if d != 0]
+  
+  return dtimes
+
+###################################################################################
+
+def monophonic_check(escore_notes, times_index=1):
+  return len(escore_notes) == len(set([e[times_index] for e in escore_notes]))
+
+###################################################################################
+
+def count_escore_notes_patches(escore_notes, patches_index=6):
+  return [list(c) for c in Counter([e[patches_index] for e in escore_notes]).most_common()]
+
+###################################################################################
+
+def escore_notes_medley(list_of_escore_notes, 
+                        list_of_labels=None,
+                        pause_time_value=255
+                        ):
+
+  if list_of_labels is not None:
+    labels = [str(l) for l in list_of_labels] + ['No label'] * (len(list_of_escore_notes)-len(list_of_labels))
+
+  medley = []
+
+  time = 0
+
+  for i, m in enumerate(list_of_escore_notes):
+
+    if list_of_labels is not None:
+      medley.append(['text_event', time, labels[i]])
+
+    pe = m[0]
+
+    for mm in m:
+
+      time += mm[1] - pe[1]
+
+      mmm = copy.deepcopy(mm)
+      mmm[1] = time
+
+      medley.append(mmm)
+
+      pe = mm
+
+    time += pause_time_value
+
+  return medley
+
+###################################################################################
+
+def proportions_counter(list_of_values):
+
+  counts = Counter(list_of_values).most_common()
+  clen = sum([c[1] for c in counts])
+
+  return [[c[0], c[1], c[1] / clen] for c in counts]
+
+###################################################################################
+#  
+# This is the end of the TMIDI X Python module
+#
 ###################################################################################

TPLOTS.py

@@ -0,0 +1,1245 @@
+#! /usr/bin/python3
+
+r'''############################################################################
+################################################################################
+#
+#
+#	      Tegridy Plots Python Module (TPLOTS)
+#	      Version 1.0
+#
+#	      Project Los Angeles
+#
+#	      Tegridy Code 2024
+#
+#       https://github.com/asigalov61/tegridy-tools
+#
+#
+################################################################################
+#
+#       Copyright 2024 Project Los Angeles / Tegridy Code
+#
+#       Licensed under the Apache License, Version 2.0 (the "License");
+#       you may not use this file except in compliance with the License.
+#       You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#       Unless required by applicable law or agreed to in writing, software
+#       distributed under the License is distributed on an "AS IS" BASIS,
+#       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#       See the License for the specific language governing permissions and
+#       limitations under the License.
+#
+################################################################################
+################################################################################
+#
+# Critical dependencies
+#
+# !pip install numpy
+# !pip install scipy
+# !pip install matplotlib
+# !pip install networkx
+# !pip3 install scikit-learn
+#
+################################################################################
+#
+# Future critical dependencies
+#
+# !pip install umap-learn
+# !pip install alphashape
+#
+################################################################################
+'''
+
+################################################################################
+# Modules imports
+################################################################################
+
+import os
+from collections import Counter
+from itertools import groupby
+
+import numpy as np
+
+import networkx as nx
+
+from sklearn.manifold import TSNE
+from sklearn import metrics
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.decomposition import PCA
+
+from scipy.ndimage import zoom
+from scipy.spatial import distance_matrix
+from scipy.sparse.csgraph import minimum_spanning_tree
+from scipy.stats import zscore
+
+import matplotlib.pyplot as plt
+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]]
+
+################################################################################
+
+CHORDS_TYPES = ['WHITE', 'BLACK', 'UNKNOWN', 'MIXED WHITE', 'MIXED BLACK', 'MIXED GRAY']
+
+################################################################################
+
+WHITE_NOTES = [0, 2, 4, 5, 7, 9, 11]
+
+################################################################################
+
+BLACK_NOTES = [1, 3, 6, 8, 10]
+
+################################################################################
+# Helper functions
+################################################################################
+
+def tones_chord_type(tones_chord, 
+                     return_chord_type_index=True,
+                     ):
+
+  """
+  Returns tones chord type
+  """
+
+  WN = WHITE_NOTES
+  BN = BLACK_NOTES
+  MX = WHITE_NOTES + BLACK_NOTES
+
+
+  CHORDS = ALL_CHORDS_FILTERED
+
+  tones_chord = sorted(tones_chord)
+
+  ctype = 'UNKNOWN'
+
+  if tones_chord in CHORDS:
+
+    if sorted(set(tones_chord) & set(WN)) == tones_chord:
+      ctype = 'WHITE'
+
+    elif sorted(set(tones_chord) & set(BN)) == tones_chord:
+      ctype = 'BLACK'
+
+    if len(tones_chord) > 1 and sorted(set(tones_chord) & set(MX)) == tones_chord:
+
+      if len(sorted(set(tones_chord) & set(WN))) == len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED GRAY'
+
+      elif len(sorted(set(tones_chord) & set(WN))) > len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED WHITE'
+
+      elif len(sorted(set(tones_chord) & set(WN))) < len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED BLACK'
+
+  if return_chord_type_index:
+    return CHORDS_TYPES.index(ctype)
+
+  else:
+    return ctype
+
+###################################################################################
+
+def tone_type(tone, 
+              return_tone_type_index=True
+              ):
+
+  """
+  Returns tone type
+  """
+
+  tone = tone % 12
+
+  if tone in BLACK_NOTES:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('BLACK')
+    else:
+      return "BLACK"
+
+  else:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('WHITE')
+    else:
+      return "WHITE"
+
+###################################################################################
+
+def find_closest_points(points, return_points=True):
+
+  """
+  Find closest 2D points
+  """
+
+  coords = np.array(points)
+
+  num_points = coords.shape[0]
+  closest_matches = np.zeros(num_points, dtype=int)
+  distances = np.zeros((num_points, num_points))
+
+  for i in range(num_points):
+      for j in range(num_points):
+          if i != j:
+              distances[i, j] = np.linalg.norm(coords[i] - coords[j])
+          else:
+              distances[i, j] = np.inf
+
+  closest_matches = np.argmin(distances, axis=1)
+  
+  if return_points:
+    points_matches = coords[closest_matches].tolist()
+    return points_matches
+  
+  else:
+    return closest_matches.tolist()
+
+################################################################################
+
+def reduce_dimensionality_tsne(list_of_valies,
+                                n_comp=2,
+                                n_iter=5000,
+                                verbose=True
+                              ):
+
+  """
+  Reduces the dimensionality of the values using t-SNE.
+  """
+
+  vals = np.array(list_of_valies)
+
+  tsne = TSNE(n_components=n_comp,
+              n_iter=n_iter,
+              verbose=verbose)
+
+  reduced_vals = tsne.fit_transform(vals)
+
+  return reduced_vals.tolist()
+
+################################################################################
+
+def compute_mst_edges(similarity_scores_list):
+
+  """
+  Computes the Minimum Spanning Tree (MST) edges based on the similarity scores.
+  """
+  
+  num_tokens = len(similarity_scores_list[0])
+
+  graph = nx.Graph()
+
+  for i in range(num_tokens):
+      for j in range(i + 1, num_tokens):
+          weight = 1 - similarity_scores_list[i][j]
+          graph.add_edge(i, j, weight=weight)
+
+  mst = nx.minimum_spanning_tree(graph)
+
+  mst_edges = list(mst.edges(data=False))
+
+  return mst_edges
+
+################################################################################
+
+def square_binary_matrix(binary_matrix, 
+                         matrix_size=128,
+                         interpolation_order=5,
+                         return_square_matrix_points=False
+                         ):
+
+  """
+  Reduces an arbitrary binary matrix to a square binary matrix
+  """
+
+  zoom_factors = (matrix_size / len(binary_matrix), 1)
+
+  resized_matrix = zoom(binary_matrix, zoom_factors, order=interpolation_order)
+
+  resized_matrix = (resized_matrix > 0.5).astype(int)
+
+  final_matrix = np.zeros((matrix_size, matrix_size), dtype=int)
+  final_matrix[:, :resized_matrix.shape[1]] = resized_matrix
+
+  points = np.column_stack(np.where(final_matrix == 1)).tolist()
+
+  if return_square_matrix_points:
+    return points
+
+  else:
+    return resized_matrix
+
+################################################################################
+
+def square_matrix_points_colors(square_matrix_points):
+
+  """
+  Returns colors for square matrix points
+  """
+
+  cmap = generate_colors(12)
+
+  chords = []
+  chords_dict = set()
+  counts = []
+
+  for k, v in groupby(square_matrix_points, key=lambda x: x[0]):
+    pgroup = [vv[1] for vv in v]
+    chord = sorted(set(pgroup))
+    tchord = sorted(set([p % 12 for p in chord]))
+    chords_dict.add(tuple(tchord))
+    chords.append(tuple(tchord))
+    counts.append(len(pgroup))
+
+  chords_dict = sorted(chords_dict)
+
+  colors = []
+
+  for i, c in enumerate(chords):
+    colors.extend([cmap[round(sum(c) / len(c))]] * counts[i])
+
+  return colors
+
+################################################################################
+
+def hsv_to_rgb(h, s, v):
+
+  if s == 0.0:
+      return v, v, v
+
+  i = int(h*6.0)
+  f = (h*6.0) - i
+  p = v*(1.0 - s)
+  q = v*(1.0 - s*f)
+  t = v*(1.0 - s*(1.0-f))
+  i = i%6
+  
+  return [(v, t, p), (q, v, p), (p, v, t), (p, q, v), (t, p, v), (v, p, q)][i]
+
+################################################################################
+
+def generate_colors(n):
+  return [hsv_to_rgb(i/n, 1, 1) for i in range(n)]
+
+################################################################################
+
+def add_arrays(a, b):
+  return [sum(pair) for pair in zip(a, b)]
+
+################################################################################
+
+def calculate_similarities(lists_of_values, metric='cosine'):
+  return metrics.pairwise_distances(lists_of_values, metric=metric).tolist()
+
+################################################################################
+
+def get_tokens_embeddings(x_transformer_model):
+  return x_transformer_model.net.token_emb.emb.weight.detach().cpu().tolist()
+
+################################################################################
+
+def minkowski_distance_matrix(X, p=3):
+
+  X = np.array(X)
+
+  n = X.shape[0]
+  dist_matrix = np.zeros((n, n))
+
+  for i in range(n):
+      for j in range(n):
+          dist_matrix[i, j] = np.sum(np.abs(X[i] - X[j])**p)**(1/p)
+
+  return dist_matrix.tolist()
+
+################################################################################
+
+def robust_normalize(values):
+
+  values = np.array(values)
+  q1 = np.percentile(values, 25)
+  q3 = np.percentile(values, 75)
+  iqr = q3 - q1
+
+  filtered_values = values[(values >= q1 - 1.5 * iqr) & (values <= q3 + 1.5 * iqr)]
+
+  min_val = np.min(filtered_values)
+  max_val = np.max(filtered_values)
+  normalized_values = (values - min_val) / (max_val - min_val)
+
+  normalized_values = np.clip(normalized_values, 0, 1)
+
+  return normalized_values.tolist()
+
+################################################################################
+
+def min_max_normalize(values):
+
+  scaler = MinMaxScaler()
+
+  return scaler.fit_transform(values).tolist()
+
+################################################################################
+
+def remove_points_outliers(points, z_score_threshold=3):
+
+  points = np.array(points)
+
+  z_scores = np.abs(zscore(points, axis=0))
+
+  return points[(z_scores < z_score_threshold).all(axis=1)].tolist()
+
+################################################################################
+
+def generate_labels(lists_of_values, 
+                    return_indices_labels=False
+                    ):
+
+  ordered_indices = list(range(len(lists_of_values)))
+  ordered_indices_labels = [str(i) for i in ordered_indices]
+  ordered_values_labels = [str(lists_of_values[i]) for i in ordered_indices]
+
+  if return_indices_labels:
+    return ordered_indices_labels
+  
+  else:
+    return ordered_values_labels
+
+################################################################################
+
+def reduce_dimensionality_pca(list_of_values, n_components=2):
+
+  """
+  Reduces the dimensionality of the values using PCA.
+  """
+
+  pca = PCA(n_components=n_components)
+  pca_data = pca.fit_transform(list_of_values)
+  
+  return pca_data.tolist()
+
+def reduce_dimensionality_simple(list_of_values, 
+                                 return_means=True,
+                                 return_std_devs=True,
+                                 return_medians=False,
+                                 return_vars=False
+                                 ):
+  
+  '''
+  Reduces dimensionality of the values in a simple way
+  '''
+
+  array = np.array(list_of_values)
+  results = []
+
+  if return_means:
+      means = np.mean(array, axis=1)
+      results.append(means)
+
+  if return_std_devs:
+      std_devs = np.std(array, axis=1)
+      results.append(std_devs)
+
+  if return_medians:
+      medians = np.median(array, axis=1)
+      results.append(medians)
+
+  if return_vars:
+      vars = np.var(array, axis=1)
+      results.append(vars)
+
+  merged_results = np.column_stack(results)
+  
+  return merged_results.tolist()
+
+################################################################################
+
+def reduce_dimensionality_2d_distance(list_of_values, p=5):
+
+  '''
+  Reduces the dimensionality of the values using 2d distance
+  '''
+
+  values = np.array(list_of_values)
+
+  dist_matrix = distance_matrix(values, values, p=p)
+
+  mst = minimum_spanning_tree(dist_matrix).toarray()
+
+  points = []
+
+  for i in range(len(values)):
+      for j in range(len(values)):
+          if mst[i, j] > 0:
+              points.append([i, j])
+
+  return points
+
+################################################################################
+
+def normalize_to_range(values, n):
+    
+  min_val = min(values)
+  max_val = max(values)
+  
+  range_val = max_val - min_val
+  
+  normalized_values = [((value - min_val) / range_val * 2 * n) - n for value in values]
+  
+  return normalized_values
+
+################################################################################
+
+def reduce_dimensionality_simple_pca(list_of_values, n_components=2):
+
+  '''
+  Reduces the dimensionality of the values using simple PCA
+  '''
+
+  reduced_values = []
+
+  for l in list_of_values:
+
+    norm_values = [round(v * len(l)) for v in normalize_to_range(l, (n_components+1) // 2)]
+
+    pca_values = Counter(norm_values).most_common()
+    pca_values = [vv[0] / len(l) for vv in pca_values]
+    pca_values = pca_values[:n_components]
+    pca_values = pca_values + [0] * (n_components - len(pca_values))
+
+    reduced_values.append(pca_values)
+
+  return reduced_values
+
+################################################################################
+
+def filter_and_replace_values(list_of_values, 
+                              threshold, 
+                              replace_value, 
+                              replace_above_threshold=False
+                              ):
+
+  array = np.array(list_of_values)
+
+  modified_array = np.copy(array)
+  
+  if replace_above_threshold:
+    modified_array[modified_array > threshold] = replace_value
+  
+  else:
+    modified_array[modified_array < threshold] = replace_value
+  
+  return modified_array.tolist()
+
+################################################################################
+
+def find_shortest_constellation_path(points, 
+                                     start_point_idx, 
+                                     end_point_idx,
+                                     p=5,
+                                     return_path_length=False,
+                                     return_path_points=False,
+                                     ):
+
+    """
+    Finds the shortest path between two points of the points constellation
+    """
+
+    points = np.array(points)
+
+    dist_matrix = distance_matrix(points, points, p=p)
+
+    mst = minimum_spanning_tree(dist_matrix).toarray()
+
+    G = nx.Graph()
+
+    for i in range(len(points)):
+        for j in range(len(points)):
+            if mst[i, j] > 0:
+                G.add_edge(i, j, weight=mst[i, j])
+
+    path = nx.shortest_path(G, 
+                            source=start_point_idx, 
+                            target=end_point_idx, 
+                            weight='weight'
+                            )
+    
+    path_length = nx.shortest_path_length(G, 
+                                          source=start_point_idx, 
+                                          target=end_point_idx, 
+                                          weight='weight')
+        
+    path_points = points[np.array(path)].tolist()
+
+
+    if return_path_points:
+      return path_points
+
+    if return_path_length:
+      return path_length
+
+    return path
+
+################################################################################
+# Core functions
+################################################################################
+
+def plot_ms_SONG(ms_song,
+                  preview_length_in_notes=0,
+                  block_lines_times_list = None,
+                  plot_title='ms Song',
+                  max_num_colors=129, 
+                  drums_color_num=128, 
+                  plot_size=(11,4), 
+                  note_height = 0.75,
+                  show_grid_lines=False,
+                  return_plt = False,
+                  timings_multiplier=1,
+                  save_plt='',
+                  save_only_plt_image=True,
+                  save_transparent=False
+                  ):
+
+  '''ms SONG plot'''
+
+  notes = [s for s in ms_song if s[0] == 'note']
+
+  if (len(max(notes, key=len)) != 7) and (len(min(notes, key=len)) != 7):
+    print('The song notes do not have patches information')
+    print('Ploease add patches to the notes in the song')
+
+  else:
+
+    start_times = [(s[1] * timings_multiplier) / 1000 for s in notes]
+    durations = [(s[2]  * timings_multiplier) / 1000 for s in notes]
+    pitches = [s[4] for s in notes]
+    patches = [s[6] for s in notes]
+
+    colors = generate_colors(max_num_colors)
+    colors[drums_color_num] = (1, 1, 1)
+
+    pbl = (notes[preview_length_in_notes][1] * timings_multiplier) / 1000
+
+    fig, ax = plt.subplots(figsize=plot_size)
+
+    for start, duration, pitch, patch in zip(start_times, durations, pitches, patches):
+        rect = plt.Rectangle((start, pitch), duration, note_height, facecolor=colors[patch])
+        ax.add_patch(rect)
+
+    ax.set_xlim([min(start_times), max(add_arrays(start_times, durations))])
+    ax.set_ylim([min(pitches)-1, max(pitches)+1])
+
+    ax.set_facecolor('black')
+    fig.patch.set_facecolor('white')
+
+    if preview_length_in_notes > 0:
+      ax.axvline(x=pbl, c='white')
+
+    if block_lines_times_list:
+      for bl in block_lines_times_list:
+        ax.axvline(x=bl, c='white')
+           
+    if show_grid_lines:
+      ax.grid(color='white')
+
+    plt.xlabel('Time (s)', c='black')
+    plt.ylabel('MIDI Pitch', c='black')
+
+    plt.title(plot_title)
+
+    if save_plt != '':
+      if save_only_plt_image:
+        plt.axis('off')
+        plt.title('')
+        plt.savefig(save_plt, 
+                    transparent=save_transparent, 
+                    bbox_inches='tight', 
+                    pad_inches=0, 
+                    facecolor='black'
+                    )
+        plt.close()
+      
+      else:
+        plt.savefig(save_plt)
+        plt.close()
+
+    if return_plt:
+      return fig
+
+    plt.show()
+    plt.close()
+
+################################################################################
+
+def plot_square_matrix_points(list_of_points,
+                              list_of_points_colors,
+                              plot_size=(7, 7),
+                              point_size = 10,
+                              show_grid_lines=False,
+                              plot_title = 'Square Matrix Points Plot',
+                              return_plt=False,
+                              save_plt='',
+                              save_only_plt_image=True,
+                              save_transparent=False
+                              ):
+
+  '''Square matrix points plot'''
+
+  fig, ax = plt.subplots(figsize=plot_size)
+
+  ax.set_facecolor('black')
+
+  if show_grid_lines:
+    ax.grid(color='white')
+
+  plt.xlabel('Time Step', c='black')
+  plt.ylabel('MIDI Pitch', c='black')
+
+  plt.title(plot_title)
+
+  plt.scatter([p[0] for p in list_of_points], 
+              [p[1] for p in list_of_points], 
+              c=list_of_points_colors, 
+              s=point_size
+              )
+
+  if save_plt != '':
+    if save_only_plt_image:
+      plt.axis('off')
+      plt.title('')
+      plt.savefig(save_plt, 
+                  transparent=save_transparent, 
+                  bbox_inches='tight', 
+                  pad_inches=0, 
+                  facecolor='black'
+                  )
+      plt.close()
+    
+    else:
+      plt.savefig(save_plt)
+      plt.close()
+
+  if return_plt:
+    return fig
+
+  plt.show()
+  plt.close()
+
+################################################################################
+
+def plot_cosine_similarities(lists_of_values,
+                             plot_size=(7, 7),
+                             save_plot=''
+                            ):
+
+  """
+  Cosine similarities plot
+  """
+
+  cos_sim = metrics.pairwise_distances(lists_of_values, metric='cosine')
+
+  plt.figure(figsize=plot_size)
+
+  plt.imshow(cos_sim, cmap="inferno", interpolation="nearest")
+
+  im_ratio = cos_sim.shape[0] / cos_sim.shape[1]
+
+  plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)
+
+  plt.xlabel("Index")
+  plt.ylabel("Index")
+
+  plt.tight_layout()
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+  plt.close()
+
+################################################################################
+
+def plot_points_with_mst_lines(points, 
+                               points_labels, 
+                               points_mst_edges,
+                               plot_size=(20, 20),
+                               labels_size=24,
+                               save_plot=''
+                               ):
+
+  """
+  Plots 2D points with labels and MST lines.
+  """
+
+  plt.figure(figsize=plot_size)
+
+  for i, label in enumerate(points_labels):
+      plt.scatter(points[i][0], points[i][1])
+      plt.annotate(label, (points[i][0], points[i][1]), fontsize=labels_size)
+
+  for edge in points_mst_edges:
+      i, j = edge
+      plt.plot([points[i][0], points[j][0]], [points[i][1], points[j][1]], 'k-', alpha=0.5)
+
+  plt.title('Points Map with MST Lines', fontsize=labels_size)
+  plt.xlabel('X-axis', fontsize=labels_size)
+  plt.ylabel('Y-axis', fontsize=labels_size)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+
+################################################################################
+
+def plot_points_constellation(points, 
+                              points_labels,
+                              p=5,                              
+                              plot_size=(15, 15),
+                              labels_size=12,
+                              show_grid=False,
+                              save_plot=''
+                              ):
+
+  """
+  Plots 2D points constellation
+  """
+
+  points = np.array(points)
+
+  dist_matrix = distance_matrix(points, points, p=p)
+
+  mst = minimum_spanning_tree(dist_matrix).toarray()
+
+  plt.figure(figsize=plot_size)
+
+  plt.scatter(points[:, 0], points[:, 1], color='blue')
+
+  for i, label in enumerate(points_labels):
+      plt.annotate(label, (points[i, 0], points[i, 1]), 
+                   textcoords="offset points", 
+                   xytext=(0, 10), 
+                   ha='center',
+                   fontsize=labels_size
+                   )
+
+  for i in range(len(points)):
+      for j in range(len(points)):
+          if mst[i, j] > 0:
+              plt.plot([points[i, 0], points[j, 0]], [points[i, 1], points[j, 1]], 'k--')
+
+  plt.xlabel('X-axis', fontsize=labels_size)
+  plt.ylabel('Y-axis', fontsize=labels_size)
+  plt.title('2D Coordinates with Minimum Spanning Tree', fontsize=labels_size)
+
+  plt.grid(show_grid)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+
+################################################################################
+
+def binary_matrix_to_images(matrix, 
+                            step,
+                            overlap,
+                            output_folder='./Dataset/', 
+                            output_img_prefix='image', 
+                            output_img_ext='.png',
+                            save_to_array=False,
+                            verbose=True
+                            ):
+
+    if not save_to_array:
+
+      if verbose:
+        print('=' * 70)
+        print('Checking output folder dir...')
+
+      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
+
+      if verbose:
+        print('Done!')
+
+    if verbose:
+      print('=' * 70)
+      print('Writing images...')
+
+    matrix = np.array(matrix, dtype=np.uint8)
+    
+    image_array = []
+    
+    for i in range(0, max(1, matrix.shape[0]), overlap):
+       
+        submatrix = matrix[i:i+step, :]
+
+        if submatrix.shape[0] < 128:
+          zeros_array = np.zeros((128-submatrix.shape[0], 128))
+          submatrix = np.vstack((submatrix, zeros_array))
+
+        img = Image.fromarray(submatrix * 255).convert('1')
+        
+        if save_to_array:
+          image_array.append(np.array(img))
+
+        else:
+          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
+  
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
+      print('=' * 70)
+
+    if save_to_array:
+        return np.array(image_array).tolist()
+
+################################################################################
+
+def images_to_binary_matrix(list_of_images):
+
+    image_array = np.array(list_of_images)
+   
+    original_matrix = []
+    
+    for img in image_array:
+
+        submatrix = np.array(img)
+        original_matrix.extend(submatrix.tolist())
+    
+    return original_matrix
+
+################################################################################
+
+def square_image_matrix(image_matrix,
+                        matrix_size=128,
+                        num_pca_components=5,
+                        filter_out_zero_rows=False,
+                        return_square_matrix_points=False
+                        ):
+
+  """
+  Reduces an arbitrary image matrix to a square image matrix
+  """
+
+  matrix = np.array(image_matrix)
+
+  if filter_out_zero_rows:
+    matrix = matrix[~np.all(matrix == 0, axis=1)]
+
+  target_rows = matrix_size
+
+  rows_per_group = matrix.shape[0] // target_rows
+
+  compressed_matrix = np.zeros((target_rows, matrix.shape[1]), dtype=np.int32)
+
+  for i in range(target_rows):
+      start_row = i * rows_per_group
+      end_row = (i + 1) * rows_per_group
+      group = matrix[start_row:end_row, :]
+      
+      pca = PCA(n_components=num_pca_components)
+      pca.fit(group)
+      
+      principal_component = np.mean(pca.components_, axis=0)
+      contributions = np.dot(group, principal_component)
+      selected_row_index = np.argmax(contributions)
+      
+      compressed_matrix[i, :] = group[selected_row_index, :]
+
+  if return_square_matrix_points:
+    filtered_matrix = compressed_matrix[~np.all(compressed_matrix == 0, axis=1)]
+
+    row_indexes, col_indexes = np.where(filtered_matrix != 0)
+    points = np.column_stack((row_indexes, filtered_matrix[row_indexes, col_indexes])).tolist()
+
+    return points
+
+  else:
+    return compressed_matrix.tolist()
+
+################################################################################
+
+def image_matrix_to_images(image_matrix,
+                           step,
+                           overlap,
+                           num_img_channels=3,
+                           output_folder='./Dataset/',
+                           output_img_prefix='image',
+                           output_img_ext='.png',
+                           save_to_array=False,
+                           verbose=True
+                           ):
+
+    if num_img_channels > 1:
+      n_mat_channels = 3
+
+    else:
+      n_mat_channels = 1
+
+    if not save_to_array:
+
+      if verbose:
+        print('=' * 70)
+        print('Checking output folder dir...')
+
+      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
+
+      if verbose:
+        print('Done!')
+
+    if verbose:
+      print('=' * 70)
+      print('Writing images...')
+
+    matrix = np.array(image_matrix)
+
+    image_array = []
+
+    for i in range(0, max(1, matrix.shape[0]), overlap):
+
+        submatrix = matrix[i:i+step, :]
+
+        if submatrix.shape[0] < 128:
+          zeros_array = np.zeros((128-submatrix.shape[0], 128))
+          submatrix = np.vstack((submatrix, zeros_array))
+
+        if n_mat_channels == 3:
+
+          r = (submatrix // (256*256)) % 256
+          g = (submatrix // 256) % 256
+          b = submatrix % 256
+
+          rgb_image = np.stack((r, g, b), axis=-1).astype(np.uint8)
+          img = Image.fromarray(rgb_image, 'RGB')
+
+        else:
+          grayscale_image = submatrix.astype(np.uint8)
+          img = Image.fromarray(grayscale_image, 'L')
+
+        if save_to_array:
+          image_array.append(np.array(img))
+
+        else:
+          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
+
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
+      print('=' * 70)
+
+    if save_to_array:
+        return np.array(image_array).tolist()
+
+################################################################################
+
+def images_to_image_matrix(list_of_images,
+                           num_img_channels=3
+                           ):
+
+    if num_img_channels > 1:
+      n_mat_channels = 3
+
+    else:
+      n_mat_channels = 1
+
+    image_array = np.array(list_of_images)
+
+    original_matrix = []
+
+    for img in image_array:
+
+      if num_img_channels == 3:
+
+        rgb_array = np.array(img)
+
+        matrix = (rgb_array[..., 0].astype(np.int64) * 256*256 +
+                  rgb_array[..., 1].astype(np.int64) * 256 +
+                  rgb_array[..., 2].astype(np.int64))
+
+      else:
+        matrix = np.array(img)
+
+      original_matrix.extend(matrix)
+
+    return original_matrix
+
+################################################################################
+
+def square_matrix_to_RGB_matrix(square_matrix):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  r = (sq_matrix // (256 ** 2)) % 256
+  g = (sq_matrix // 256) % 256
+  b = sq_matrix % 256
+
+  rgb_array = np.stack((r, g, b), axis=-1)
+
+  return rgb_array.tolist()
+
+################################################################################
+
+def upsample_square_matrix(square_matrix, upsampling_factor=4):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  scaling_array = np.ones((upsampling_factor, upsampling_factor))
+  scaled_array = np.kron(sq_matrix, scaling_array)
+  scaled_array = scaled_array.astype('int')
+
+  return scaled_array.tolist()
+
+################################################################################
+
+def downsample_square_matrix(square_matrix, downsampling_factor=4):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  dmatrix = sq_matrix[::downsampling_factor, ::downsampling_factor]
+  dmatrix = dmatrix.astype('int')
+
+  return dmatrix.tolist()
+
+################################################################################
+# [WIP] Future dev functions
+################################################################################
+
+'''
+import umap
+
+def reduce_dimensionality_umap(list_of_values,
+                               n_comp=2,
+                               n_neighbors=15,
+                               ):
+
+  """
+  Reduces the dimensionality of the values using UMAP.
+  """
+
+  vals = np.array(list_of_values)
+
+  umap_reducer = umap.UMAP(n_components=n_comp,
+                           n_neighbors=n_neighbors,
+                           n_epochs=5000,
+                           verbose=True
+                           )
+
+  reduced_vals = umap_reducer.fit_transform(vals)
+
+  return reduced_vals.tolist()
+'''
+
+################################################################################
+
+'''
+import alphashape
+from shapely.geometry import Point
+from matplotlib.tri import Triangulation, LinearTriInterpolator
+from scipy.stats import zscore
+
+#===============================================================================
+
+coordinates = points
+
+dist_matrix = minkowski_distance_matrix(coordinates, p=3)  # You can change the value of p as needed
+
+# Centering matrix
+n = dist_matrix.shape[0]
+H = np.eye(n) - np.ones((n, n)) / n
+
+# Apply double centering
+B = -0.5 * H @ dist_matrix**2 @ H
+
+# Eigen decomposition
+eigvals, eigvecs = np.linalg.eigh(B)
+
+# Sort eigenvalues and eigenvectors
+idx = np.argsort(eigvals)[::-1]
+eigvals = eigvals[idx]
+eigvecs = eigvecs[:, idx]
+
+# Select the top 2 eigenvectors
+X_transformed = eigvecs[:, :2] * np.sqrt(eigvals[:2])
+
+#===============================================================================
+
+src_points = X_transformed
+src_values = np.array([[p[1]] for p in points]) #np.random.rand(X_transformed.shape[0])
+
+#===============================================================================
+
+# Normalize the points to the range [0, 1]
+scaler = MinMaxScaler()
+points_normalized = scaler.fit_transform(src_points)
+
+values_normalized = custom_normalize(src_values)
+
+# Remove outliers based on z-score
+z_scores = np.abs(zscore(points_normalized, axis=0))
+filtered_points = points_normalized[(z_scores < 3).all(axis=1)]
+filtered_values = values_normalized[(z_scores < 3).all(axis=1)]
+
+# Compute the concave hull (alpha shape)
+alpha = 8  # Adjust alpha as needed
+hull = alphashape.alphashape(filtered_points, alpha)
+
+# Create a triangulation
+tri = Triangulation(filtered_points[:, 0], filtered_points[:, 1])
+
+# Interpolate the values on the triangulation
+interpolator = LinearTriInterpolator(tri, filtered_values[:, 0])
+xi, yi = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100))
+zi = interpolator(xi, yi)
+
+# Mask out points outside the concave hull
+mask = np.array([hull.contains(Point(x, y)) for x, y in zip(xi.flatten(), yi.flatten())])
+zi = np.ma.array(zi, mask=~mask.reshape(zi.shape))
+
+# Plot the filled contour based on the interpolated values
+plt.contourf(xi, yi, zi, levels=50, cmap='viridis')
+
+# Plot the original points
+#plt.scatter(filtered_points[:, 0], filtered_points[:, 1], c=filtered_values, edgecolors='k')
+
+plt.title('Filled Contour Plot with Original Values')
+plt.xlabel('X-axis')
+plt.ylabel('Y-axis')
+plt.colorbar(label='Value')
+plt.show()
+'''
+
+################################################################################
+#
+# This is the end of TPLOTS Python modules
+#
+################################################################################