Add files to project

app.py

@@ -3,43 +3,111 @@ import mido
 from mido import Message, MidiFile, MidiTrack
 import numpy as np
 import os
+import matplotlib.pyplot as plt
+import subprocess
 
+from music21 import midi, converter
+from pydub import AudioSegment
+import hexachords
 
-def generate_chords(hexachord):
+def generate_chords(midi_pitches):
     # Placeholder for your actual chord generation function
     # Assuming hexachord is a list of MIDI note numbers
-    chords = []
-    for i in range(4):  # Generate 4 chords
-        chords.append([note + (i * 2) for note in hexachord])  # Simple transposition
-    return chords
-
+    hexa = hexachords.Hexachord()
+    cs1 = hexa.generate_chord_sequence_from_midi_pitches(midi_pitches, intrvl="P4")
+    return cs1
 
 def create_midi(chords):
     mid = MidiFile()
     track = MidiTrack()
     mid.tracks.append(track)
-
+    start_time = 0
     for chord in chords:
         for note in chord:
-            track.append(Message('note_on', note=int(note), velocity=64, time=0))
+            track.append(Message('note_on', note=note.pitch.midi, velocity=64, time=0))
         for note in chord:
-            track.append(Message('note_off', note=int(note), velocity=64, time=480))
-
+            track.append(Message('note_off', note=note.pitch.midi, velocity=0, time=480))
     midi_path = "output.mid"
     mid.save(midi_path)
     return midi_path
 
 
-def process_hexachord(note1, note2, note3, note4, note5, note6):
-    notes = [note1, note2, note3, note4, note5, note6]
+def generate_piano_roll(chords):
+    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("piano_roll.png")
+    return "piano_roll.png"
+
+def generate_music_score(midi_path):
+    mf = midi.MidiFile()
+    mf.open(midi_path)
+    mf.read()
+    mf.close()
+    score = converter.parse(midi_path)
+    # score = converter.parse(mf)
+    score_img_path = "music_score"
+    score.write(fmt='lily.png', fp=score_img_path)
+    return score_img_path
+
+def convert_midi_to_audio(midi_path):
+    wav_path = "output.wav"
+    mp3_path = "output.mp3"
+    soundfont_path = "soundfont.sf2"  # Ensure you have a SoundFont file
+
+    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)
+
+        # Convert WAV to MP3
+        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 process_hexachord(*notes):
+    print(f'Received notes: {notes}')
+    notes = list(notes)
     notes = [int(note) for note in notes if note is not None]  # Convert to int, remove None values
 
     if len(notes) != 6 or len(set(notes)) != 6:
         return "Please select exactly 6 unique notes."
 
+    print('Generating chords...')
     chords = generate_chords(notes)
+    print('Creating MIDI file...')
     midi_path = create_midi(chords)
-    return midi_path
+    print('Generating piano roll...')
+    piano_roll_path = generate_piano_roll(chords)
+    print('Generating music score...')
+    score_path = generate_music_score(midi_path)
+    print('Converting MIDI to audio...')
+    audio_path = convert_midi_to_audio(midi_path)
+
+    return midi_path, piano_roll_path, score_path, audio_path
 
 
 # UI Components
@@ -55,11 +123,14 @@ with gr.Blocks() as ui:
 
     generate_button = gr.Button("Generate Chords")
     midi_output = gr.File(label="Generated MIDI")
+    piano_roll_output = gr.Image(label="Piano Roll Visualization")
+    music_score_output = gr.Image(label="Score Visualization")
+    audio_output = gr.Audio(label="Play Generated Chords", value=None, interactive=False)
 
     generate_button.click(
         fn=process_hexachord,
         inputs=note_inputs,
-        outputs=[midi_output]
+        outputs=[midi_output, piano_roll_output, music_score_output, audio_output]
     )
 
 # Detect if running on Hugging Face Spaces

apt.txt

@@ -0,0 +1,3 @@
+fluidsynth
+ffmpeg
+lilypond

hexachords.py

@@ -0,0 +1,126 @@
+from music21 import note, stream, interval, meter, chord
+from ortools.sat.python import cp_model
+
+class Hexachord:
+
+    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])
+
+    def generate_chord_sequence(self, list_of_notes, intrvl="P5"):
+
+        hexachord =  [note.Note(n) for n in list_of_notes]
+        # print(hexachord)
+        s = stream.Stream()
+        s.append(hexachord)
+        # Play the sequence
+        # s.show('midi')
+        # build chords
+        fifth = interval.Interval(intrvl)  # Perfect fifth
+        all_pc = [n.pitch.pitchClass for n in hexachord]
+        all_chords = []
+        for n in hexachord:
+            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:
+                    max_pitch = ch[-1].pitch
+                    while interval.Interval(noteStart=ch[-1], noteEnd=current_note).semitones > 12:
+                        current_note = current_note.transpose(-12)
+                    ch.add(current_note)
+            all_chords.append(ch)
+        return all_chords
+
+    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
+
+
+if __name__ == '__main__':
+    hexa = Hexachord()
+    cs1 = hexa.generate_chord_sequence(["C3", "D3", "E3", "G3", "A3", "B3"], 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")

requirements.txt

@@ -1,3 +1,8 @@
 gradio
 mido
-numpy
+numpy
+matplotlib
+pydub
+ffmpeg
+music21
+ortools