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

app.py

@@ -3,12 +3,14 @@ import gradio as gr
 import numpy as np
 from mido import Message, MidiFile, MidiTrack
 import os
-from music21 import converter, note
+from music21 import converter, note, stream, chord, tempo, meter
 import hexachords
 from format_conversions import Format_Converter
 import verovio
 import subprocess
 
+from legacy.essai_mido_to_xml import midi_path
+
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
 def get_verovio_resource_path():
@@ -54,8 +56,6 @@ class HexachordApp:
             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'
@@ -63,40 +63,20 @@ class HexachordApp:
 
     def generate_realizations(self):
         # 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")
-        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")
-        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")
-        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):
-        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))
+        all_paths = []
+        fm = Format_Converter()
+        for i, real in enumerate(reals):
+            midi_path = f"real{i}.mid"
+            all_paths.append(self.create_midi_file(real, midi_path))
+            all_paths.append(fm.midi_to_svg_file(tk, midi_path, f"real{i}.svg"))
+            all_paths.append(fm.convert_midi_to_audio(midi_path, f"real{i}"))
+        return tuple(all_paths)
+
+    def create_midi_file(self, chords, file_name, duration_in_quarter_lengths=4.0, tempo_bpm=120, time_signature="4/4"):
         midi_path = os.path.join(BASE_DIR, file_name)
-        mid.save(midi_path)
-        return midi_path
+        self._hexachord.save_chords_to_midi_file(chords, midi_path)
+        return file_name
 
     def generate_svg(self, midi_file, output_file_name):
         return Format_Converter().midi_to_svg_file(tk, midi_file, output_file_name)
@@ -132,7 +112,7 @@ class HexachordApp:
             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")
+        midi_path = self.create_midi_file(chords, "base_chords.mid")
         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()
@@ -143,7 +123,7 @@ class HexachordApp:
         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, f"movement{index_of_chord}.mid")
+            midi_path = self.create_midi_file(chords, f"movement{index_of_chord}.mid")
             score_path = fm.midi_to_svg_file(tk, midi_path, f"movement{index_of_chord}.svg")
             audio_path = fm.convert_midi_to_audio(midi_path, f"movement{index_of_chord}")
             everyone = everyone + (midi_path, score_path, audio_path)

format_conversions.py

@@ -53,66 +53,13 @@ class Format_Converter:
         musicxml_str = exporter.parse().decode('utf-8')
         return musicxml_str
 
-    @classmethod
-    def midi_to_musicxml_string_two_staves_old(cls, midi_path):
-        # Parse MIDI file into a music21 stream
-        score = converter.parse(midi_path)
-        score = score.flattenParts()
-        # Create a new Score with two staves: Treble and Bass
-        treble = stream.Part()
-        bass = stream.Part()
-        treble.id = 'Treble'
-        bass.id = 'Bass'
-        # Assign clefs (optional but recommended)
-        from music21 import clef
-        treble.insert(0, clef.TrebleClef())
-        bass.insert(0, clef.BassClef())
-        split_pitch = 60
-        # Split notes by pitch (simple heuristic)
-        treble_voice = stream.Voice()
-        bass_voice = stream.Voice()
-        for el in score.recurse().notesAndRests:
-            true_offset = el.getOffsetInHierarchy(score)
-            if isinstance(el, note.Rest):
-                # Send same rest to both staves (or adjust as needed)
-                treble.insert(true_offset, el)
-                bass.insert(true_offset, el)
-
-            elif isinstance(el, note.Note):
-                target = treble if el.pitch.midi >= split_pitch else bass
-                target.insert(true_offset, el)
-
-            elif isinstance(el, chord.Chord):
-                # Split the chord into individual notes
-                for p in el.pitches:
-                    n = note.Note(p)
-                    n.quarterLength = el.quarterLength
-                    n.volume = el.volume
-                    if p.midi >= split_pitch:
-                        treble_voice.insert(true_offset, n)
-                    else:
-                        bass_voice.insert(true_offset, n)
-        # Combine the two parts into a score
-        treble.append(treble_voice)
-        bass.append(bass_voice)
-        new_score = stream.Score()
-        new_score.insert(0, treble)
-        new_score.insert(0, bass)
-        # staff_group = StaffGroup([bass, treble], symbol='brace', barTogether=True)
-        # new_score.insert(0, staff_group)
-        # Export to MusicXML string
-        exporter = musicxml.m21ToXml.GeneralObjectExporter(new_score)
-        musicxml_str = exporter.parse().decode('utf-8')  # parse() returns bytes
-        return musicxml_str
-
     @classmethod
     def midi_to_musicxml_string(cls, midi_path):
         # Parse MIDI file into a music21 stream
         score = converter.parse(midi_path)
         # Export to MusicXML string
         exporter = musicxml.m21ToXml.GeneralObjectExporter(score)
-        musicxml_str = exporter.parse().decode('utf-8')  # parse() returns bytes
-        return musicxml_str
+        return exporter.parse().decode('utf-8')  # parse() returns bytes
 
     @classmethod
     def xml_to_mei_string(cls, tk, xmlstring):
@@ -123,8 +70,8 @@ class Format_Converter:
     def midi_to_svg(cls, tk, midi_path):
         try:
             # Convert MIDI to MEI using music21
-            musicxml = cls.midi_to_musicxml_string(midi_path)
-            mei_str = cls.xml_to_mei_string(tk, musicxml)
+            musicxmlobj = cls.midi_to_musicxml_string(midi_path)
+            mei_str = cls.xml_to_mei_string(tk, musicxmlobj)
             # Load MEI and render SVG
             tk.loadData(mei_str)
             svg = tk.renderToSVG(1)
@@ -132,7 +79,6 @@ class Format_Converter:
         except Exception as e:
             return f"<p style='color:red'>Error: {e}</p>"
 
-
     @classmethod
     def midi_to_svg_file(cls, tk, midi_path, output_file):
         try:
@@ -148,6 +94,29 @@ class Format_Converter:
             # return f"<p style='color:red'>Error: {e}</p>"
             return output_file
 
+    @classmethod
+    def m21_to_xml(cls, m21):
+        # Export to MusicXML string
+        exporter = musicxml.m21ToXml.GeneralObjectExporter()
+        return exporter.parse(m21).decode('utf-8')
+
+    @classmethod
+    def m21_to_svg_file(cls, m21, output_file):
+        # Export to MusicXML string
+        exporter = musicxml.m21ToXml.GeneralObjectExporter()
+        musicxmlobj = exporter.parse(m21).decode('utf-8')
+        try:
+            tk = verovio.toolkit()
+            mei_str = cls.xml_to_mei_string(tk, musicxmlobj)
+            # Load MEI and render SVG
+            tk.loadData(mei_str)
+            svg = tk.renderToSVGFile(output_file)
+            return output_file
+        except Exception as e:
+            print("error in midi_to_svg_file")
+            # 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:

hexachords.py

@@ -1,3 +1,6 @@
+import os
+
+from mido import MidiFile, Message, MidiTrack
 from music21 import note, stream, interval, meter, chord
 from ortools.sat.python import cp_model
 
@@ -82,17 +85,30 @@ class Hexachord:
         self._realizations =  res1, res2, res3
         return self._realizations
 
-    def chords_to_stream(self, chords, file_name):
+    def chords_to_m21(self, chords):
         s = stream.Stream()
         s.append(meter.TimeSignature("4/4"))
         for c in chords:
             ch = chord.Chord(c)
             ch.duration.quarterLength = 4
             s.append(ch)
-        # s.show('midi')
-        s.write('midi', file_name)
         return s
 
+    def chords_to_m21_voices(self, chords):
+        s = stream.Stream()
+        s.append(meter.TimeSignature("4/4"))
+        for i_chord, c in enumerate(chords):
+            for chord_note in c:
+                n = note.Note(chord_note.pitch)
+                n.duration.quarterLength = 4
+                s.insert(i_chord * 4, n)
+        return s
+
+    def save_chords_to_midi_file(self, chords, file_name):
+        m21 = self.chords_to_m21_voices(chords)
+        m21.write('midi', file_name)
+        return file_name
+
     def alternate_chords(self, s1, s2):
         """Create a new stream alternating between chords from s1 and s2"""
         new_stream = stream.Stream()
@@ -160,6 +176,7 @@ class Hexachord:
 
         return optimized_chords
 
+
 if __name__ == '__main__':
     hexa = Hexachord()
     note_names = ["C3", "Eb3", "E3", "F#3", "G3", "Bb3"]
@@ -170,7 +187,7 @@ if __name__ == '__main__':
     # alternation = alternate_chords(cs1, cs2)
     # alternation.write('midi',"alternation.mid")
 
-    hexa.chords_to_stream(cs1, 'temp.mid').show('text')
+    hexa.save_chords_to_midi_file(cs1, 'temp.mid')
     # optimized = optimize_voice_leading([c1, c2, c3])
     optimized = hexa.optimize_voice_leading(cs1)
     stream1 = stream.Stream(optimized)

legacy/essai.py

@@ -1,37 +0,0 @@
-import verovio
-import os
-
-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
-
-def render_mei(mei_path):
-    tk = verovio.toolkit()
-    # Set resource path explicitly
-    resource_path = get_verovio_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({
-    #     "font": "/app/data/Bravura",  # Path to the font folder
-    # })
-    with open(mei_path, "r", encoding="utf-8") as f:
-        mei_data = f.read()
-    # tk.loadFile("path-to-mei-file")
-    # return tk.renderToSVG(1)
-
-    try:
-        tk.loadData(mei_data)
-        return tk.renderToSVG(1)
-    except Exception as e:
-        return f"<pre>Rendering failed:\n{e}</pre>"
-
-
-string = render_mei("output.mei")
-print(string)

legacy/essai_m21_to_xml_Measure.py

@@ -0,0 +1,44 @@
+from music21 import stream, note, tie, meter
+# working version but using Measure
+from format_conversions import Format_Converter
+
+# Create Voice 1 (tied C4 over two half notes)
+voice1 = stream.Voice()
+n1 = note.Note('C4', quarterLength=2.0)
+n1.tie = tie.Tie('start')
+n2 = note.Note('C4', quarterLength=2.0)
+n2.tie = tie.Tie('stop')
+voice1.append([n1, n2])
+voice1.append(note.Note('E4', quarterLength=2.0))
+
+# Create Voice 2 (a single E4 half note)
+voice2 = stream.Voice()
+voice2.append(note.Note('E4', quarterLength=2.0))
+voice2.append(note.Note('G4', quarterLength=2.0))
+voice2.append(note.Note('C5', quarterLength=2.0))
+voice2.append(note.Note('D5', quarterLength=2.0))
+voice2.append(note.Note('E5', quarterLength=2.0))
+voice2.append(note.Note('G5', quarterLength=2.0))
+
+voice3 = stream.Voice()
+voice3.append(note.Note('G4', quarterLength=2.0))
+voice3.append(note.Note('C5', quarterLength=2.0))
+voice3.append(note.Note('E5', quarterLength=2.0))
+
+# Put both voices into a Measure
+measure = stream.Measure()
+measure.timeSignature = meter.TimeSignature('4/4')  # optional, but helpful
+measure.insert(0, voice1)
+measure.insert(0, voice2)
+measure.insert(0, voice3)
+
+# Wrap in a Part and Score
+part = stream.Part()
+part.append(measure)
+
+score = stream.Score()
+score.append(part)
+
+# Write to MusicXML
+score.write('musicxml', fp='two_voice_example.musicxml')
+Format_Converter().m21_to_svg_file(score, "output.svg")

legacy/essai_mido_to_xml.py

@@ -0,0 +1,27 @@
+import os
+
+import verovio
+from mido import MidiFile, MidiTrack, Message
+from music21 import stream
+
+from format_conversions import Format_Converter
+
+mid = MidiFile()
+track = MidiTrack()
+mid.tracks.append(track)
+delta_time = 480 * 4
+
+track.append(Message('note_on', note=60, velocity=64, time=0))
+track.append(Message('note_on', note=64, velocity=64, time=0))
+
+track.append(Message('note_off', note=60, velocity=0, time=delta_time))
+track.append(Message('note_on', note=62, velocity=64, time=0))
+track.append(Message('note_off', note=62, velocity=0, time=delta_time))
+track.append(Message('note_off', note=64, velocity=0, time=0))
+
+midi_path = os.path.join("","output.mid")
+mid.save(midi_path)
+str = Format_Converter().midi_to_musicxml_string("output.mid")
+with open("output.musicxml", "a") as f:
+    f.write(str)
+Format_Converter().midi_to_svg_file(verovio.toolkit(), "output.mid", "output2.svg")

legacy/essai_music21_to_xml.py

@@ -0,0 +1,33 @@
+from music21 import stream, chord, note, tie
+
+from format_conversions import Format_Converter
+
+# Create two voices
+voice1 = stream.Voice()
+voice2 = stream.Voice()
+
+n1 = note.Note('C4', quarterLength=2.0)
+voice1.append(n1)
+n2 = note.Note('C4', quarterLength=2.0)
+voice1.append(n2)
+
+voice2.append(note.Note('E4', quarterLength=2.0))
+voice2.append(note.Note('G4', quarterLength=2.0))
+# voice2.append(note.Note('A4', quarterLength=2.0))
+
+n1.tie = tie.Tie('start')     # beginning of tie
+n2.tie = tie.Tie('stop')
+# Combine them into a part
+part = stream.Part()
+part.insert(0, voice1)
+part.insert(0, voice2)
+
+score = stream.Score()
+score.append(part)
+# score.show('midi')
+# score.show('musicxml')
+Format_Converter().m21_to_svg_file(score, 'essai.svg')
+score.write('musicxml', fp='my_score.musicxml')
+# xml = Format_Converter().m21_to_xml(score)
+# with open("my_score.musicxml", "w", encoding="utf-8") as f:
+#     f.write(xml)

legacy/example.mei

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<mei xmlns="http://www.music-encoding.org/ns/mei" meiversion="4.0.0">
-  <music>
-    <body>
-      <mdiv>
-        <score>
-          <scoreDef>
-            <staffGrp>
-              <staffDef n="1" lines="5"/>
-            </staffGrp>
-          </scoreDef>
-          <section>
-            <measure n="1">
-              <staff n="1">
-                <layer n="1">
-                  <note pname="c" oct="4" dur="4"/>
-                  <note pname="d" oct="4" dur="4"/>
-                  <note pname="e" oct="4" dur="4"/>
-                  <note pname="f" oct="4" dur="4"/>
-                </layer>
-              </staff>
-            </measure>
-          </section>
-        </score>
-      </mdiv>
-    </body>
-  </music>
-</mei>