created working versions folder with a working version with piano rolls.

convert_to_svg.cjs

@@ -7,7 +7,7 @@ verovio.module.onRuntimeInitialized = function ()
     // create the toolkit instance
     const vrvToolkit = new verovio.toolkit();
     // read the MEI file
-    mei = fs.readFileSync('hello.mei');
+    mei = fs.readFileSync('output.mei');
     // load the MEI data as string into the toolkit
     vrvToolkit.loadData(mei.toString());
     // render the fist page as SVG

new_app.py

@@ -188,6 +188,16 @@ class HexachordApp:
 
         return midi_path, score_path, audio_path
 
+    def midi_to_musicxml_string(self, midi_file):
+        #     midi_file_path = "example.mid"  # Replace with your MIDI file
+        #     musicxml_string = midi_to_musicxml_string(midi_file_path)
+        #     print(musicxml_string)
+        """Convert MIDI to MusicXML string using music21."""
+        score = converter.parse(midi_file)
+        return score.write('musicxml')
+    # Example usage
+
+
     def render(self):
         with gr.Blocks() as ui:
             gr.Markdown("# Hexachord-based Chord Generator")

working_version.py

@@ -1,223 +1,46 @@
-import shutil
-import gradio as gr
-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
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-
-class HexachordApp:
-
-    def __init__(self):
-        self._hexachord = None
-        self._hexachord_base_sequence = None
-        self.ui = None
-        self.on_huggingface = "HUGGINGFACE_SPACE" in os.environ
-
-    def is_fsynth_installed(self):
-        """ Check to make sure fluidsynth exists in the PATH """
-        for path in os.environ['PATH'].split(os.pathsep):
-            f = os.path.join(path, 'fluidsynth')
-            if os.path.exists(f) and os.access(f, os.X_OK):
-                print('fluidsynth is installed')
-                return True
-        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
-        self._hexachord = hexachords.Hexachord()
-        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))
-                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))
-                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_png(self, midi_file, output_file_name):
-        self._hexachord.midi_to_png(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 process_hexachord(self, hexachord_str, itvl):
-        try:
-            notes = [note.Note(n) for n in hexachord_str.split()]
-            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."
-        self._hexachord = notes
-        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_png (midi_path, "score_base_chords.png")
-        audio_path = self.convert_midi_to_audio(midi_path, "base_chords")
-
-        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_input = gr.Textbox(
-                            label="Enter 6 notes (pitchclass plus octave, separated by spaces)",
-                            value="C3 D3 E3 G3 A3 B3",
-                            interactive = True
-                        )
-                        interval_switch = gr.Radio(
-                            choices=["fourth", "fifth"],
-                            label="Select Interval",
-                            value="fifth"
-                        )
-                        generate_button = gr.Button("Generate Chords")
-                    midi_output = gr.File(label="Download MIDI File")
-                    # piano_roll_output = gr.Image(label="Piano Roll Visualization")
-                    score_output = gr.Image(label="Score Visualization")
-                    audio_output = gr.Audio(label="Play Generated Chords", value=None, interactive=False)
-
-                    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))
+import requests
+from music21 import converter
+
+
+def midi_to_musicxml(midi_file):
+    """Convert MIDI to MusicXML using music21."""
+    score = converter.parse(midi_file)
+    musicxml_path = "temp.musicxml"
+    score.write('musicxml', fp=musicxml_path)
+    return musicxml_path
+
+
+def convert_musicxml_to_svg_online(musicxml_path):
+    """Send MusicXML file to Verovio API and get SVG output."""
+    url = "https://verovio.humdrum.org/cgi-bin/verovio.cgi"
+    with open(musicxml_path, "rb") as file:
+        files = {
+            "file": ("score.musicxml", file, "application/xml"),
+            "format": (None, "svg"),  # Request SVG format
+        }
+        response = requests.post(url, files=files)
+    if response.status_code == 200:
+        return response.text  # SVG content
+    else:
+        return f"Error: {response.status_code}, {response.text}"
 
-                    # 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 midi_to_svg(midi_file):
+    """Convert MIDI to SVG using Verovio Web API."""
 
+    # Step 1: Convert MIDI to MusicXML
+    musicxml_path = midi_to_musicxml(midi_file)
+    # Step 2: Convert MusicXML to SVG via Verovio API
+    svg_content = convert_musicxml_to_svg_online(musicxml_path)
+    # Save SVG
+    output_svg = "output.svg"
+    with open(output_svg, "w") as f:
+        f.write(svg_content)
+    return output_svg
 
-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)
-    else:
-        hex.ui.launch()
 
+# Example Usage
+midi_file_path = "base_chords.mid"  # Replace with actual MIDI file
+svg_output = midi_to_svg(midi_file_path)
 
-launch_app()
+print(f"SVG file generated: {svg_output}")

working_versions/app.py

@@ -0,0 +1,252 @@
+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, interval
+from pydub import AudioSegment
+import hexachords
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+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):
+        """ Check to make sure fluidsynth exists in the PATH """
+        for path in os.environ['PATH'].split(os.pathsep):
+            f = os.path.join(path, 'fluidsynth')
+            if os.path.exists(f) and os.access(f, os.X_OK):
+                print('fluidsynth is installed')
+                return True
+        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))
+                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))
+                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_png(self, midi_file, output_file_name):
+        self._hexachord.midi_to_png(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 process_hexachord(self, hexachord_str, itvl):
+        try:
+            notes = [note.Note(n) for n in hexachord_str.split()]
+            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_png (midi_path, "score_base_chords.png")
+        audio_path = self.convert_midi_to_audio(midi_path, "base_chords")
+
+        return midi_path, piano_roll_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="C3 D3 E3 G3 A3 B3",
+                            interactive = True
+                        )
+                        interval_switch = gr.Radio(
+                            choices=["fourth", "fifth"],
+                            label="Select Interval",
+                            value="fifth"
+                        )
+                        generate_button = gr.Button("Generate Chords")
+                    midi_output = gr.File(label="Download MIDI File")
+                    # piano_roll_output = gr.Image(label="Piano Roll Visualization")
+                    score_output = gr.Image(label="Score Visualization")
+                    audio_output = gr.Audio(label="Play Generated Chords", value=None, interactive=False)
+
+                    hexachord_selector.change(
+                        fn=self.get_selected_hexachord,
+                        inputs=[hexachord_selector],
+                        outputs=[hexachord_input]
+                    )
+                    # generate_button.click(
+                    #     fn=self.process_hexachord,
+                    #     inputs=[hexachord_selector, interval_switch],
+                    #     outputs=[midi_output, score_output, audio_output]
+                    # )
+
+                    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)
+    else:
+        hex.ui.launch()
+
+
+launch_app()
+

working_versions/hexachords.py

@@ -0,0 +1,208 @@
+import os
+import subprocess
+from music21 import note, stream, interval, meter, chord, converter, metadata
+from ortools.sat.python import cp_model
+from verovio import verovio
+
+
+class Hexachord:
+    known_hexachords = [
+        "6-1	[0,1,2,3,4,5]	Chromatic hexachord",
+        "6-7	[0,1,2,6,7,8]	Two-semitone tritone scale",
+        "6-Z17A	[0,1,2,4,7,8]	All-trichord hexachord",
+        "6-20	[0,1,4,5,8,9]	Augmented scale, Ode-to-Napoleon hexachord",
+        "6-Z24A	[0,1,3,4,6,8]	Minor major eleventh chord",
+        "6-Z24B	[0,2,4,5,7,8]	Half-diminished eleventh chord",
+        "6-Z25A	[0,1,3,5,6,8]	Major eleventh chord",
+        "6-Z26	[0,1,3,5,7,8]	Major ninth sharp eleventh chord",
+        "6-27B	[0,2,3,5,6,9]	Diminished eleventh chord",
+        "6-Z28	[0,1,3,5,6,9]	Augmented major eleventh chord",
+        "6-Z29	[0,2,3,6,7,9]	Bridge chord",
+        "6-30B	[0,2,3,6,8,9]	Petrushka chord, tritone scale",
+        "6-32	[0,2,4,5,7,9]	Diatonic hexachord, minor eleventh chord",
+        "6-33B	[0,2,4,6,7,9]	Dominant eleventh chord",
+        "6-34A	[0,1,3,5,7,9]	Mystic chord",
+        "6-34B	[0,2,4,6,8,9]	Augmented eleventh chord, dominant sharp eleventh chord, Prélude chord",
+        "6-35	[0,2,4,6,8,T]	Whole tone scale",
+        "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"]
+
+    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"):
+
+        fifth = interval.Interval(intrvl)  # Perfect fifth
+        all_pc = [n.pitch.pitchClass for n in six_notes]
+        all_chords = []
+        for n in six_notes:
+            ch = chord.Chord([n])
+            current_note = n
+            while len(ch) < 6:
+                current_note = fifth.transposeNote(current_note)
+                if current_note.pitch.pitchClass in all_pc and current_note not in ch:
+                    while interval.Interval(noteStart=ch[-1], noteEnd=current_note).semitones > (12 + 7):
+                        current_note = current_note.transpose(-12)
+                    ch.add(current_note)
+            all_chords.append(ch)
+        return all_chords
+
+    def generate_3_chords_realizations(self, chord_seq):
+        # lower each of the top to notes by 2 ocatves
+        res1 = []
+        res2 = []
+        res3 = []
+        for ch in chord_seq:
+            new_ch = chord.Chord()
+            for i, n in enumerate(ch.notes):
+                if i == 4 or i == 5:
+                    new_ch.add(n.transpose(-24))
+                else:
+                    new_ch.add(n)
+            res1.append(new_ch)
+        for ch in chord_seq:
+            new_ch = chord.Chord()
+            for i, n in enumerate(ch.notes):
+                if i == 4 or i == 5:
+                    new_ch.add(n.transpose(-24))
+                elif i == 3:
+                    new_ch.add(n.transpose(-12))
+                else:
+                    new_ch.add(n)
+            res2.append(new_ch)
+        for ch in chord_seq:
+            new_ch = chord.Chord()
+            for i, n in enumerate(ch.notes):
+                if i == 4 or i == 5:
+                    new_ch.add(n.transpose(-24))
+                elif i == 3 or i == 2:
+                    new_ch.add(n.transpose(-12))
+                else:
+                    new_ch.add(n)
+            res3.append(new_ch)
+        return res1, res2, res3
+
+    def chords_to_stream(self, chords, file_name):
+        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 alternate_chords(self, s1, s2):
+        """Create a new stream alternating between chords from s1 and s2"""
+        new_stream = stream.Stream()
+
+        # Get chords from both streams
+        chords1 = list(s1.getElementsByClass(chord.Chord))
+        chords2 = list(s2.getElementsByClass(chord.Chord))
+
+        # Interleave chords from s1 and s2
+        for c1, c2 in zip(chords1, chords2):
+            new_stream.append(c1)
+            new_stream.append(c2)
+        return new_stream
+
+    def optimize_voice_leading(self, chord_sequence):
+        model = cp_model.CpModel()
+        octave_variables = {}
+        movement_vars = []
+
+        # Define variables and domains (allowing octave shifts)
+        for i, ch in enumerate(chord_sequence):
+            for n in ch.notes:
+                var_name = f"chord_{i}_note_{n.nameWithOctave}"
+                octave_variables[var_name] = model.NewIntVar(n.octave - 1, n.octave + 1,
+                                                             var_name)  # Allow octave shifts
+        spread_vars = []
+        # Add constraints to minimize movement between chords
+        for i in range(len(chord_sequence) - 1):
+            max_octave = model.NewIntVar(0, 10, "max_pitch" + str(i))
+            min_octave = model.NewIntVar(0, 10, "min_pitch" + str(i))
+            for n in chord_sequence[i]:
+                v = octave_variables[f"chord_{i}_note_{n.nameWithOctave}"]
+                # model.Add(max_pitch >= v)  # max_pitch must be at least as high as any note
+                # model.Add(min_pitch <= v)  # min_pitch must
+            spread_var = max_octave - min_octave
+            spread_vars.append(spread_var)
+        for i in range(len(chord_sequence) - 1):
+            for n1, n2 in zip(chord_sequence[i].notes, chord_sequence[i + 1].notes):
+                var1 = octave_variables[f"chord_{i}_note_{n1.nameWithOctave}"]
+                var2 = octave_variables[f"chord_{i + 1}_note_{n2.nameWithOctave}"]
+                # Define movement variable
+                movement_var = model.NewIntVar(0, 36, f"movement_{i}_{n1.name}")
+                model.AddAbsEquality(movement_var, var2 - var1)
+                # Track movement variable in objective function
+                movement_vars.append(movement_var)
+        # Define objective: minimize sum of all movement values
+        model.Minimize(sum(spread_vars))
+        # obj_var = sum(movement_vars)
+        # model.Minimize(obj_var)
+        # Solve
+        solver = cp_model.CpSolver()
+        solver.Solve(model)
+        # print(solver.Value(obj_var))
+        # for v in variables:
+        #     print(v)
+        #     print(variables[v].Proto().domain)
+        #     print(solver.Value(variables[v]))
+        # Apply changes to music21 chord sequence
+        optimized_chords = []
+        for i, ch in enumerate(chord_sequence):
+            new_chord = chord.Chord(
+                [note.Note(f"{n.name}{solver.Value(octave_variables[f'chord_{i}_note_{n.nameWithOctave}'])}")
+                 for n in ch.notes])
+            optimized_chords.append(new_chord)
+
+        return optimized_chords
+
+    def midi_to_svg_file(self, midi_file, output_file):
+        score = converter.parse(midi_file)
+        musicxml_data = score.write('musicxml')  # Get MusicXML as a string
+        # Step 2: Load MusicXML into Verovio
+        tk = verovio.toolkit()
+        tk.loadData(musicxml_data.encode())  # Convert to bytes and load into Verovio
+        tk.renderToSVGFile(output_file, 1)
+
+    def midi_to_svg(self, midi_file, svg_output):
+        """Convert MIDI to SVG using Verovio's command-line tool."""
+        score = converter.parse(midi_file)
+        score.metadata = metadata.Metadata()
+        score.metadata.title = ''
+        musicxml_path = "temp.musicxml"
+        score.write('musicxml', fp=musicxml_path)
+        # Run Verovio via command line (since Python API fails)
+        verovio_executable = "verovio/build/verovio"  # Ensure correct path
+        if not os.path.exists(verovio_executable):
+            return "Error: Verovio binary not found!"
+        # Run Verovio with the full path
+        command = f"{verovio_executable} {musicxml_path} -o {svg_output} --smufl-text-font embedded --scale 50 --page-width 1000 --page-height 500 --footer none"
+        result = subprocess.run(command, shell=True, capture_output=True, text=True)
+
+        if result.returncode != 0:
+            print("Verovio Error:", result.stderr)
+            return f"Error running Verovio: {result.stderr}"
+        return svg_output
+
+
+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 = 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)
+    # alternation.write('midi',"alternation.mid")
+
+    hexa.chords_to_stream(cs1, 'temp.mid').show('text')
+    # optimized = optimize_voice_leading([c1, c2, c3])
+    optimized = hexa.optimize_voice_leading(cs1)
+    stream1 = stream.Stream(optimized)
+    stream1.show('text')
+    # stream1.write('midi', "optimized.mid")