Upload 4 files

miditostring.py

@@ -0,0 +1,460 @@
+# convert_midi_to_custom_string.py
+"""
+Konverterar en MIDI-fil tillbaka till det anpassade strängformatet.
+
+Formatet är: [oktav][notnamn][volym][notlängd][tidstämpel]
+• Varje rad = 1 sekund (1000 ms)
+• Notlängd som bokstav: a=1, b=2, c=4, d=8, e=16, f=32, g=64, h=128, i=256
+• Tidstämpel: 0-59 = antal takter (1 takt ≈ 16.667 ms)
+• Volym: 0-10 (skalas ned från MIDI 0-127)
+"""
+
+from __future__ import annotations
+from pathlib import Path
+from typing import List, Tuple
+from collections import defaultdict
+
+import mido
+
+# ------------------------------------------------------------
+#  Konfiguration (samma som i string_to_midi)
+# ------------------------------------------------------------
+STAMP_SPAN_MS = 1_000  # 1 sekund per rad
+TAKTER_PER_STAMP = 60  # 60 takter per rad
+TACKT_MS = STAMP_SPAN_MS / TAKTER_PER_STAMP  # ≈16.667 ms
+BASE_DUR_MS = 33  # 33 ms som bas för notlängd
+VELOCITY_SCALE = 12.8  # för att skala tillbaka från MIDI velocity
+TEMPO_US_PER_BEAT = 500_000  # 120 BPM
+TICKS_PER_BEAT = 480
+
+minvolume=0
+maxoctave=6
+
+# Omvänd mappning: MIDI-notnummer till bokstav
+MIDI_TO_NOTE = {
+    0: 'C', 1: 'I', 2: 'D', 3: 'J',
+    4: 'E', 5: 'F', 6: 'K', 7: 'G',
+    8: 'L', 9: 'A', 10: 'H', 11: 'B',
+}
+
+# Omvänd mappning: millisekunder till bokstav
+DURATION_VALUES = {
+    'a': 1, 'b': 2, 'c': 4, 'd': 8,
+    'e': 16, 'f': 32, 'g': 64, 'h': 128, 'i': 256
+}
+
+
+def parse_midi(midi_path: str | Path, filter_drums: bool = True,
+               filter_non_piano: bool = False) -> List[Tuple[float, int, int, float]]:
+    """
+    Läser MIDI-filen och returnerar en lista med
+    (start_ms, midi_pitch, velocity, duration_ms)
+
+    Args:
+        midi_path: Sökväg till MIDI-filen
+        filter_drums: Om True, filtrera bort kanal 9 (trummor)
+        filter_non_piano: Om True, behåll endast piano-instrument (program 0-7)
+    """
+    mid = mido.MidiFile(midi_path)
+
+    # Hitta tempo (antar 120 BPM om inget anges)
+    tempo = TEMPO_US_PER_BEAT
+    for track in mid.tracks:
+        for msg in track:
+            if msg.type == 'set_tempo':
+                tempo = msg.tempo
+                break
+
+    # Spåra vilka program (instrument) som används per kanal
+    channel_programs = {}  # channel -> program_number
+
+    # Samla alla note events
+    note_on_times = {}  # (pitch, channel) -> start_time_ms
+    events = []
+
+    for track in mid.tracks:
+        current_time = 0.0
+        for msg in track:
+            current_time += msg.time
+            time_ms = mido.tick2second(current_time, mid.ticks_per_beat, tempo) * 1000
+
+            # Spåra program changes (instrumentbyten)
+            if msg.type == 'program_change':
+                channel_programs[msg.channel] = msg.program
+
+            if msg.type == 'note_on' and msg.velocity > 0:
+                # Filtrera bort kanal 9 (trummor) om filter_drums är True
+                if filter_drums and msg.channel == 9:
+                    continue
+
+                # Filtrera bort icke-piano instrument om filter_non_piano är True
+                # Piano-instrument är typiskt program 0-7 i General MIDI
+                if filter_non_piano:
+                    program = channel_programs.get(msg.channel, 0)
+                    if program > 7:  # Inte ett piano-instrument
+                        continue
+
+                # Ny not börjar
+                key = (msg.note, msg.channel)
+                note_on_times[key] = (time_ms, msg.velocity)
+
+            elif msg.type == 'note_off' or (msg.type == 'note_on' and msg.velocity == 0):
+                # Filtrera bort kanal 9 (trummor)
+                if filter_drums and msg.channel == 9:
+                    continue
+
+                # Filtrera bort icke-piano instrument
+                if filter_non_piano:
+                    program = channel_programs.get(msg.channel, 0)
+                    if program > 7:
+                        continue
+
+                # Not slutar
+                key = (msg.note, msg.channel)
+                if key in note_on_times:
+                    start_ms, velocity = note_on_times[key]
+                    duration_ms = time_ms - start_ms
+                    events.append((start_ms, msg.note, velocity, duration_ms))
+                    del note_on_times[key]
+
+    # Sortera efter starttid
+    events.sort(key=lambda e: e[0])
+    return events
+
+
+def duration_to_letter(duration_ms: float) -> str:
+    """
+    Konverterar notlängd i millisekunder till närmaste bokstav (a-i).
+    """
+    # Beräkna hur många BASE_DUR_MS enheter detta motsvarar
+    units = duration_ms / BASE_DUR_MS
+
+    # Hitta närmaste multiplikator
+    best_letter = 'a'
+    best_diff = abs(units - DURATION_VALUES['a'])
+
+    for letter, value in DURATION_VALUES.items():
+        diff = abs(units - value)
+        if diff < best_diff:
+            best_diff = diff
+            best_letter = letter
+
+    return best_letter
+
+
+def velocity_to_volume(velocity: int) -> int:
+    """
+    Konverterar MIDI velocity (0-127) till volym (0-10).
+    """
+    volume = int(round(velocity / VELOCITY_SCALE))
+    return max(0, min(10, volume))
+
+
+def remove_duplicate_notes(events: List[Tuple[float, int, int, float]]) -> List[Tuple[float, int, int, float]]:
+    """
+    Tar bort exakta dubbletter - noter med samma starttid och pitch.
+    Behåller den med högst velocity om det finns dubbletter.
+
+    Args:
+        events: Lista med (start_ms, pitch, velocity, duration_ms)
+
+    Returns:
+        Lista utan dubbletter
+    """
+    if not events:
+        return events
+
+    # Använd dictionary för att gruppera efter (start_time, pitch)
+    unique_notes = {}
+
+    for start_ms, pitch, velocity, duration_ms in events:
+        # Runda starttid till 0.1ms precision
+        rounded_time = round(start_ms, 1)
+        key = (rounded_time, pitch)
+
+        # Om denna kombination redan finns, behåll den med högst velocity
+        if key in unique_notes:
+            existing_vel = unique_notes[key][2]
+            if velocity > existing_vel:
+                unique_notes[key] = (start_ms, pitch, velocity, duration_ms)
+        else:
+            unique_notes[key] = (start_ms, pitch, velocity, duration_ms)
+
+    # Konvertera tillbaka till lista och sortera
+    filtered = list(unique_notes.values())
+    filtered.sort(key=lambda e: e[0])
+
+    removed = len(events) - len(filtered)
+    if removed > 0:
+        print(f"  ✓ Tog bort {removed} dubbletter (samma not vid samma tidpunkt)")
+
+    return filtered
+
+
+def remove_negative_octaves(events: List[Tuple[float, int, int, float]]) -> List[Tuple[float, int, int, float]]:
+    """
+    Tar bort noter med negativ oktav (MIDI pitch < 12).
+
+    Args:
+        events: Lista med (start_ms, pitch, velocity, duration_ms)
+
+    Returns:
+        Lista utan noter med negativ oktav
+    """
+    if not events:
+        return events
+
+    filtered = []
+    removed = 0
+
+    for start_ms, pitch, velocity, duration_ms in events:
+        octave = (pitch // 12) - 1
+        if octave >= 0:
+            filtered.append((start_ms, pitch, velocity, duration_ms))
+        else:
+            removed += 1
+
+    if removed > 0:
+        print(f"  ✓ Tog bort {removed} noter med negativ oktav")
+
+    return filtered
+
+
+def filter_large_chords(events: List[Tuple[float, int, int, float]],
+                        max_simultaneous: int = 5) -> List[Tuple[float, int, int, float]]:
+    """
+    Filtrerar bort noter från stora ackord där fler än max_simultaneous noter
+    börjar vid EXAKT samma tidpunkt.
+    Behåller de noter som är närmast pitch-medianen.
+
+    Args:
+        events: Lista med (start_ms, pitch, velocity, duration_ms)
+        max_simultaneous: Max antal noter som får starta vid samma tidpunkt
+
+    Returns:
+        Filtrerad lista med events
+    """
+    if not events:
+        return events
+
+    from statistics import median
+    from collections import defaultdict
+
+    # Gruppera noter efter EXAKT samma starttid
+    time_groups = defaultdict(list)
+
+    for event in events:
+        start_time = event[0]
+        # Runda till 0.1ms precision för att hantera float-fel
+        rounded_time = round(start_time, 1)
+        time_groups[rounded_time].append(event)
+
+    # Filtrera varje grupp
+    filtered_events = []
+    removed_count = 0
+
+    for start_time, group in time_groups.items():
+        if len(group) <= max_simultaneous:
+            # Gruppen är liten nog, behåll alla
+            filtered_events.extend(group)
+        else:
+            # För stor grupp - behåll endast de närmast mitten
+            pitches = [note[1] for note in group]
+            median_pitch = median(pitches)
+
+            # Sortera efter avstånd från median
+            sorted_group = sorted(group, key=lambda note: abs(note[1] - median_pitch))
+
+            # Behåll de max_simultaneous närmaste
+            filtered_events.extend(sorted_group[:max_simultaneous])
+            removed_count += len(group) - max_simultaneous
+
+    # Sortera om efter starttid
+    filtered_events.sort(key=lambda e: e[0])
+
+    if removed_count > 0:
+        print(
+            f"  ✓ Filtrerade bort {removed_count} noter från stora ackord (max {max_simultaneous} vid samma tidpunkt)")
+
+    return filtered_events
+
+
+def midi_pitch_to_octave_note(pitch: int) -> Tuple[int, str]:
+    """
+    Konverterar MIDI pitch till oktav och notnamn.
+    MIDI: C-1 = 0, C0 = 12, C1 = 24, etc.
+    """
+    octave = (pitch // 12) - 1
+    note_num = pitch % 12
+    note_letter = MIDI_TO_NOTE[note_num]
+    return octave, note_letter
+
+
+def convert_to_custom_string(events: List[Tuple[float, int, int, float]]) -> str:
+    """
+    Konverterar eventlistan till det anpassade strängformatet.
+    Grupperar noter per rad (per sekund) och tar bort duplicerade tokens.
+    """
+    # Gruppera noter per stamp (rad)
+    stamps = defaultdict(list)
+
+    for start_ms, pitch, velocity, duration_ms in events:
+        # Bestäm vilken rad (stamp) denna not tillhör
+        stamp_idx = int(start_ms // STAMP_SPAN_MS)
+
+        # Beräkna tid inom denna rad
+        time_within_stamp = start_ms - (stamp_idx * STAMP_SPAN_MS)
+        time_takter = int(round(time_within_stamp / TACKT_MS))
+        time_takter = max(0, min(59, time_takter))  # Begränsa till 0-59
+
+        # Konvertera pitch till oktav och not
+        octave, note_letter = midi_pitch_to_octave_note(pitch)
+
+        # Konvertera velocity till volym
+        volume = velocity_to_volume(velocity)
+        if(volume>minvolume and octave<=maxoctave):
+
+            # Konvertera duration till bokstav
+            dur_letter = duration_to_letter(duration_ms)
+
+            # Skapa token: oktav + notnamn + volym + notlängd + tidstämpel
+            token = f"{octave}{note_letter}{volume}{dur_letter}{time_takter}"
+            stamps[stamp_idx].append(token)
+
+    # Bygg output-sträng och ta bort duplicerade tokens per rad
+    if not stamps:
+        return ""
+
+    max_stamp = max(stamps.keys())
+    lines = []
+    total_duplicates_removed = 0
+
+    for stamp_idx in range(max_stamp + 1):
+        if stamp_idx in stamps:
+            # Ta bort duplicerade tokens i denna rad (behåll ordning)
+            tokens = stamps[stamp_idx]
+            seen = set()
+            unique_tokens = []
+            duplicates_in_line = 0
+
+            for token in tokens:
+                if token not in seen:
+                    seen.add(token)
+                    unique_tokens.append(token)
+                else:
+                    duplicates_in_line += 1
+
+            total_duplicates_removed += duplicates_in_line
+            line = " ".join(unique_tokens)
+            lines.append(line)
+        else:
+            lines.append("")  # Tom rad om inga noter i denna sekund
+
+    if total_duplicates_removed > 0:
+        print(f"  ✓ Tog bort {total_duplicates_removed} duplicerade tokens i strängformatet")
+
+    return "\n".join(lines)
+
+
+def midi_to_string(midi_path: str | Path, output_path: str | Path = None,
+                   filter_drums: bool = True, filter_non_piano: bool = False,
+                   max_chord_notes: int = 5) -> str:
+    """
+    Huvudfunktion: läser MIDI och returnerar strängformatet.
+
+    Args:
+        midi_path: Sökväg till MIDI-filen
+        output_path: Sökväg för att spara output (optional)
+        filter_drums: Om True, filtrera bort kanal 9 (trummor) - standard True
+        filter_non_piano: Om True, behåll endast piano (program 0-7) - standard False
+        max_chord_notes: Max antal noter som får starta vid exakt samma tidpunkt - standard 5
+
+    Returns:
+        Strängrepresentation i custom format
+    """
+    events = parse_midi(midi_path, filter_drums, filter_non_piano)
+
+    # Först: Ta bort dubbletter
+    events = remove_duplicate_notes(events)
+
+    # Sedan: Ta bort noter med negativ oktav
+    events = remove_negative_octaves(events)
+
+    # Slutligen: Filtrera stora ackord om max_chord_notes är satt
+    if max_chord_notes > 0:
+        events = filter_large_chords(events, max_chord_notes)
+
+    custom_string = convert_to_custom_string(events)
+
+    if output_path:
+        Path(output_path).write_text(custom_string, encoding='utf-8')
+        print(f"Sparade {output_path}")
+
+    # Beräkna låtlängd och noter per sekund
+    if events:
+        last_note_end = max(start_ms + duration_ms for start_ms, _, _, duration_ms in events)
+        song_length_seconds = last_note_end / 1000.0
+        notes_per_second = len(events) / song_length_seconds if song_length_seconds > 0 else 0
+
+        print(f"\n--- Statistik ---")
+        print(f"Antal noter efter filtrering: {len(events)}")
+        print(f"Låtlängd: {song_length_seconds:.2f} sekunder")
+        print(f"Noter per sekund: {notes_per_second:.2f}")
+    else:
+        print(f"\n--- Statistik ---")
+        print(f"Antal noter efter filtrering: 0")
+
+    if filter_drums:
+        print("  ✓ Trummor filtrerade bort (kanal 9)")
+    if filter_non_piano:
+        print("  ✓ Endast piano-instrument behållna (program 0-7)")
+
+    return custom_string
+
+
+# ------------------------------------------------------------------
+#  CLI-exempel
+# ------------------------------------------------------------------
+if __name__ == "__main__":
+
+    midi_file = r"C:\Users\tom\Downloads\ABBA.Gimme gimme gimme L.mid"
+    output_file = "tmp/output.txt"
+
+    # Standard: Filtrera trummor + begränsa ackord till max 5 noter vid exakt samma tidpunkt
+    result = midi_to_string(midi_file, output_file,
+                            filter_drums=True,
+                            filter_non_piano=False,
+                            max_chord_notes=10)
+
+    # Alternativt: Behåll ENDAST piano + max 5 noter per ackord
+    # result = midi_to_string(midi_file, output_file,
+    #                        filter_drums=True,
+    #                        filter_non_piano=True,
+    #                        max_chord_notes=5)
+
+    # Alternativt: Max 3 noter vid samma tidpunkt
+    # result = midi_to_string(midi_file, output_file, max_chord_notes=3)
+
+    # Alternativt: Inget ackordfilter (0 = avstängt)
+    # result = midi_to_string(midi_file, output_file, max_chord_notes=0)
+
+    # Alternativt: Behåll ENDAST piano + max 5 noter per ackord
+    # result = midi_to_string(midi_file, output_file,
+    #                        filter_drums=True,
+    #                        filter_non_piano=True,
+    #                        max_chord_notes=5)
+
+    # Alternativt: Inget ackordfilter (0 = avstängt)
+    # result = midi_to_string(midi_file, output_file,
+    #                        filter_drums=True,
+    #                        max_chord_notes=0)
+
+    # Alternativt: Ingen filtrering alls
+    # result = midi_to_string(midi_file, output_file,
+    #                        filter_drums=False,
+    #                        filter_non_piano=False,
+    #                        max_chord_notes=0)
+
+    if not output_file:
+        print("\nResultat:")
+        print(result)

stringtomidi.py

@@ -0,0 +1,132 @@
+# convert_custom_string_to_midi.py
+"""
+Konverterar strängen som ser ut så här:
+
+4G5d21 5E9a0 5J9b13
+
+till en MIDI‑fil.
+
+• Varje rad = ny stämpel (= +1 s) [Ändrat från 2s till 1s]
+• Formatet är: [oktav][notnamn][volym][notlängd][tidstämpel]
+• Notlängd som bokstav: a=1, b=2, c=4, d=8, e=16, f=32, g=64 (multiplikator för 100ms)
+• Tidstämpel: 0‑59 = antal takter (1 takt ≙ 16.667 ms)
+• Volym: 0‑10 (skalas upp till 0‑127)
+"""
+
+from __future__ import annotations
+import re
+from pathlib import Path
+from typing import List, Tuple
+
+import mido
+
+# ------------------------------------------------------------
+#  Konfiguration
+# ------------------------------------------------------------
+STAMP_SPAN_MS = 1_000  # 1 sekund per rad (ändrat från 2_000)
+TAKTER_PER_STAMP = 60  # 60 takter per rad
+TACKT_MS = STAMP_SPAN_MS / TAKTER_PER_STAMP  # ≈16.667 ms
+BASE_DUR_MS = 33  # 0.1 sekund som bas för notlängd
+VELOCITY_SCALE = 12.8  # 8 * 12.8 ≈ 102
+TEMPO_US_PER_BEAT = 500_000  # 120 BPM
+TICKS_PER_BEAT = 480
+
+NOTE_MAP = {  # samma konstiga namngivning som i Java‑koden
+    'C': 0, 'I': 1, 'D': 2, 'J': 3,
+    'E': 4, 'F': 5, 'K': 6, 'G': 7,
+    'L': 8, 'A': 9, 'H': 10, 'B': 11,
+}
+
+DURATION_MAP = {  # a=1, b=2, c=4, d=8, e=16, f=32, g=64
+    'a': 1, 'b': 2, 'c': 4, 'd': 8, 'e': 16, 'f': 32, 'g': 64, 'h': 128, 'i': 256
+}
+
+# Nytt regex för det nya formatet: oktav + notnamn + volym + notlängd + tidstämpel
+TOKEN_RE = re.compile(r'^(\d+)([A-Z])(\d+)([a-i])(\d+)$')
+
+
+def parse_custom(text: str) -> List[Tuple[float, int, int, int]]:
+    """
+    Läser texten och returnerar en lista med
+    (start_ms, midi_pitch, velocity, duration_ms)
+    """
+    events = []
+    for stamp_idx, line in enumerate(text.replace("*","").strip().splitlines()):
+        base_time_ms = stamp_idx * STAMP_SPAN_MS
+        for token in line.strip().split():
+            m = TOKEN_RE.match(token)
+            if not m:
+                raise ValueError(f'Felaktigt token: {token}')
+
+            # Tolka nytt format: oktav + notnamn + volym + notlängd + tidstämpel
+            octave_str, letter, vel_str, dur_letter, time_str = m.groups()
+
+            octave = int(octave_str)
+            time_since = int(time_str)
+            velocity_in = int(vel_str)
+
+            # Konvertera notlängdsbokstav till millisekunder
+            duration_ms = DURATION_MAP[dur_letter] * BASE_DUR_MS
+
+            pitch = NOTE_MAP[letter] + (octave + 1) * 12  # MIDI har C‑1 = 0
+            velocity = min(127, int(round(velocity_in * VELOCITY_SCALE)))
+            start_ms = base_time_ms + time_since * TACKT_MS
+
+            events.append((start_ms, pitch, velocity, duration_ms))
+
+    return events
+
+
+def build_midi(events: List[Tuple[float, int, int, int]],
+               out_path: str | Path = "output.mid") -> None:
+    """
+    Bygger en simpel 1‑spårig SMF‑fil av eventlistan.
+    """
+    # Skapa Note On + Note Off‑par
+    timed = []
+    end_ms=None
+    for start_ms, pitch, vel, duration_ms in events:
+        end_ms = start_ms + duration_ms  # Använd notlängden från formatet
+        timed.append((start_ms, pitch, vel, True))  # True = note_on
+        timed.append((end_ms, pitch, 0, False))  # False = note_off
+
+    print(f"noter: {len(events)}, längd: {round(end_ms/1000,2)}s, tempo: {round(1000*len(events)/end_ms,1)} noter/s")
+
+    # sortera kronologiskt
+    timed.sort(key=lambda t: t[0])
+
+    mid = mido.MidiFile(ticks_per_beat=TICKS_PER_BEAT)
+    track = mido.MidiTrack()
+    mid.tracks.append(track)
+    track.append(mido.MetaMessage('set_tempo', tempo=TEMPO_US_PER_BEAT, time=0))
+
+    last_tick = 0
+    for abs_ms, pitch, velocity, is_on in timed:
+        sec = abs_ms / 1000.0
+        tick = mido.second2tick(sec, TICKS_PER_BEAT, TEMPO_US_PER_BEAT)
+        delta = int(round(tick - last_tick))
+        msg_type = 'note_on' if is_on else 'note_off'
+        track.append(mido.Message(msg_type, note=pitch, velocity=velocity, time=delta))
+        last_tick = tick
+
+    mid.save(out_path)
+    print(f"Sparade {out_path}")
+
+
+# ------------------------------------------------------------------
+#  CLI‑exempel / snabbtest
+# ------------------------------------------------------------------
+if __name__ == "__main__":
+    example_text = """
+
+5C5e17 5C7f30 5C7f37 5C7f38 5C7f38 3C7f38
+4C7g4 3A7g4 4C7g4 4C5g4 3G7g4 5C7e14 4C7e43
+4G7e52
+4G7f14 4F7f14 3G5f14 4G6f46 4C7f46
+3H5f12 4G6f35 5G7e42 4G7f43 4C7f43 3G7f45
+5C7d29 5C7d58
+4G7d14 4A7d39
+
+""".replace("*", "")
+    events = parse_custom(example_text)
+    build_midi(events, "tmp/example.mid")

train.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d0053740266b249dd8b8e282c4a3538de5d9e8420383e177f936a3b3768e520
+size 6453696436

val.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88258c666e7736a6ff3a4defe145f4bfc28f76a28938893365c74df95e24d2c2
+size 6460157