restructured the project a bit, added legacy folder

.gitignore

@@ -19,7 +19,7 @@ __pycache__/
 *.mp3
 *.wav
 *.ly
-output.*
+legacy/output.mei
 temp.*
 
 # Project specific

README.md

@@ -51,7 +51,7 @@ To run this project locally:
 
 1. Local Development:
    ```bash
-   python app.py
+   python working_app_one_score.py
    ```
 
 2. Web Interface:

format_conversions.py

@@ -2,7 +2,6 @@ import copy
 from music21 import converter, musicxml, stream, note, chord, clef
 import verovio
 
-
 class Format_Converter:
 
     def midi_to_musicxml_string_two_staves(midi_path, split_pitch=60):

app_in_progress.py → legacy/app_in_progress.py

@@ -139,7 +139,7 @@ class HexachordApp:
         except ValueError:
             return "Invalid input. Enter 6 MIDI note numbers separated by spaces."
         chords = self.generate_chords(notes, itvl)
-        midi_path = self.create_midi(chords, "base_chords.mid")
+        midi_path = self.create_midi(chords, "../base_chords.mid")
         #piano_roll_path = self.generate_piano_roll(chords, "base_chords.png")
         score_path = self.generate_png (midi_path, "score_base_chords.png")
         audio_path = self.convert_midi_to_audio(midi_path, "base_chords")

legacy/working_app_one_score.py

@@ -0,0 +1,290 @@
+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
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+def get_verovio_resource_path():
+    for path in verovio.__path__:
+        candidate = os.path.join(path, "data")
+        if os.path.exists(candidate):
+            return candidate
+    return None
+
+# Initialize the Verovio toolkit with rendering options
+tk = verovio.toolkit()
+resource_path = get_verovio_resource_path()
+print(f"resource path: {os.listdir(resource_path)}")
+print("[Debug] Using resource path:", resource_path)
+if resource_path:
+    try:
+        tk.setResourcePath(resource_path)
+    except Exception as e:
+        print("[Error] Failed to set resourcePath:", e)
+tk.setOptions({
+    "adjustPageWidth": True,
+    "header": 'none',  # This disables the rendering of the title
+    "scale": 70,
+    "adjustPageHeight": True,
+    "landscape": False,
+})
+print(tk.getOptions())
+
+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
+
+    def is_fsynth_installed(self):
+        try:
+            subprocess.run(["fluidsynth", "--version"], check=True)
+            print('fluidsynth is installed')
+            return True
+        except Exception:
+            print('fluidsynth is NOT installed')
+            return False
+
+    def generate_chords(self, note_names, itvl):
+        # Placeholder for your actual chord generation function
+        # Assuming hexachord is a list of MIDI note numbers
+        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
+
+    def generate_realizations(self):
+        # returns 3 triples of midipath, piano roll, audio player
+        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")
+        audio_path1 = self.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")
+        audio_path2 = self.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")
+        audio_path3 = self.convert_midi_to_audio(midi_path3, "real3")
+        return midi_path1, piano_roll_path1, audio_path1, midi_path2, piano_roll_path2, audio_path2, midi_path3, piano_roll_path3, audio_path3
+
+    def create_midi(self, chords, file_name):
+        mid = MidiFile()
+        track = MidiTrack()
+        mid.tracks.append(track)
+        delta_time = 480 * 4
+        for i_chord, chord in enumerate(chords):
+            for i, note in enumerate(chord):
+                if i == 0 and i_chord != 0:
+                    track.append(Message('note_on', note=note.pitch.midi, velocity=64, time=1))
+                    # track.append(Message('note_on', note=note.pitch.midi, velocity=64, time=0))
+                else:
+                    track.append(Message('note_on', note=note.pitch.midi, velocity=64, time=0))
+            for i, note in enumerate(chord):
+                if i==0:
+                    track.append(Message('note_off', note=note.pitch.midi, velocity=0, time=delta_time - 1))
+                    # track.append(Message('note_off', note=note.pitch.midi, velocity=0, time=delta_time))
+                else:
+                    track.append(Message('note_off', note=note.pitch.midi, velocity=0, time=0))
+        midi_path = os.path.join(BASE_DIR, file_name)
+        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)
+            score.show('musicxml')
+            return "Opened MIDI file in the default score editor!"
+        except Exception as e:
+            return f"Error opening score editor: {str(e)}"
+
+    def build_octave_dependent_notes_from_string(self, note_string):
+        start_octave = 3
+        notes = []
+        previous_note = None
+        for nn in note_string.split():
+            n = note.Note(nn)
+            n.octave = start_octave
+            if previous_note is not None and n.pitch.midi < previous_note.pitch.midi:
+                n.octave = n.octave + 1
+                start_octave += 1
+            notes.append(n)
+            previous_note = n
+        return notes
+
+    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 MIDI note numbers."
+        except ValueError:
+            return "Invalid input. Enter 6 MIDI note numbers separated by spaces."
+        chords = self.generate_chords(notes, itvl)
+        midi_path = self.create_midi(chords, "base_chords.mid")
+        # piano_roll_path = self.generate_piano_roll(chords, "base_chords.png")
+        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
+        return midi_path, score_path, audio_path
+
+    def render(self):
+        with gr.Blocks() as ui:
+            gr.Markdown("# Hexachord-based Chord Generator")
+            with gr.Tabs():
+                with gr.TabItem("Hexachord Generator"):
+                    with gr.Row():
+                        hexachord_selector = gr.Dropdown(label="Select Known Hexachord",
+                                                         choices=self.get_known_hexachords_choice(), value=None, interactive=True)
+                        hexachord_input = gr.Textbox(
+                            label="Enter 6 notes (pitchclass plus octave, separated by spaces)",
+                            value="C D E G A B",
+                            interactive = True
+                        )
+                        interval_switch = gr.Radio(
+                            choices=["fourth", "fifth"],
+                            label="Select Interval",
+                            value="fifth"
+                        )
+                        generate_button = gr.Button("Generate Chords")
+                    with gr.Row():
+                        midi_output = gr.File(label="Download MIDI File", scale=1)
+                        # piano_roll_output = gr.Image(label="Piano Roll Visualization")
+                        score_output = gr.Image(label="Score Visualization", scale=3)
+                        audio_output = gr.Audio(label="Play Generated Chords", value=None, interactive=False, scale=3)
+                    hexachord_selector.change(
+                        fn=self.get_selected_hexachord,
+                        inputs=[hexachord_selector],
+                        outputs=[hexachord_input]
+                    )
+                    generate_button.click(
+                        fn=self.process_hexachord,
+                        inputs=[hexachord_input, interval_switch],
+                        # outputs=[midi_output, piano_roll_output, audio_output]
+                        outputs = [midi_output, score_output, audio_output]
+                    )
+                # Pressing Enter in the textbox also triggers processing
+                    hexachord_input.submit(
+                        fn=self.process_hexachord,
+                        inputs=[hexachord_input, interval_switch],
+                        outputs=[midi_output, score_output, audio_output]
+                    )
+
+                with gr.TabItem("Alternative Chord Realizations"):
+                    gr.Markdown("Alternative Chord Realizations")
+
+                    realization_button = gr.Button("Generate Alternative Realizations")
+                    realization_outputs = []
+
+                    for i in range(3):  # Three alternative realizations
+                        with gr.Group():
+                            gr.Markdown(f"#### Realization {i + 1}")
+                            midi_output = gr.File(label="Download MIDI File")
+                            piano_roll = gr.Image(label=f"Piano Roll {i + 1}")
+                            audio_player = gr.Audio(label=f"Play Chords {i + 1}", interactive=False)
+                            realization_outputs.append((midi_output, piano_roll, audio_player))
+
+                    # Clicking the button triggers realization generation
+                    realization_button.click(
+                        fn=self.generate_realizations,
+                        inputs=[],
+                        outputs=[output for trip in realization_outputs for output in trip]
+                    )
+
+                with gr.TabItem("Settings"):
+                    gr.Markdown("### Configuration Options")
+                    setting_1 = gr.Checkbox(label="Enable Advanced Mode")
+                    setting_2 = gr.Slider(0, 100, label="Complexity Level")
+        self.ui = ui
+
+    def get_known_hexachords_choice(self):
+        return self._hexachord.known_hexachords
+
+    def get_selected_hexachord(self, x):
+        # lambda x: {"Hexachord 1": "C3 D3 E3 G3 A3 B3", "Hexachord 2": "D3 E3 F3 A3 B3 C4",
+        #            "Hexachord 3": "E3 G3 A3 C4 D4 F4"}.get(x, "")
+        item = x[x.index('['):x.index(']')+1]
+        int_array = np.array(ast.literal_eval(item))
+        hexa_string = ''
+        start_note = note.Note('C3')
+        for i in int_array:
+            add_note = start_note.transpose(int(i))
+            hexa_string = hexa_string + ' ' + add_note.nameWithOctave
+        return hexa_string
+
+
+def launch_app():
+    hex = HexachordApp()
+    hex.is_fsynth_installed()
+    hex.render()
+    if hex.on_huggingface:
+        hex.ui.launch(server_name="0.0.0.0", server_port=7860, share=True)
+    else:
+        hex.ui.launch(server_name="0.0.0.0", server_port=7860)
+
+
+launch_app()
+

output.mei

@@ -1,126 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<mei xmlns="http://www.music-encoding.org/ns/mei" meiversion="5.1">
-   <meiHead xml:id="maqjp63">
-      <fileDesc xml:id="f7jp7g9">
-         <titleStmt xml:id="t8iiqsi">
-            <title>Music21 Fragment</title>
-            <respStmt>
-               <persName role="composer">Music21</persName>
-            </respStmt>
-         </titleStmt>
-         <pubStmt xml:id="phleh0y">
-            <date isodate="2025-03-19" type="encoding-date">2025-03-19</date>
-         </pubStmt>
-      </fileDesc>
-      <encodingDesc xml:id="eo6csxx">
-         <appInfo xml:id="a1c3w7ux">
-            <application xml:id="a164khur" isodate="2025-03-19T22:43:27" version="5.1.0-8c3069d">
-               <name xml:id="n1s9x4c2">Verovio</name>
-               <p xml:id="pyiw3j3">Transcoded from MusicXML</p>
-            </application>
-         </appInfo>
-      </encodingDesc>
-   </meiHead>
-   <music>
-      <body>
-         <mdiv xml:id="mbezojg">
-            <score xml:id="s132ublt">
-               <scoreDef xml:id="s18pzn4w">
-                  <staffGrp xml:id="sx01ah5">
-                     <staffDef xml:id="P54fd32f1e7813de141d5e94b173800dd" n="1" lines="5" ppq="10080">
-                        <clef xml:id="cuxwkmr" shape="G" line="2" />
-                        <meterSig xml:id="m3eod4t" count="4" unit="4" />
-                     </staffDef>
-                  </staffGrp>
-               </scoreDef>
-               <section xml:id="s14syw2w">
-                  <measure xml:id="m1lvm0yy" n="1">
-                     <staff xml:id="s1b6zc5j" n="1">
-                        <layer xml:id="l1csnxpz" n="1">
-                           <chord xml:id="ck94yh6" dur.ppq="40320" dur="1">
-                              <note xml:id="ngp84u5" oct="3" pname="c" />
-                              <note xml:id="nde028f" oct="3" pname="g" />
-                              <note xml:id="n1yg2sol" oct="4" pname="d" />
-                              <note xml:id="nonpwmg" oct="4" pname="a" />
-                              <note xml:id="n1n8asow" oct="5" pname="e" />
-                              <note xml:id="n1ldxmuk" oct="5" pname="b" />
-                           </chord>
-                        </layer>
-                     </staff>
-                  </measure>
-                  <measure xml:id="m14inp6s" n="2">
-                     <staff xml:id="s1lhc1b1" n="1">
-                        <layer xml:id="lsqjdvd" n="1">
-                           <chord xml:id="ciuhgaf" dur.ppq="40320" dur="1">
-                              <note xml:id="ne6ljq2" oct="3" pname="d" />
-                              <note xml:id="n1kvdtq9" oct="3" pname="a" />
-                              <note xml:id="n1xr0clo" oct="4" pname="e" />
-                              <note xml:id="nrbjlqa" oct="4" pname="b" />
-                              <note xml:id="n28mjc0" oct="6" pname="c" />
-                              <note xml:id="nlw8k83" oct="6" pname="g" />
-                           </chord>
-                        </layer>
-                     </staff>
-                  </measure>
-                  <measure xml:id="m1trdq8d" n="3">
-                     <staff xml:id="sxxezgl" n="1">
-                        <layer xml:id="l1hinj87" n="1">
-                           <chord xml:id="c2m0w8t" dur.ppq="40320" dur="1">
-                              <note xml:id="nsgm2a0" oct="3" pname="e" />
-                              <note xml:id="n1wvcozg" oct="3" pname="b" />
-                              <note xml:id="n1bc7t89" oct="5" pname="c" />
-                              <note xml:id="n1gsv9bl" oct="5" pname="g" />
-                              <note xml:id="n1slsoot" oct="6" pname="d" />
-                              <note xml:id="np4pub2" oct="6" pname="a" />
-                           </chord>
-                        </layer>
-                     </staff>
-                  </measure>
-                  <measure xml:id="mb4850f" n="4">
-                     <staff xml:id="s1didadp" n="1">
-                        <layer xml:id="l1vc3d6s" n="1">
-                           <chord xml:id="c1271to" dur.ppq="40320" dur="1">
-                              <note xml:id="nfhf7lb" oct="3" pname="g" />
-                              <note xml:id="n1hsnwjo" oct="4" pname="d" />
-                              <note xml:id="n1ea78x5" oct="4" pname="a" />
-                              <note xml:id="nonhxoz" oct="5" pname="e" />
-                              <note xml:id="n2tp0ge" oct="5" pname="b" />
-                              <note xml:id="n1keg9ge" oct="7" pname="c" />
-                           </chord>
-                        </layer>
-                     </staff>
-                  </measure>
-                  <measure xml:id="m1cfva6" n="5">
-                     <staff xml:id="sbphnat" n="1">
-                        <layer xml:id="lulnle2" n="1">
-                           <chord xml:id="c1hbxjwb" dur.ppq="40320" dur="1">
-                              <note xml:id="nwzeofb" oct="3" pname="a" />
-                              <note xml:id="n56onxs" oct="4" pname="e" />
-                              <note xml:id="n77tugx" oct="4" pname="b" />
-                              <note xml:id="n15a2loc" oct="6" pname="c" />
-                              <note xml:id="n1xwblav" oct="6" pname="g" />
-                              <note xml:id="n1y7kzmd" oct="7" pname="d" />
-                           </chord>
-                        </layer>
-                     </staff>
-                  </measure>
-                  <measure xml:id="m959oif" right="end" n="6">
-                     <staff xml:id="sxe147o" n="1">
-                        <layer xml:id="l1n1reed" n="1">
-                           <chord xml:id="civ4vs9" dur.ppq="40320" dur="1">
-                              <note xml:id="n1q55ord" oct="3" pname="b" />
-                              <note xml:id="n6a3qk" oct="5" pname="c" />
-                              <note xml:id="n1fetjh5" oct="5" pname="g" />
-                              <note xml:id="nfc1bgg" oct="6" pname="d" />
-                              <note xml:id="nk15vap" oct="6" pname="a" />
-                              <note xml:id="n1939asj" oct="7" pname="e" />
-                           </chord>
-                        </layer>
-                     </staff>
-                  </measure>
-               </section>
-            </score>
-         </mdiv>
-      </body>
-   </music>
-</mei>