Update app.py

app.py

@@ -20,6 +20,21 @@ from midi_to_colab_audio import midi_to_colab_audio
 
 # =================================================================================================
 
+def find_best_match(matches):
+
+  mlens = []
+
+  for sidx in matches:
+    mlen = len(TMIDIX.flatten(long_chords_chunks_mult[sidx[0]][sidx[1]:sidx[1]+(csize // 2)]))
+    mlens.append(mlen)
+
+  max_len = max(mlens)
+  max_len_idx = mlens.index(max_len)
+
+  return matches[max_len_idx]
+
+# =================================================================================================
+
 def Harmonize_Melody(source_melody_transpose_value,
                     harmonizer_melody_chunk_size,
                     harmonizer_max_matches_count,
@@ -66,7 +81,7 @@ def Harmonize_Melody(source_melody_transpose_value,
     
     mel_score = TMIDIX.fix_monophonic_score_durations(TMIDIX.recalculate_score_timings(cscore))
     
-    mel_score = TMIDIX.transpose_escore_notes(mel_score, 0)
+    mel_score = TMIDIX.transpose_escore_notes(mel_score, source_melody_transpose_value)
     
     print('=' * 70)
     print('Done!')
@@ -80,97 +95,73 @@ def Harmonize_Melody(source_melody_transpose_value,
     #==================================================================
 
     print('=' * 70)
-    print('Melody Harmonization Generator')
+    print('Melody Harmonizer')
     print('=' * 70)
 
     print('=' * 70)
-    print('Generating...')
+    print('Harmonizing...')
     print('=' * 70)
-    
-    matching_long_chords_chunks = []
-    
-    ridx = random.randint(0, len(all_long_chords_tokens_chunks)-1)
-    
-    matching_long_chords_chunks.append(ridx)
-    
-    max_song_len = 0
-    
-    tries = 0
-    
-    while len(matching_long_chords_chunks) < minimum_song_length_in_chords_chunks:
 
-        matching_long_chords_chunks = []
-    
-        ridx = random.randint(0, len(all_long_chords_tokens_chunks)-1)
-    
-        matching_long_chords_chunks.append(ridx)
-        seen = [ridx]
-        gseen = [ridx]
-    
-        for a in range(minimum_song_length_in_chords_chunks * 10):
+    #===============================================================================
     
-          if not matching_long_chords_chunks:
-            break
+    song = []
     
-          if len(matching_long_chords_chunks) > minimum_song_length_in_chords_chunks:
-            break
+    csize = harmonizer_melody_chunk_size
+    matches_mem_size = harmonizer_max_matches_count
     
-          schunk = all_long_chords_tokens_chunks[matching_long_chords_chunks[-1]]
-          trg_long_chunk = np.array(schunk[-chunk_size:])
-          idxs = np.where((src_long_chunks == trg_long_chunk).all(axis=1))[0].tolist()
+    i = 0
+    dev = 0
+    dchunk = []
     
-          if len(idxs) > 1:
+    #===============================================================================
     
-            random.shuffle(idxs)
+    while i < len(mel_pitches):
     
-            eidxs = [i for i in idxs if i not in seen]
+      matches = []
     
-            if eidxs:
-              eidx = eidxs[0]
-              matching_long_chords_chunks.append(eidx)
-              seen.append(eidx)
-              gseen.append(eidx)
+      for midx, mel in enumerate(long_mels_chunks_mult):
+        if len(mel) >= csize:
+          schunk = mel_pitches[i:i+csize]
+          idx = HaystackSearch.HaystackSearch(schunk, mel)
     
-              if 0 < chords_chunks_memory_ratio < 1:
-                seen = random.choices(gseen, k=math.ceil(len(gseen) * chords_chunks_memory_ratio))
-              elif chords_chunks_memory_ratio == 0:
-                seen = []
+          if idx != -1:
+            matches.append([midx, idx])
+            if matches_mem_size > -1:
+              if len(matches) > matches_mem_size:
+                break
     
-            else:
-                gseen.pop()
-                matching_long_chords_chunks.pop()
+      if matches:
     
-          else:
-            gseen.pop()
-            matching_long_chords_chunks.pop()
+        sidx = find_best_match(matches)
     
+        fchunk = long_chords_chunks_mult[sidx[0]][sidx[1]:sidx[1]+csize]
     
-        if len(matching_long_chords_chunks) > max_song_len:
-          print('Current song length:', len(matching_long_chords_chunks), 'chords chunks')
-          print('=' * 70)
-          final_song = matching_long_chords_chunks
+        song.extend(fchunk[:(csize // 2)])
+        i += (csize // 2)
+        dchunk = fchunk
+        dev = 0
+        print('step', i)
+        
+      else:
     
-        max_song_len = max(max_song_len, len(matching_long_chords_chunks))
+        if dchunk:
     
-        tries += 1
+          song.append(dchunk[(csize // 2)+dev])
+          dev += 1
+          i += 1
+          print('dead chord', i, dev)
+        else:
+          print('DEAD END!!!')
+          break
     
-        if tries % 500 == 0:
-          print('Number of passed tries:', tries)
-          print('=' * 70)
-
-    if len(matching_long_chords_chunks) > max_song_len:
-      print('Current song length:', len(matching_long_chords_chunks), 'chords chunks')
-      print('=' * 70)
-      final_song = matching_long_chords_chunks
     
-    f_song = []
+        if dev == csize // 2:
+          print('DEAD END!!!')
+          break
     
-    for mat in final_song:
-      f_song.extend(all_long_good_chords_chunks[mat][:-chunk_size])
-    f_song.extend(all_long_good_chords_chunks[mat][-chunk_size:])
+    song = song[:len(mel_pitches)]
     
-    print('Generated final song after', tries, 'tries with', len(final_song), 'chords chunks and', len(f_song), 'chords')
-    print('=' * 70)
+    print('Harmonized', len(song), 'out of', len(mel_pitches), 'notes')
 
     print('Done!')
     print('=' * 70)
@@ -185,51 +176,30 @@ def Harmonize_Melody(source_melody_transpose_value,
     time = 0
     
     patches = [0] * 16
-    patches[0] = chords_progression_MIDI_patch_number
+    patches[0] = harmonized_accompaniment_MIDI_patch_number
     
     if base_MIDI_patch_number > -1:
       patches[2] = base_MIDI_patch_number
     
-    if melody_MIDI_patch_number > -1:
-      patches[3] = melody_MIDI_patch_number
-    
-    chords_labels = []
-    
-    for i, s in enumerate(f_song):
-    
-      time += chord_time_step
-    
-      dur = chord_time_step
+    patches[3] = melody_MIDI_patch_number
     
-      chord_str = str(i+1)
+    for i, s in enumerate(song):
     
-      for t in sorted(set([t % 12 for t in s])):
-        chord_str += '-' + str(t)
-    
-      chords_labels.append(['text_event', time, chord_str])
+      time = mel_score[i][1] * 16
+      dur = mel_score[i][2] * 16
+
+      output_score.append(['note', time, dur, 3,  mel_score[i][4], 115+(mel_score[i][4] % 12), 40])
     
       for p in s:
-        output_score.append(['note', time, dur, 0, p, max(40, p), chords_progression_MIDI_patch_number])
+        output_score.append(['note', time, dur, 0, p, max(40, p), harmonized_accompaniment_MIDI_patch_number])
                     
       if base_MIDI_patch_number > -1:
         output_score.append(['note', time, dur, 2, (s[-1] %  12)+24, 120-(s[-1] %  12), base_MIDI_patch_number])
-    
-    if melody_MIDI_patch_number > -1:
-      output_score = TMIDIX.add_melody_to_enhanced_score_notes(output_score, 
-                                                               melody_patch=melody_MIDI_patch_number,
-                                                               melody_notes_max_duration=max(merge_chords_notes, chord_time_step)
-                                                              )
-
-    if merge_chords_notes > 0:
-        escore_matrix = TMIDIX.escore_notes_to_escore_matrix(output_score)
-        output_score = TMIDIX.escore_matrix_to_merged_escore_notes(escore_matrix, max_note_duration=merge_chords_notes)
-        
-    midi_score = sorted(chords_labels + output_score, key=lambda x: x[1])
 
     fn1 = "Pitches-Chords-Progression-Composition"
     
-    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(midi_score,
-                                                              output_signature = 'Pitches Chords Progression',
+    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(output_score,
+                                                              output_signature = 'Monophonic MIDI Melody Harmonizer',
                                                               output_file_name = fn1,
                                                               track_name='Project Los Angeles',
                                                               list_of_MIDI_patches=patches
@@ -254,73 +224,20 @@ def Harmonize_Melody(source_melody_transpose_value,
     output_plot = TMIDIX.plot_ms_SONG(output_score, plot_title=output_midi, return_plt=True)
     
     print('Done!')
-    print('=' * 70)
     
     #========================================================
 
-    print('Generated chords progression info and stats:')
-    print('=' * 70)
+    harmonization_summary_string = '=' * 70
+    harmonization_summary_string += '\n'
 
-    chords_progression_summary_string = '=' * 70
-    chords_progression_summary_string += '\n'
-
-    all_song_chords = []
+    harmonization_summary_string += 'Source melody has ' + str(len(mel_pitches)) + ' monophonic pitches'
+    harmonization_summary_string += '=' * 70
+    harmonization_summary_string += '\n'
     
-    for pc in f_song:
-      tones_chord = tuple(sorted(set([p % 12 for p in pc])))
-      all_song_chords.append([pc, tones_chord])
+    harmonization_summary_string += 'Harmonized ' + str(len(song)) + ' out of ' + str(len(mel_pitches)) + ' source melody pitches')
+    harmonization_summary_string += '=' * 70
+    harmonization_summary_string += '\n'
     
-    print('=' * 70)
-    print('Total number of chords:', len(all_song_chords))
-    chords_progression_summary_string += 'Total number of chords: ' + str(len(all_song_chords)) + '\n'
-    chords_progression_summary_string += '=' * 70
-    chords_progression_summary_string += '\n'
-    print('=' * 70)
-    print('Most common pitches chord:', list(Counter(tuple([a[0] for a in all_song_chords])).most_common(1)[0][0]), '===', Counter(tuple([a[0] for a in all_song_chords])).most_common(1)[0][1], 'count')
-    chords_progression_summary_string += 'Most common pitches chord: ' + str(list(Counter(tuple([a[0] for a in all_song_chords])).most_common(1)[0][0])) + ' === ' + str(Counter(tuple([a[0] for a in all_song_chords])).most_common(1)[0][1]) + ' count' + '\n'
-    chords_progression_summary_string += '=' * 70
-    chords_progression_summary_string += '\n'
-    print('=' * 70)
-    print('Most common tones chord:', list(Counter(tuple([a[1] for a in all_song_chords])).most_common(1)[0][0]), '===', Counter(tuple([a[1] for a in all_song_chords])).most_common(1)[0][1], 'count')
-    chords_progression_summary_string += 'Most common tones chord: ' + str(list(Counter(tuple([a[1] for a in all_song_chords])).most_common(1)[0][0])) + ' === ' + str(Counter(tuple([a[1] for a in all_song_chords])).most_common(1)[0][1]) + ' count' + '\n'
-    chords_progression_summary_string += '=' * 70
-    chords_progression_summary_string += '\n'    
-    print('=' * 70)
-    print('Sorted unique songs chords set:', len(sorted(set(tuple([a[1] for a in all_song_chords])))), 'count')
-    chords_progression_summary_string += 'Sorted unique songs chords set: ' + str(len(sorted(set(tuple([a[1] for a in all_song_chords]))))) +  ' count' + '\n'
-    chords_progression_summary_string += '=' * 70
-    chords_progression_summary_string += '\n'
-    #print('=' * 70)
-    for c in sorted(set(tuple([a[1] for a in all_song_chords]))):
-        #print(list(c))
-        chords_progression_summary_string += str(list(c)) + '\n'
-    chords_progression_summary_string += '=' * 70
-    chords_progression_summary_string += '\n'
-    print('=' * 70)
-    print('Grouped songs chords set:', len(TMIDIX.grouped_set(tuple([a[1] for a in all_song_chords]))), 'count')
-    chords_progression_summary_string += 'Grouped songs chords set: ' + str(len(TMIDIX.grouped_set(tuple([a[1] for a in all_song_chords])))) + ' count' + '\n'
-    chords_progression_summary_string += '=' * 70
-    chords_progression_summary_string += '\n'
-    print('=' * 70)
-    for c in TMIDIX.grouped_set(tuple([a[1] for a in all_song_chords])):
-        #print(list(c))
-        chords_progression_summary_string += str(list(c)) + '\n'
-    chords_progression_summary_string += '=' * 70
-    chords_progression_summary_string += '\n'
-    #print('=' * 70)
-    #print('All songs chords')
-    chords_progression_summary_string += 'All songs chords' + '\n'
-    chords_progression_summary_string += '=' * 70
-    chords_progression_summary_string += '\n'
-    #print('=' * 70)
-    for i, pc_tc in enumerate(all_song_chords):
-        #print('Song chord #', i)
-        chords_progression_summary_string += 'Song chord # ' + str(i) + '\n'
-        #print(list(pc_tc[0]), '===', list(pc_tc[1]))
-        chords_progression_summary_string += str(list(pc_tc[0])) + ' === ' + str(list(pc_tc[1])) + '\n'
-        #print('=' * 70)
-        chords_progression_summary_string += '=' * 70
-        chords_progression_summary_string += '\n'
     #========================================================
     
     print('-' * 70)
@@ -328,7 +245,7 @@ def Harmonize_Melody(source_melody_transpose_value,
     print('-' * 70)
     print('Req execution time:', (reqtime.time() - start_time), 'sec')
 
-    return output_audio, output_plot, output_midi, chords_progression_summary_string
+    return output_audio, output_plot, output_midi, harmonization_summary_string
 
 # =================================================================================================