Miditoolkit

https://github.com/yatingmusic/miditoolkit
Admin
Miditoolkit is a Python package designed for working with MIDI files, processing events in native...
Tokens:8,847
Snippets:42
Trust Score:7.7
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install MidiToolkit via PyPI

Source: https://github.com/yatingmusic/miditoolkit/blob/master/README.md

Installs the miditoolkit package from the Python Package Index (PyPI). This is the standard method for installing Python packages.

```bash
pip install miditoolkit
```

--------------------------------

### Access and Analyze Built-in Example MIDI File (Python)

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This code example demonstrates how to access and load the example MIDI file provided with the miditoolkit library using `example_midi_file()`. It then proceeds to load the MIDI file and print various properties such as ticks per beat, tempo changes, time signatures, and instrument details. This is useful for testing and quick demonstrations.

```python
from miditoolkit import MidiFile
from miditoolkit.midi.utils import example_midi_file

# Get the path to the example MIDI file
example_path = example_midi_file()
print(f"Example MIDI path: {example_path}")

# Load the example file
midi = MidiFile(example_path)

# Display properties
print(f"\nExample MIDI properties:")
print(f"Ticks per beat: {midi.ticks_per_beat}")
print(f"Max tick: {midi.max_tick}")
print(f"Tempo changes: {len(midi.tempo_changes)}")
print(f"Time signatures: {len(midi.time_signature_changes)}")
print(f"Key signatures: {len(midi.key_signature_changes)}")
print(f"Markers: {len(midi.markers)}")
print(f"Lyrics: {len(midi.lyrics)}")
print(f"Instruments: {midi.num_instruments}")

# Analyze the example file
for idx, instrument in enumerate(midi.instruments):
    print(f"\nInstrument {idx}:")
    print(f"  Name: {instrument.name}")
    print(f"  Program: {instrument.program}")
    print(f"  Notes: {instrument.num_notes}")
    print(f"  Control changes: {len(instrument.control_changes)}")
    print(f"  Pitch bends: {len(instrument.pitch_bends)}")
```

--------------------------------

### Install MidiToolkit from Git Repository

Source: https://github.com/yatingmusic/miditoolkit/blob/master/README.md

Installs the miditoolkit package directly from its Git repository. This is useful for accessing the latest features or fixes not yet released on PyPI.

```bash
pip install git+https://github.com/YatingMusic/miditoolkit
```

--------------------------------

### Load and Print MidiFile Object in Python

Source: https://github.com/yatingmusic/miditoolkit/blob/master/README.md

Demonstrates how to load a MIDI file using MidiFile and print its basic properties. It requires the miditoolkit library and uses an example MIDI file path.

```python
from miditoolkit import MidiFile
from miditoolkit.midi.utils import example_midi_file

path_midi = example_midi_file()
midi_obj = MidiFile(path_midi)

print(midi_obj)
```

--------------------------------

### Parse MIDI File Information - Python

Source: https://github.com/yatingmusic/miditoolkit/blob/master/examples/parse_and_create_MIDI_files.ipynb

Loads a MIDI file and prints details about its contents, including ticks per beat, time signatures, key signatures, tempo changes, markers, and instrument notes. It also demonstrates converting note start times from ticks to seconds using a tick-to-time mapping.

```python
import numpy as np

from miditoolkit.midi import parser as mid_parser  
from miditoolkit.midi import containers as ct

# load midi file
path_midi = '../testcases/2.midi'
mido_obj = mid_parser.MidiFile(path_midi)

# ticks per beats
print(' > ticks per beat:', mido_obj.ticks_per_beat)

# signatures
print('\n -- time signatures -- ')
print(' > amount:', len(mido_obj.time_signature_changes))
print(mido_obj.time_signature_changes[0])

print('\n -- key signatures --')
print(' > amount:', len(mido_obj.key_signature_changes))

# tempo changes
print('\n -- tempo changes --')
print(' > amount:', len(mido_obj.tempo_changes))
print(mido_obj.tempo_changes[0])

# markers
print('\n -- markers --')
print(' > amount:', len(mido_obj.markers))
print(mido_obj.markers[0])

# instruments
print('\n -- instruments --')
print(' > number of tracks:', len(mido_obj.instruments))
print(' > number of notes:', len(mido_obj.instruments[0].notes))

# convert to seconds
note = mido_obj.instruments[0].notes[20]
mapping = mido_obj.get_tick_to_time_mapping()
tick = note.start
sec = mapping[tick]
print('{} tick at {} seconds'.format(tick, sec))
```

--------------------------------

### Convert MIDI Ticks to Time in Seconds (Python)

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This example shows how to convert MIDI ticks to seconds, accounting for tempo changes within a MIDI file using miditoolkit. It utilizes the `get_tick_to_time_mapping()` method to obtain a conversion array and demonstrates converting specific tick values and note timings to seconds. This is crucial for tempo-aware analysis and synchronization.

```python
from miditoolkit import MidiFile
import numpy as np

# Load a MIDI file with tempo changes
midi = MidiFile('song.mid')

# Get tick-to-second mapping
tick_to_time = midi.get_tick_to_time_mapping()

print(f"Total ticks: {len(tick_to_time)}")
print(f"Total duration: {tick_to_time[-1]:.2f} seconds")

# Convert specific tick to seconds
tick = 1920  # One bar at 480 ticks per beat in 4/4
time_in_seconds = tick_to_time[tick]
print(f"Tick {tick} = {time_in_seconds:.2f} seconds")

# Example: Get note timing in seconds
instrument = midi.instruments[0]
for note in instrument.notes[:5]:
    start_sec = tick_to_time[note.start]
    end_sec = tick_to_time[note.end]
    duration_sec = end_sec - start_sec
    print(f"Note: pitch={note.pitch}, "
          f"start={start_sec:.2f}s, end={end_sec:.2f}s, "
          f"duration={duration_sec:.2f}s")
```

--------------------------------

### Compare MIDI Properties and Instruments in Python

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This Python code snippet demonstrates how to compare key properties of two MIDI objects, such as ticks per beat, number of tempo changes, and number of instruments. It also includes a detailed comparison of individual instruments and their notes, sorting the notes by start time, pitch, end time, and velocity before comparison to ensure order independence.

```python
if midi1.ticks_per_beat == midi2.ticks_per_beat:
    print("Same ticks per beat")

if len(midi1.tempo_changes) == len(midi2.tempo_changes):
    print("Same number of tempo changes")

if midi1.num_instruments == midi2.num_instruments:
    print("Same number of instruments")

# Compare instruments
for i, (inst1, inst2) in enumerate(zip(midi1.instruments, midi2.instruments)):
    if inst1 == inst2:
        print(f"Instrument {i} is identical")
    else:
        print(f"Instrument {i} differs")

    # Detailed comparison
    if inst1.program != inst2.program:
        print(f"  Program differs: {inst1.program} vs {inst2.program}")
    if inst1.num_notes != inst2.num_notes:
        print(f"  Note count differs: {inst1.num_notes} vs {inst2.num_notes}")

    # Sort notes before comparing to ignore order
    inst1.notes.sort(key=lambda x: (x.start, x.pitch, x.end, x.velocity))
    inst2.notes.sort(key=lambda x: (x.start, x.pitch, x.end, x.velocity))

    if inst1.notes != inst2.notes:
        print(f"  Notes differ")
```

--------------------------------

### Converting Piano-Roll Representation back to MIDI Notes in Python

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This code shows the reverse process of converting a piano-roll matrix back into MIDI note objects. It requires the same pitch range used during the initial conversion. The example includes modifying the piano-roll (e.g., removing low-velocity notes) before conversion and then saving the reconstructed notes into a new MIDI file. This is useful for generative music models or editing MIDI data.

```python
from miditoolkit import MidiFile, Instrument
from miditoolkit.pianoroll import notes2pianoroll, pianoroll2notes
import numpy as np

# Load a MIDI file
midi = MidiFile('input.mid')
original_notes = midi.instruments[0].notes

# Convert to piano-roll
pianoroll = notes2pianoroll(notes=original_notes, pitch_range=(60, 84))

# Modify the piano-roll (e.g., remove soft notes)
pianoroll[pianoroll < 60] = 0  # Remove velocities below 60

# Convert back to notes
reconstructed_notes = pianoroll2notes(
    pianoroll=pianoroll,
    pitch_range=(60, 84),  # Must match the pitch range used in conversion
    resample_factor=None
)

print(f"Original notes: {len(original_notes)}")
print(f"Reconstructed notes: {len(reconstructed_notes)}")

# Create a new MIDI file with reconstructed notes
new_midi = MidiFile(ticks_per_beat=480)
new_instrument = Instrument(program=0, is_drum=False, name="Piano")
new_instrument.notes = reconstructed_notes
new_midi.instruments.append(new_instrument)
new_midi.dump('reconstructed.mid')
```

--------------------------------

### Crop MIDI File Segment - Python

Source: https://github.com/yatingmusic/miditoolkit/blob/master/examples/parse_and_create_MIDI_files.ipynb

Loads a MIDI file and exports a specific segment defined by a start and end bar. The segment is determined by calculating the tick values corresponding to the desired bars based on the MIDI file's ticks per beat.

```python
# load midi file
path_midi = 'testcases/2.midi'
mido_obj = mid_parser.MidiFile(path_midi)
beat_resol = mido_obj.ticks_per_beat

# define interval: from 2nd to 8th bar
st = beat_resol * 4 * 2
ed = beat_resol * 4 * 8

# export
mido_obj.dump('seg.midi', segment=(st, ed))
```

--------------------------------

### Create MIDI Files Programmatically with Miditoolkit

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

Shows how to create a new MIDI file from scratch using Miditoolkit. This includes setting global properties, adding tempo and time signature changes, creating instruments, adding notes, and saving the file.

```python
from miditoolkit import MidiFile, Instrument, Note, TempoChange, TimeSignature

# Create a new MIDI file
midi = MidiFile(ticks_per_beat=480)

# Add tempo change (120 BPM at the beginning)
midi.tempo_changes.append(TempoChange(tempo=120, time=0))

# Add time signature (4/4 at the beginning)
midi.time_signature_changes.append(TimeSignature(numerator=4, denominator=4, time=0))

# Create a piano instrument (program 0)
piano = Instrument(program=0, is_drum=False, name="Piano")

# Add notes to the piano (C major scale)
pitches = [60, 62, 64, 65, 67, 69, 71, 72]  # C4 to C5
for i, pitch in enumerate(pitches):
    start_tick = i * 480  # One beat per note
    end_tick = start_tick + 480
    note = Note(velocity=80, pitch=pitch, start=start_tick, end=end_tick)
    piano.notes.append(note)

# Add the instrument to the MIDI file
midi.instruments.append(piano)

# Save the MIDI file
midi.dump('output.mid')
print("MIDI file created successfully!")
```

--------------------------------

### Load and Parse MIDI Files with Miditoolkit

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

Demonstrates how to load a MIDI file using Miditoolkit's MidiFile class and access its global properties, tempo changes, time signatures, key signatures, instruments, and notes.

```python
from miditoolkit import MidiFile

# Load a MIDI file
midi = MidiFile('path/to/your/song.mid')

# Access global properties
print(f"Ticks per beat: {midi.ticks_per_beat}")
print(f"Max tick: {midi.max_tick}")
print(f"Number of instruments: {midi.num_instruments}")

# Access tempo changes
for tempo in midi.tempo_changes:
    print(f"Tempo: {tempo.tempo} BPM at tick {tempo.time}")

# Access time signatures
for ts in midi.time_signature_changes:
    print(f"Time signature: {ts.numerator}/{ts.denominator} at tick {ts.time}")

# Access key signatures
for ks in midi.key_signature_changes:
    print(f"Key signature: {ks.key_name} at tick {ks.time}")

# Access instruments and notes
for idx, instrument in enumerate(midi.instruments):
    print(f"\nInstrument {idx}: {instrument.name}")
    print(f"  Program: {instrument.program}, Is drum: {instrument.is_drum}")
    print(f"  Number of notes: {instrument.num_notes}")

    # Access individual notes
    for note in instrument.notes[:5]:  # First 5 notes
        print(f"  Note: pitch={note.pitch}, velocity={note.velocity}, "
              f"start={note.start}, end={note.end}, duration={note.duration}")
```

--------------------------------

### Load and Save MIDI Files to Memory Buffers (Python)

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This snippet illustrates how to work with MIDI files in memory using `io.BytesIO` with the miditoolkit library. It demonstrates creating a MIDI file, saving it to a buffer, and then loading it back from the same buffer. This is useful for streaming MIDI data or for applications that do not require writing to disk.

```python
from miditoolkit import MidiFile, Instrument, Note
from io import BytesIO

# Create a MIDI file in memory
buffer = BytesIO()

# Create a simple MIDI file
midi = MidiFile(ticks_per_beat=480)
piano = Instrument(program=0, is_drum=False, name="Piano")

# Add a simple melody
for i, pitch in enumerate([60, 64, 67, 72]):
    note = Note(velocity=80, pitch=pitch, start=i*480, end=(i+1)*480)
    piano.notes.append(note)

midi.instruments.append(piano)

# Save to buffer
midi.dump(file=buffer)
buffer.seek(0)  # Reset buffer position

print(f"MIDI file size in memory: {len(buffer.getvalue())} bytes")

# Load from buffer
buffer.seek(0)
loaded_midi = MidiFile(file=buffer)

print(f"Loaded MIDI has {loaded_midi.num_instruments} instruments")
print(f"First instrument has {loaded_midi.instruments[0].num_notes} notes")

# Example: Stream MIDI data
midi_bytes = buffer.getvalue()
# Can now send midi_bytes over network, save to database, etc.
```

--------------------------------

### Create Empty MIDI File and Add Notes - Python

Source: https://github.com/yatingmusic/miditoolkit/blob/master/examples/parse_and_create_MIDI_files.ipynb

Creates a new, empty MIDI file, adds an instrument track, and populates it with a series of eighth notes with incrementally increasing pitches. It also adds a marker and saves the MIDI file, then reloads it to verify the contents.

```python
# create an empty file
mido_obj = mid_parser.MidiFile()
beat_resol = mido_obj.ticks_per_beat

# create an  instrument
track = ct.Instrument(program=0, is_drum=False, name='example track')
mido_obj.instruments = [track]

# create eighth notes
duration = int(beat_resol * 0.5)
prev_end = 0
pitch = 60
for i in range(10):
    # create one note
    start = prev_end
    end = prev_end + duration
    pitch = pitch
    velocity = np.random.randint(1, 127)
    note = ct.Note(start=start, end=end, pitch=pitch, velocity=velocity)
    mido_obj.instruments[0].notes.append(note)
    
    # prepare next
    prev_end = end
    pitch += 1

# create markers
marker_hi = ct.Marker(time=0, text='HI')
mido_obj.markers.append(marker_hi)

# write to file
mido_obj.dump('result.midi')

# reload for check
mido_obj_re = mid_parser.MidiFile('result.midi')
for note in mido_obj_re.instruments[0].notes:
    print(note)

print('\nmarker:', mido_obj_re.markers)
```

--------------------------------

### Compare Two MIDI Files for Equality (Python)

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This code snippet shows how to compare two MIDI files for exact equality using the overloaded equality operator (`==`) provided by the `MidiFile` class in miditoolkit. It loads two MIDI files and prints a message indicating whether they are identical or differ. This is useful for verifying that processing or modifications have not unintentionally altered the MIDI data.

```python
from miditoolkit import MidiFile

# Load two MIDI files
midi1 = MidiFile('original.mid')
midi2 = MidiFile('modified.mid')

# Compare entire MIDI files
if midi1 == midi2:
    print("MIDI files are identical")
else:
    print("MIDI files differ")
```

--------------------------------

### Access and Add Control Changes and Pedal Events in MIDI

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

Demonstrates how to access existing pedal events from a MIDI instrument, add new control change events (like modulation wheel), and append new pedal events. The modified MIDI data is then saved to a file. This functionality is crucial for fine-tuning MIDI performances.

```python
from miditoolkit import MidiFile, ControlChange, Pedal

# Assuming 'instrument' and 'midi' objects are already loaded
# Example: midi = MidiFile('input.mid')
# instrument = midi.instruments[0]

print(f"\nNumber of pedal events: {len(instrument.pedals)}")
for pedal in instrument.pedals:
    print(f"Pedal: start={pedal.start}, end={pedal.end}, duration={pedal.duration}")

# Add a new control change (e.g., modulation wheel CC 1)
new_cc = ControlChange(number=1, value=64, time=480)
instrument.control_changes.append(new_cc)

# Add a new pedal event
new_pedal = Pedal(start=960, end=1920)
instrument.pedals.append(new_pedal)

# Save the modified MIDI
midi.dump('output_with_controls.mid')
```

--------------------------------

### Working with Pitch Bends in MIDI using Python

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This snippet shows how to load a MIDI file, access pitch bend events for an instrument, and add new pitch bend events to create expressive musical performance. It details how to set the pitch value and time for each bend and how to reset the pitch bend to its center position. The modified MIDI is then saved.

```python
from miditoolkit import MidiFile, PitchBend

# Load a MIDI file
midi = MidiFile('expressive.mid')

# Access pitch bends for the first instrument
instrument = midi.instruments[0]

print(f"Number of pitch bends: {len(instrument.pitch_bends)}")
for pb in instrument.pitch_bends:
    print(f"Pitch bend: pitch={pb.pitch} at tick {pb.time}")
    # Pitch bend range: -8192 to +8191 (0 = no bend)

# Add a pitch bend event (bend up by 2 semitones)
bend_up = PitchBend(pitch=4096, time=480)  # +4096 = approximately +2 semitones
instrument.pitch_bends.append(bend_up)

# Reset pitch bend to center
bend_reset = PitchBend(pitch=0, time=960)
instrument.pitch_bends.append(bend_reset)

# Save the modified MIDI
midi.dump('output_with_bends.mid')
```

--------------------------------

### Add and Manipulate Markers and Lyrics in MIDI Files (Python)

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This snippet demonstrates how to add and access markers and lyrics for structural annotations in MIDI files using the miditoolkit library. It covers loading a MIDI file, appending Marker and Lyric objects with text and time information, and iterating through existing annotations. The modified MIDI file is then saved.

```python
from miditoolkit import MidiFile, Marker, Lyric

# Load or create a MIDI file
midi = MidiFile('song.mid')

# Add markers for song structure
midi.markers.append(Marker(text="Intro", time=0))
midi.markers.append(Marker(text="Verse 1", time=1920))
midi.markers.append(Marker(text="Chorus", time=7680))
midi.markers.append(Marker(text="Verse 2", time=15360))
midi.markers.append(Marker(text="Outro", time=23040))

# Add lyrics
midi.lyrics.append(Lyric(text="When", time=1920))
midi.lyrics.append(Lyric(text="I", time=2160))
midi.lyrics.append(Lyric(text="find", time=2400))
midi.lyrics.append(Lyric(text="my", time=2640))
midi.lyrics.append(Lyric(text="self", time=2880))

# Access existing markers
print("Markers:")
for marker in midi.markers:
    print(f"  {marker.text} at tick {marker.time}")

# Access existing lyrics
print("\nLyrics:")
for lyric in midi.lyrics:
    print(f"  '{lyric.text}' at tick {lyric.time}")

# Save with annotationsmidi.dump('annotated_song.mid')
```

--------------------------------

### Piano-Roll Utilities: Chromagram, Padding, and Normalization in Python

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This snippet introduces utility functions for advanced piano-roll manipulation. It covers converting a piano-roll to a chromagram (12-dimensional pitch class representation), normalizing the chromagram, and padding a piano-roll to cover the full MIDI pitch range. These utilities are helpful for feature extraction and preparing data for various music processing tasks.

```python
from miditoolkit import MidiFile
from miditoolkit.pianoroll import notes2pianoroll
from miditoolkit.pianoroll.utils import tochroma, pitch_padding, normalize
import numpy as np

# Load a MIDI file and convert to piano-roll
midi = MidiFile('song.mid')
notes = midi.instruments[0].notes
pianoroll = notes2pianoroll(notes=notes)

# Convert piano-roll to chromagram (12-dimensional pitch class representation)
chroma = tochroma(pianoroll)
print(f"Chromagram shape: {chroma.shape}")  # (time_steps, 12)
print(f"Pitch classes: C, C#, D, D#, E, F, F#, G, G#, A, A#, B")

# Normalize the chromagram
chroma_normalized = normalize(chroma)
print(f"Normalized range: [{chroma_normalized.min():.2f}, {chroma_normalized.max():.2f}]")

# Pad piano-roll to full MIDI pitch range
pianoroll_padded = pitch_padding(
    pianoroll=pianoroll,
    pitch_range=(60, 84),  # Original pitch range
    padding_range=(0, 127),  # Target range (full MIDI)
    value=0  # Padding value
)
print(f"Original shape: {pianoroll.shape}")
print(f"Padded shape: {pianoroll_padded.shape}")
```

--------------------------------

### Crop and Pad Piano-roll Pitch Axis using miditoolkit

Source: https://github.com/yatingmusic/miditoolkit/blob/master/examples/pinoroll_manipulation.ipynb

Demonstrates how to crop a specific pitch range from a piano-roll and then pad it back to the original range using pitch_padding utility. This is useful for focusing on specific musical octaves or instrument ranges.

```python
from miditoolkit.pianoroll import utils

# cropping pitch
pianoroll_small = pianoroll[:, 24:108]
print('before:', pianoroll_small.shape)

# padding pitch
pianoroll_re = utils.pitch_padding(pianoroll_small, pitch_range=(24, 108))
print(' after:', pianoroll_re.shape)
```

--------------------------------

### Work with Control Changes and Pedals using Miditoolkit

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

Explains how to access and manipulate MIDI control change (CC) events, including sustain pedal data, for a specific instrument within a loaded MIDI file.

```python
from miditoolkit import MidiFile, ControlChange, Pedal

# Load a MIDI file
midi = MidiFile('piano_performance.mid')

# Access control changes for the first instrument
instrument = midi.instruments[0]

print(f"Number of control changes: {len(instrument.control_changes)}")
for cc in instrument.control_changes[:10]:  # First 10 CC events
    print(f"CC {cc.number}: value={cc.value} at tick {cc.time}")
```

--------------------------------

### Modify and Manipulate MIDI Files with Miditoolkit

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

Illustrates how to modify existing MIDI files, including transposing notes, changing tempo, filtering notes by velocity, removing invalid notes, cropping the file to a segment, and exporting specific instruments.

```python
from miditoolkit import MidiFile, TempoChange

# Load an existing MIDI file
midi = MidiFile('input.mid')

# Transpose all notes up by 2 semitones
for instrument in midi.instruments:
    for note in instrument.notes:
        note.pitch += 2

# Change tempo to 140 BPM
midi.tempo_changes = [TempoChange(tempo=140, time=0)]

# Remove notes with velocity below 50
for instrument in midi.instruments:
    instrument.notes = [note for note in instrument.notes if note.velocity >= 50]

# Remove invalid notes (notes with no duration)
for instrument in midi.instruments:
    instrument.remove_notes_with_no_duration()

# Crop the MIDI file to a specific segment (ticks 1920 to 9600)
segment = (1920, 9600)
midi.dump('output_cropped.mid', segment=segment, shift=True)

# Export only specific instruments (e.g., instrument 0 and 2)
midi.dump('output_selected.mid', instrument_idx=[0, 2])
```

--------------------------------

### Resample Piano-roll using miditoolkit

Source: https://github.com/yatingmusic/miditoolkit/blob/master/examples/pinoroll_manipulation.ipynb

Shows how to resample a piano-roll to a different time resolution. This involves adjusting the time-step density of the piano-roll, either by downsampling or upsampling, using the notes2pianoroll and pianoroll2notes functions with a resample_factor.

```python
from miditoolkit.midi import parser as mid_parser
from miditoolkit.pianoroll import parser as pr_parser

# resampling
old_resol = mido_obj.ticks_per_beat
new_resol = 24
factor_down = new_resol/ old_resol
print('resampling factor:', factor_down)

# downsample
pianoroll = pr_parser.notes2pianoroll(
                    notes, 
                    resample_factor=factor_down)
print('downsample:', pianoroll.shape)

# upsample
notes_re = pr_parser.pianoroll2notes(
                    pianoroll,
                    resample_factor=1/factor_down)
# check
for pair in zip(notes_re[:5],  notes[:5]):
    print('{} | {}'.format(pair[0], pair[1]))
```

--------------------------------

### Converting MIDI Notes to Piano-Roll Representation in Python

Source: https://context7.com/yatingmusic/miditoolkit/llms.txt

This code demonstrates converting MIDI notes into a piano-roll representation, which is a time x pitch matrix. It allows for various parameters like pitch range, time resolution, and velocity threshold to be specified during conversion. The resulting piano-roll can be resampled or segmented. This is useful for music analysis and machine learning tasks.

```python
from miditoolkit import MidiFile
from miditoolkit.pianoroll import notes2pianoroll
import numpy as np

# Load a MIDI file
midi = MidiFile('song.mid')

# Get notes from the first instrument
notes = midi.instruments[0].notes

# Convert to piano-roll (time x pitch matrix)
pianoroll = notes2pianoroll(
    notes=notes,
    pitch_range=(60, 84),  # C4 to C6
    pitch_offset=0,
    resample_factor=None,  # Keep original time resolution
    velocity_threshold=0,  # Include all notes
    time_portion=None,  # Use full time range
    keep_note_with_zero_duration=True
)

print(f"Piano-roll shape: {pianoroll.shape}")  # (time_steps, num_pitches)
print(f"Piano-roll dtype: {pianoroll.dtype}")
print(f"Non-zero entries: {np.count_nonzero(pianoroll)}")

# Example: Resample to half the time resolution
pianoroll_resampled = notes2pianoroll(
    notes=notes,
    resample_factor=0.5,  # Halve the time resolution
    resample_method=round
)

# Example: Extract a specific time segment
pianoroll_segment = notes2pianoroll(
    notes=notes,
    time_portion=(1920, 9600)  # Specific tick range
)
```

--------------------------------

### Convert MIDI Notes to Piano-roll using miditoolkit

Source: https://github.com/yatingmusic/miditoolkit/blob/master/examples/pinoroll_manipulation.ipynb

Loads a MIDI file and converts its notes into a piano-roll representation. The output is a 2D array where rows represent time steps and columns represent MIDI pitches.

```python
from miditoolkit.midi import parser as mid_parser
from miditoolkit.pianoroll import parser as pr_parser

# load midi file
path_midi = '../testcases/1.midi'
mido_obj = mid_parser.MidiFile(path_midi)
notes = mido_obj.instruments[0].notes

# convert notes to pianoroll
pianoroll = pr_parser.notes2pianoroll(
                    notes)

# pianoroll: tick x pitch
print(pianoroll.shape)
```

--------------------------------

### Convert Piano-roll to Chromagram using miditoolkit

Source: https://github.com/yatingmusic/miditoolkit/blob/master/examples/pinoroll_manipulation.ipynb

Converts a piano-roll representation into a chromagram. A chromagram represents musical pitch classes (0-11) across time, useful for analyzing harmonic content regardless of octave.

```python
from miditoolkit.pianoroll import utils

# convert to chromagram
chormagram = utils.tochroma(pianoroll)
print(chormagram.shape)
```
Tokens:
Raw