Update app.py, format_conversions.py, and hexachords.py

app.py

@@ -1,16 +1,13 @@
 import ast
-import shutil
 import gradio as gr
 import numpy as np
-from matplotlib import pyplot as plt
 from mido import Message, MidiFile, MidiTrack
 import os
-import subprocess
 from music21 import converter, note
-from pydub import AudioSegment
 import hexachords
 from format_conversions import Format_Converter
 import verovio
+import subprocess
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
@@ -44,7 +41,6 @@ class HexachordApp:
 
     def __init__(self):
         self._hexachord = hexachords.Hexachord()
-        self._hexachord_base_sequence = None
         self.ui = None
         self.on_huggingface = "HUGGINGFACE_SPACE" in os.environ
 
@@ -63,24 +59,21 @@ class HexachordApp:
         interval_21 = 'P5'
         if itvl == 'fourth':
             interval_21 = 'P4'
-        self._hexachord_base_sequence = self._hexachord.generate_chord_sequence(note_names, intrvl=interval_21)
-        return self._hexachord_base_sequence
+        return self._hexachord.generate_base_sequence(note_names, intrvl=interval_21)
 
     def generate_realizations(self):
-        # returns 3 triples of midipath, piano roll, audio player
-        reals = self._hexachord.generate_3_chords_realizations(self._hexachord_base_sequence)
+        # returns triples of midipath, score image, audio player
+        fm = Format_Converter()
+        reals = self._hexachord.generate_3_chords_realizations(self._hexachord._base_sequence)
         midi_path1 = self.create_midi(reals[0], "real1.mid")
-        # piano_roll_path1 = self.generate_piano_roll(reals[0], "real1.png")
-        score_path1 = self.generate_svg(midi_path1, "real1.svg")
-        audio_path1 = self.convert_midi_to_audio(midi_path1, "real1")
+        score_path1 = fm.midi_to_svg_file(tk, midi_path1, "real1.svg")
+        audio_path1 = fm.convert_midi_to_audio(midi_path1, "real1")
         midi_path2 = self.create_midi(reals[1], "real2.mid")
-        # piano_roll_path2 = self.generate_piano_roll(reals[1], "real2.png")
-        score_path2 = self.generate_svg(midi_path2, "real2.svg")
-        audio_path2 = self.convert_midi_to_audio(midi_path2, "real2")
+        score_path2 = fm.midi_to_svg_file(tk, midi_path2, "real2.svg")
+        audio_path2 = fm.convert_midi_to_audio(midi_path2, "real2")
         midi_path3 = self.create_midi(reals[2], "real3.mid")
-        # piano_roll_path3 = self.generate_piano_roll(reals[2], "real3.png")
-        score_path3 = self.generate_svg(midi_path3, "real3.svg")
-        audio_path3 = self.convert_midi_to_audio(midi_path3, "real3")
+        score_path3 = fm.midi_to_svg_file(tk, midi_path3, "real3.svg")
+        audio_path3 = fm.convert_midi_to_audio(midi_path3, "real3")
         return midi_path1, score_path1, audio_path1, midi_path2, score_path2, audio_path2, midi_path3, score_path3, audio_path3
 
     def create_midi(self, chords, file_name):
@@ -105,56 +98,9 @@ class HexachordApp:
         mid.save(midi_path)
         return midi_path
 
-
-    def convert_midi_to_audio(self, midi_path, file_name):
-        if not shutil.which("fluidsynth"):
-            try:
-                subprocess.run(["apt-get", "update"], check=True)
-                subprocess.run(["apt-get", "install", "-y", "fluidsynth"], check=True)
-            except Exception as e:
-                return f"Error installing Fluidsynth: {str(e)}"
-        wav_path = os.path.join(BASE_DIR, file_name + ".wav")
-        mp3_path = os.path.join(BASE_DIR, file_name + ".mp3")
-        soundfont_path = os.path.join(BASE_DIR, "soundfont.sf2")
-        if not os.path.exists(soundfont_path):
-            return "Error: SoundFont file not found. Please provide a valid .sf2 file."
-        try:
-            subprocess.run(["fluidsynth", "-ni", soundfont_path, midi_path, "-F", wav_path, "-r", "44100"], check=True)
-            AudioSegment.converter = "ffmpeg"
-            audio = AudioSegment.from_wav(wav_path)
-            audio.export(mp3_path, format="mp3")
-            return mp3_path
-        except Exception as e:
-            return f"Error converting MIDI to audio: {str(e)}"
-
     def generate_svg(self, midi_file, output_file_name):
         return Format_Converter().midi_to_svg_file(tk, midi_file, output_file_name)
 
-    def generate_piano_roll(self, chords, label):
-        fig, ax = plt.subplots(figsize=(8, 4))
-
-        for i, chord in enumerate(chords):
-            for note in chord:
-                ax.broken_barh([(i * 1, 0.8)], (note.pitch.midi - 0.4, 0.8), facecolors='blue')
-
-        ax.set_xlabel("Chord Progression")
-        ax.set_ylabel("MIDI Note Number")
-        min_min_chords = 128
-        max_max_chords = 0
-        for ch in chords:
-            for note in ch:
-                if note.pitch.midi < min_min_chords:
-                    min_min_chords = note.pitch.midi
-                if note.pitch.midi > max_max_chords:
-                    max_max_chords = note.pitch.midi
-        ax.set_yticks(range(min_min_chords, max_max_chords + 1, 2))
-        ax.set_xticks(range(len(chords)))
-        ax.set_xticklabels([f"Chord {i + 1}" for i in range(len(chords))])
-
-        plt.grid(True, linestyle='--', alpha=0.5)
-        plt.savefig(label)
-        return label
-
     def launch_score_editor(self, midi_path):
         try:
             score = converter.parse(midi_path)
@@ -179,19 +125,30 @@ class HexachordApp:
 
     def process_hexachord(self, hexachord_str, itvl):
         try:
-            # notes = [note.Note(n) for n in hexachord_str.split()]
             notes = self.build_octave_dependent_notes_from_string(hexachord_str)
             if len(notes) != 6 or len(set(notes)) != 6:
                 return "Please enter exactly 6 unique notes."
         except ValueError:
             return "Invalid input. Enter 6 notes separated by spaces."
+        fm = Format_Converter()
         chords = self.generate_chords(notes, itvl)
         midi_path = self.create_midi(chords, "base_chords.mid")
-        score_path = self.generate_svg (midi_path, "score_base_chords.svg")
-        audio_path = self.convert_midi_to_audio(midi_path, "base_chords")
-        # return midi_path, piano_roll_path, audio_path
+        score_path = fm.midi_to_svg_file(tk, midi_path, "score_base_chords.svg")
+        audio_path = fm.convert_midi_to_audio(midi_path, "base_chords")
         return (midi_path, score_path, audio_path) + self.generate_realizations()
 
+    def generate_movements(self):
+        # take 2 realizations of the same root
+        everyone = ()
+        for index_of_chord in range(6):
+            chords = [real[index_of_chord] for real in self._hexachord._realizations]
+            fm = Format_Converter()
+            midi_path = self.create_midi(chords, "movement1.mid")
+            score_path = fm.midi_to_svg_file(tk, midi_path, "movement1.svg")
+            audio_path = fm.convert_midi_to_audio(midi_path, "movement1")
+            everyone = everyone + (midi_path, score_path, audio_path)
+        return everyone
+
     def render(self):
         with gr.Blocks() as ui:
             gr.Markdown("# Hexachord-based Chord Generator")
@@ -245,7 +202,21 @@ class HexachordApp:
 
                 with gr.TabItem("Movements"):
                     gr.Markdown("Movements")
-
+                    with gr.Row():
+                        generate_mvmt_button = gr.Button("Generate Movements")
+                    realization_outputs = []
+                    for i in range(6):  # Three alternative realizations
+                        with gr.Row():
+                            gr.Markdown(f"#### Movement {i + 1}")
+                            midi_output = gr.File(label="Download MIDI File", scale=1)
+                            piano_roll = gr.Image(label=f"Piano Roll {i + 1}", scale=3)
+                            audio_player = gr.Audio(label=f"Play Chords {i + 1}", interactive=False, scale=3)
+                            realization_outputs += (midi_output, piano_roll, audio_player)
+                    generate_mvmt_button.click(
+                        fn=self.generate_movements,
+                        inputs=[],
+                        outputs = realization_outputs
+                    )
 
                 with gr.TabItem("Settings"):
                     gr.Markdown("### Configuration Options")

format_conversions.py

@@ -1,6 +1,12 @@
 import copy
+import os
 from music21 import converter, musicxml, stream, note, chord, clef
 import verovio
+import shutil
+import subprocess
+from pydub import AudioSegment
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
 class Format_Converter:
 
@@ -142,5 +148,27 @@ class Format_Converter:
             # return f"<p style='color:red'>Error: {e}</p>"
             return output_file
 
+    def convert_midi_to_audio(self, midi_path, file_name):
+        if not shutil.which("fluidsynth"):
+            try:
+                subprocess.run(["apt-get", "update"], check=True)
+                subprocess.run(["apt-get", "install", "-y", "fluidsynth"], check=True)
+            except Exception as e:
+                return f"Error installing Fluidsynth: {str(e)}"
+        wav_path = os.path.join(BASE_DIR, file_name + ".wav")
+        mp3_path = os.path.join(BASE_DIR, file_name + ".mp3")
+        soundfont_path = os.path.join(BASE_DIR, "soundfont.sf2")
+        if not os.path.exists(soundfont_path):
+            return "Error: SoundFont file not found. Please provide a valid .sf2 file."
+        try:
+            subprocess.run(["fluidsynth", "-ni", soundfont_path, midi_path, "-F", wav_path, "-r", "44100"], check=True)
+            AudioSegment.converter = "ffmpeg"
+            audio = AudioSegment.from_wav(wav_path)
+            audio.export(mp3_path, format="mp3")
+            return mp3_path
+        except Exception as e:
+            return f"Error converting MIDI to audio: {str(e)}"
+
+
 if __name__ == '__main__':
     svg_string = Format_Converter().midi_to_svg(verovio.toolkit(), 'output.mid')

hexachords.py

@@ -1,7 +1,6 @@
-from music21 import note, stream, interval, meter, chord, converter, metadata
+from music21 import note, stream, interval, meter, chord
 from ortools.sat.python import cp_model
 
-
 class Hexachord:
     known_hexachords = [
         "6-1	[0,1,2,3,4,5]	Chromatic hexachord",
@@ -24,12 +23,13 @@ class Hexachord:
         "6-Z44A	[0,1,2,5,6,9]	Schoenberg hexachord",
         "6-Z46A	[0,1,2,4,6,9]	Scale of harmonics",
         "6-Z47B	[0,2,3,4,7,9]	Blues scale"]
+    _base_sequence = None
+    _realizations = []
 
     def generate_chord_sequence_from_midi_pitches(self, list_of_mp, intrvl="P5"):
-        return self.generate_chord_sequence([note.Note(mp).nameWithOctave for mp in list_of_mp], intrvl=intrvl)
-
-    def generate_chord_sequence(self, six_notes, intrvl="P5"):
+        return self.generate_base_sequence([note.Note(mp).nameWithOctave for mp in list_of_mp], intrvl=intrvl)
 
+    def generate_base_sequence(self, six_notes, intrvl="P5"):
         fifth = interval.Interval(intrvl)  # Perfect fifth
         all_pc = [n.pitch.pitchClass for n in six_notes]
         all_chords = []
@@ -43,6 +43,7 @@ class Hexachord:
                         current_note = current_note.transpose(-12)
                     ch.add(current_note)
             all_chords.append(ch)
+        self._base_sequence = all_chords
         return all_chords
 
     def generate_3_chords_realizations(self, chord_seq):
@@ -78,7 +79,8 @@ class Hexachord:
                 else:
                     new_ch.add(n)
             res3.append(new_ch)
-        return res1, res2, res3
+        self._realizations =  res1, res2, res3
+        return self._realizations
 
     def chords_to_stream(self, chords, file_name):
         s = stream.Stream()
@@ -162,7 +164,7 @@ if __name__ == '__main__':
     hexa = Hexachord()
     note_names = ["C3", "Eb3", "E3", "F#3", "G3", "Bb3"]
     notes = [note.Note(n) for n in note_names]
-    cs1 = hexa.generate_chord_sequence(notes, intrvl="P4")
+    cs1 = hexa.generate_base_sequence(notes, intrvl="P4")
     # cs1 = generate_chord_sequence(["E3", "G3", "Ab3", "B3", "C4", "Eb4"])
     # cs2 = generate_chord_sequence(["C3", "F3", "F#3", "A3", "B4", "E4"])
     # alternation = alternate_chords(cs1, cs2)