#!/usr/bin/env python3 """ various routines for converting midi files to piano roll images and back Unless otherwise noted: Author: Scott H. Hawley, Feb-March 2024 """ import os import torch import torchvision import torchvision.transforms as transforms from PIL import Image, ImageOps, ImageDraw, ImageFont import numpy as np import pretty_midi import matplotlib.pyplot as plt from .chords import chord_num_to_color, simplify_chord, CHORD_BORDER from .utils import rect_to_square, square_to_rect ONSET_STYLE = 'new' # 'old'=onset markers on pixels before notes, 'new'=onset markers are part of notes def plot_piano_roll(pr_array): plt.figure(figsize=(8, 8)) plt.imshow(np.flipud(pr_array), aspect='auto') plt.show() def piano_roll_to_pretty_midi(piano_roll, fs=8, program=0): # this routine copied from https://github.com/jsleep/pretty-midi/blob/ba7d01e5796fedf3ca0a3528e48b5242d9d2ccc3/examples/reverse_pianoroll.py '''Convert a Piano Roll array into a PrettyMidi object with a single instrument. Parameters ---------- piano_roll : np.ndarray, shape=(128,frames), dtype=int Piano roll of one instrument fs : int Sampling frequency of the columns, i.e. each column is spaced apart by ``1./fs`` seconds. program : int The program number of the instrument. Returns ------- midi_object : pretty_midi.PrettyMIDI A pretty_midi.PrettyMIDI class instance describing the piano roll. ''' notes, frames = piano_roll.shape #print("piano_roll.T[piano_roll.T != 0] = ",piano_roll.T[piano_roll.T != 0],flush=True) pm = pretty_midi.PrettyMIDI() instrument = pretty_midi.Instrument(program=program) # pad 1 column of zeros so we can acknowledge inital and ending events piano_roll = np.pad(piano_roll, [(0, 0), (1, 1)], 'constant') # use changes in velocities to find note on / note off events velocity_changes = np.nonzero(np.diff(piano_roll).T) # keep track on velocities and note on times prev_velocities = np.zeros(notes, dtype=int) note_on_time = np.zeros(notes) for time, note in zip(*velocity_changes): # use time + 1 because of padding above velocity = np.clip(piano_roll[note, time + 1], 0, 127) #print("piano_roll[note, time + 1], velocity = ",piano_roll[note, time + 1], velocity,flush=True) time = time / fs if velocity > 0: if prev_velocities[note] == 0: note_on_time[note] = time prev_velocities[note] = velocity else: pm_note = pretty_midi.Note( velocity=prev_velocities[note], pitch=note, start=note_on_time[note], end=time) instrument.notes.append(pm_note) prev_velocities[note] = 0 pm.instruments.append(instrument) return pm #### beginning of code copied from midi2img.py def find_first_note_start(midi): """find the start time of the first note in the midi file used to help alignment to beats/bars """ first_start = 10000.0 for instrument in midi.instruments: for note in instrument.notes: if note.start < first_start: first_start = note.start return first_start def get_piano_rolls(midi, fs, remove_leading_silence=True, add_onsets=True, debug=False): """Converts a pretty_midi object to a piano roll for each instrument""" duration = midi.get_end_time() # find out duration of the midi file n_frames = int(np.ceil(duration * fs)) # calculate the number of frames # create a piano roll for each instrument # TODO: currently this is only setup for POP909 dataset, need to generalize for other datasets piano_rolls = {'PIANO': np.zeros((128, n_frames)), 'MELODY': np.zeros((128, n_frames)), 'TOTAL': np.zeros((128, n_frames))} if remove_leading_silence: first_start = find_first_note_start(midi) for instrument in midi.instruments: name = instrument.name.upper() if name in ['MELODY', 'PIANO']: if debug: print(f"get_piano_rolls: instrument.name = {name}") for note in instrument.notes: if remove_leading_silence: note.start -= first_start note.end -= first_start start = int(np.round(note.start * fs)) # quantize start time to nearest 16th note dur = (note.end - note.start)*fs # quantize duration (Tip: don't separately quantize start & end; that can lead to "double-rounding" errors) #end = int(np.round(note.end * fs)) end = start + int(np.round(dur)) # round means some notes will get held a bit too long, but "floor" would err on the side of extra staccatto notes which I don't want if end==start: end = start+1 # make sure note is at least 1 pixel long piano_rolls[name][note.pitch, start:end] = note.velocity ## value of piano roll array for these pixels will be the note velocity. end+1 so that "end" index gets covered piano_rolls['TOTAL'][note.pitch, start:end] = note.velocity #if note.velocity in [65,59,49,100]: print("note = ",note) # extra fun: make sure all note onsets pop piano_rolls[name][note.pitch, start-1] = 0 piano_rolls['TOTAL'][note.pitch, start-1] = 0 # if remove_leading_silence and add_onsets: # we need to add one pixel for the red onset dot at the start # for instrument in piano_rolls: # piano_rolls[instrument] = np.insert(piano_rolls[instrument], 0, 0, axis=1) return piano_rolls def piano_roll_to_img(pr_frame, # this is an array of shape (128, n_frames) output_dir, midi_name, instrument, start_col=None, add_onsets=True, chords=None, chord_names=False, debug=False, onset_style=ONSET_STYLE, # 'new' or 'old' ): os.makedirs(f"{output_dir}/{midi_name}", exist_ok=True) filename = f"{output_dir}/{midi_name}/{midi_name}_{instrument}.png" if start_col is not None: filename = filename.replace(".png",f"_{str(start_col).zfill(5)}.png") #if debug: print("pr_frame.T[pr_frame.T != 0] = ",pr_frame.T[pr_frame.T != 0]) #scaling_factor = 65 / 18 # found empiracally by lots of checking #pr_frame = np.round(pr_frame * scaling_factor).astype(np.uint8) scale_factor = 2 # velocity only goes up to 127, but colors go up to 255 green_channel = np.clip(np.round(pr_frame*scale_factor), 0, 255).astype(np.uint8) rgb_image = np.dstack((np.zeros_like(green_channel), green_channel, np.zeros_like(green_channel))) img = Image.fromarray(rgb_image,'RGB') if add_onsets: # add little onset markers (red dots) if onset_style=='old': # any black pixel that has a green pixel to its right is an onset. color it red # note that x any are flipped from what you'd think, e.g. "img.size = (2352, 128)" for y in range(img.size[-1]): for x in range(img.size[0]-1): if img.getpixel((x,y)) == (0,0,0) and img.getpixel((x+1,y)) != (0,0,0): img.putpixel((x,y), (255,0,0)) elif onset_style=='new': # New version: # any green pixel with a black pixel on its left becomes a red pixel. or if first pixel on row is green, make it red (matchinf velocity) # Thus red pixel counts as both onset and first part of note, so shortest notes (16ths) will appear as only red with no green # btw this seems to agree w/ polyffusion's approach (??) for y in range(img.size[-1]): x = 0 pxl = img.getpixel((x,y)) r,g,b = pxl if is_green(*pxl): img.putpixel((0,y), (g,0,0)) # make the first pixel of the note red, matching the green intensity for x in range(1, img.size[0]): pxl = img.getpixel((x,y)) r,g,b = pxl if is_green(*pxl) and is_black(*img.getpixel((x-1,y))): img.putpixel((x,y), (g,0,0)) else: print(f"Error: Unrecognized onset_style = {onset_style}. Exiting.") return img = img.transpose(Image.FLIP_TOP_BOTTOM) # flip it vertically for display purposes if chords is not None: # add the chord colors for each time as a rectangles at the top and bottom if chord_names: font_size = 7 try: myFont = ImageFont.truetype("arial.ttf", 7) #mac except: myFont = ImageFont.load_default(size=font_size) for c in chords: color = chord_num_to_color(c['chord_num']) img.paste(color, (int(c['start']), img.size[-1]-CHORD_BORDER, int(c['end']), img.size[-1])) img.paste(color, (int(c['start']), 0, int(c['end']), CHORD_BORDER)) if chord_names: chord_name = c['chord_name'].replace(':','') if debug: print(f"chord_name = {chord_name}, chord_num = {c['chord_num']}") xpos = int(c['start']) I1 = ImageDraw.Draw(img) I1.text((xpos, 0), chord_name, font=myFont, fill=(255, 255, 255)) if debug: print("img.size = ",img.size) if 0 in img.size: print(f"Error: img.size = {img.size}. Skipping this file.") return # # just make sure all blue is gone: # img_array = np.array(img) # img_array[:, :, 2] = 0 # img = Image.fromarray(img_array) img.save(filename) def check_for_melody_piano(midi: pretty_midi.PrettyMIDI, debug=False): has_melody, has_piano = False, False if debug: print("check_for_melody_piano: midi.instruments = ",midi.instruments) for i, instrument in enumerate(midi.instruments): if debug: print(f"check_for_melody_piano: instrument = [{instrument.name.upper()}]") if instrument.name.upper() == 'MELODY': has_melody = True if instrument.name.upper() == 'PIANO': has_piano = True # if theres only one instrument with no name, name it PIANO if len(midi.instruments) == 1 and midi.instruments[0].name == '': has_piano = True midi.instruments[0].name = 'PIANO' return has_melody, has_piano def midi_to_pr_img(midi_file, output_dir, show_chords=None, # to show chords or not all_chords=None, # list of all possible chords add_onsets=True, # add red dots for note onsets chord_names=False, # to show chord names or not filter_mp=True, # filter midi & piano remove_leading_silence=True, # remove silence at start of song simplify_chords=False, # simplify chord names debug=False,): # show debugging info """Converts a MIDI file to a piano roll image""" if debug: print(f"midi_to_pr_img: Processing {midi_file}") if '/versions/' in midi_file and args.skip_versions: return midi = pretty_midi.PrettyMIDI(midi_file) if not check_for_melody_piano(midi): print(f"Not ok: File {midi_file} does not have melody and piano. Skipping") return else: if debug: print(f"Ok: File {midi_file} has melody and piano. Processing") ### Normalize tempo to 120bpm tempo_changes = midi.get_tempo_changes() start_tempo = tempo_changes[1][0] bps = start_tempo / 60.0 fs = bps * 4.0 * 2 if debug: print("start_tempo, fs = ", start_tempo, fs) chords=None if show_chords and all_chords is not None: # read the chord timing file, but note that those times have not yet been normalized to 120bpm # this file has column-separated format "start_time end_time chord" chords_path = midi_file.replace('.mid', '_chords.txt') with open(chords_path) as f: chords = f.read().splitlines() # split each line of text into a dict 3 values {'start':, 'end':, 'chord':}: chords = [dict(zip(['start', 'end', 'chord'], c.split('\t'))) for c in chords] for c in chords: c['start'] = int(np.floor(float(c['start']) * fs)) c['end'] = int(np.ceil(float(c['end']) * fs)) c['chord_name'] = simplify_chord(c['chord']) if simplify_chords else c['chord'] c['chord_num'] = all_chords.index(c['chord_name']) if filter_mp: # remove non-piano, non-melody instruments midi.instruments = [instrument for instrument in midi.instruments if instrument.name.upper() in ['MELODY', 'PIANO']] piano_rolls = get_piano_rolls(midi, fs, remove_leading_silence=remove_leading_silence, add_onsets=add_onsets) if debug: for p in piano_rolls.keys(): print(f"p {p}.shape =",piano_rolls[p].shape) #print(f"piano_rolls[{p}][piano_rolls[p] != 0] = ",piano_rolls[p][piano_rolls[p] != 0]) midi_name = os.path.basename(midi_file).split('.')[0] # get the midi filename w/o parent dirs or file extension for instrument in piano_rolls: # save each instrument's piano roll as a single image if debug: print("saving piano roll for ",instrument) piano_roll_to_img(piano_rolls[instrument], output_dir, midi_name, instrument, chords=chords, chord_names=chord_names, add_onsets=add_onsets, debug=debug) return #### end of code copied from midi2img.py #### below code originally in img2midi.py def blockout_topbottom_arr(arr, border=CHORD_BORDER): "set the top and bottom border pixels to black" arr2 = arr.copy() arr2[:border, :] = 0 arr2[-border:, :] = 0 return arr2 def filter_by_velocity(midi, thresh=20): "filter out notes with velocities below a certain threshold" for instrument in midi.instruments: notes = [note for note in instrument.notes if note.velocity > thresh] instrument.notes = notes return midi def img2midi(img, draw_sep=512, debug=False): # operates on a single image # flip the image vertically because numpy and PIL have different ideas of what the first row is # if image vertical dimension is more than 128, then cut it into strips of 128 and concatenate them horizontally if debug: print(f"img2midi: img.size = {img.size}") if img.size[1] > 128: arr = np.concatenate([np.array(img.crop((0, i, img.size[0], i+128))) for i in range(0, img.size[1], 128)], axis=1) else: arr = np.array(img) if debug: print("0: arr.T[arr.T != 0] = ",arr.T[arr.T != 0]) arr = blockout_topbottom_arr(arr) scale_factor = 0.5 # rgb down to velocity values piano_roll_array = np.array(arr*scale_factor, dtype=np.int32) piano_roll_array = np.flip(piano_roll_array, axis=0) # numpy as PIL are upside down relative to each other if debug: print(f"piano_roll_array.shape = {piano_roll_array.shape}, piano_roll_array.dtype = {piano_roll_array.dtype}") print("1: piano_roll_array[piano_roll_array != 0] = ",piano_roll_array[piano_roll_array != 0]) # draw a vertical line every 128/256/512 pixels if draw_sep > 0: line_every = draw_sep for i in range(0, piano_roll_array.shape[-1], line_every): if i>0: piano_roll_array[35:-35,i] = 30 piano_roll_array = np.clip(piano_roll_array, 0, 127) # make sure velocities aren't out of bounds midi = piano_roll_to_pretty_midi(piano_roll_array) midi = filter_by_velocity(midi) return midi def flip_bottom_half_and_attach(sub_img): "takes one 256x256 and returns on 512x128 image with the bottom half reversed and attached on the right" h, w = sub_img.size new_img = Image.new(sub_img.mode, (w*2, h//2)) new_img.paste(sub_img.crop((0, 0, w, h//2)), (0, 0)) new_img.paste(sub_img.crop((0, h//2, w, h)).transpose(Image.FLIP_LEFT_RIGHT), (w, 0)) return new_img def square_to_rect(img): #"""just an alias for flip_bottom_half_and_attach""" return flip_bottom_half_and_attach(img) def rect_to_square(img): "takes a 512x128 image and returns a 256x256 image with the bottom half reversed" w, h = img.size new_img = Image.new(img.mode, (w//2, h*2)) new_img.paste(img.crop((0, 0, w//2, h)), (0, 0)) new_img.paste(img.crop((w//2, 0, w, h)).transpose(Image.FLIP_LEFT_RIGHT), (0, h)) return new_img def regroup_lines(img, debug=False): """ large images come in as an 8x8 grid of 256x256 images, in which the bottom half of each 256x256 is horizontally backwards we will rebuild this grid by first flipping the bottom half of each 256x256 image """ img2 = Image.new('RGB', img.size) if debug: print(f"regroup_lines: img.size = {img.size}") if img.size[0] == 256: img2 = Image.new('RGB', (512,128)) elif img.size[0] != 2048: if debug: print("regroup_lines: unexpected image size, returning image unchanged") return img # no op, hope all's well imnum = 0 for row in range(0, img.size[0], 256): for col in range(0, img.size[1], 256): imnum += 1 sub_img = img.crop((col, row, col+256, row+256)) sub_img = square_to_rect(sub_img) paste_x, paste_y = (imnum-1) % 4 * 512, (imnum-1) // 4 * 128 if debug: print(f"imnum = {imnum}, paste_x = {paste_x}, paste_y = {paste_y}") img2.paste(sub_img, (paste_x, paste_y)) if debug: img2.show() return img2 def is_red(r,g,b, thresh=20, debug=False): result = r > thresh and g < thresh and b < thresh if debug: print("is_red: r,g,b = ",r,g,b,", result = ",result) return result def is_green(r,g,b, thresh=20): return r < thresh and g > thresh and b < thresh def is_black(r,g,b, thresh=20): return r < thresh and g < thresh and b < thresh def filter_redgreen(img:Image, require_onsets=True, # only keep green lines that start with a red pixel on the left thresh=20, # minimum amount of red or green to count onset_style=ONSET_STYLE, # 'new' or 'old debug=False): # filter: only keep black points, and green lines that start with a red pixel on the left. # i.e. only green points that have red or green to their left are valid notes # intended for img2midi img.save('rgfilter_in.png') img2 = img.copy() if debug: print("img.size = ",img.size,", require_onsets = ",require_onsets," (not require_onsets) =",(not require_onsets)," thresh = ",thresh) w, h = img.size for y in range(CHORD_BORDER,h-CHORD_BORDER): note_on = False for x in range(w): # scan from right to left r,g,b = img2.getpixel((x,y)) # pixel under consideration if debug and (r,g,b)!=(0,0,0): print(f"x, y: {x}, {y}: r, g, b = {r},{g},{b}, note_on = {note_on}, is_red = {is_red(r,g,b, thresh)}, is_green = {is_green(r,g,b, thresh)}") if is_red(r,g,b, thresh): note_on = True if onset_style == 'new': # keep the note but change the red to green img2.putpixel((x,y), (0,r,0)) elif is_green(r,g,b, thresh) and require_onsets and note_on: img2.putpixel((x,y), (r,g,b)) # keep the note elif is_green(r,g,b, thresh) and (not require_onsets): img2.putpixel((x,y), (r,g,b)) # keep the note note_on = True else: note_on = False img2.putpixel((x,y), (0,0,0)) # zero it out img2.save('rgfilter_out.png') # debugging always on here return img2 def arr_check(img, tag=''): img = img.convert("RGB") arr = np.array(img)[:,:,1] print(tag,": arr.shape = ",arr.shape, flush=True) print(tag,": arr.T[arr.T != 0] = ",arr.T[arr.T != 0], flush=True) def img2midi_multi(img, require_onsets=True, separators=512, debug=False): "can operate on a grid of images" img = img.convert('RGB') img = regroup_lines(img) img = filter_redgreen(img, require_onsets=require_onsets) #img = img.convert('L') # convert to grayscale red_arr = np.array(img.split()[0]) green_arr = np.array(img.split()[1]) combined_arr = red_arr + green_arr if debug: arr_check(img, '1') img = Image.fromarray(combined_arr, mode="L") if debug: arr_check(img, '2') return img2midi(img, draw_sep=separators) def infer_mask_from_init_img(img, mask_with='grey', debug=True): "note, this works whether image is normalized on 0..1 or -1..1, but not 0..255" assert mask_with in ['blue','white','grey'] "given an image with mask areas marked, extract the mask itself" img = np.array(img) mask = np.zeros(img.shape[:2]) if debug: print("infer: img.shape, mask.shape = ",img.shape, mask.shape) if mask_with == 'white': mask[ (img[0,:,:]==1) & (img[1,:,:]==1) & (img[2,:,:]==1)] = 1 elif mask_with == 'blue': mask[img[2,:,:]==1] = 1 # blue if mask_with == 'grey': mask[ (img[:,:,0] != 0) & (img[:,:,0] > -1) & (img[:,:,0]==img[:,:,1]) & (img[:,:,2]==img[:,:,1])] = 1 return mask*1.0 def img_file_2_midi_file(img_file, output_dir='', require_onsets=True, separators=512, diff_img_file='', debug=True): "Converts an image file to a midi file" if debug: print(f"Processing {img_file}", flush=True) img = Image.open(img_file) if debug: arr_check(img, '0') midi = img2midi_multi(img, require_onsets=require_onsets, separators=separators) if diff_img_file != '': # put new notes on new instrument. bg_img = rect_to_square(Image.open(diff_img_file)) mask = infer_mask_from_init_img(bg_img, mask_with='grey') # tile mask to 3 color channels mask = np.stack([mask]*3, axis=-1) if debug: print("mask.shape = ",mask.shape, flush=True) print("mask.min(), mask.max(), mask.sum() = ",mask.min(), mask.max(), mask.sum(), flush=True) if bg_img.size[0] > img.size[0]: bg_img = rect_to_square(bg_img) bg_midi = img2midi_multi(bg_img, require_onsets=require_onsets, separators=separators) # grab just the pixels in the mask of img arr = np.array(img) if debug: print("arr.shape, mask.shape = ",arr.shape, mask.shape, flush=True) print("arr.min(), arr.max(), arr.sum() = ",arr.min(), arr.max(), arr.sum(), flush=True) new_arr = np.zeros_like(arr) new_arr[mask > 0] = 1*255# arr[mask > 0] new_arr = np.where(mask>0, arr, 0) # new_arr[:,:,0] = arr[:,:,0] * mask # new_arr[:,:,1] = arr[:,:,1] * mask # new_arr[:,:,2] = arr[:,:,2] * mask new_img = Image.fromarray(new_arr, 'RGB') square_to_rect(new_img).save('new_img.png') new_midi = img2midi_multi(new_img, require_onsets=require_onsets, separators=separators) bg_midi.instruments.append(new_midi.instruments[0]) midi = bg_midi midi_file = os.path.basename(img_file).replace('.png', '.mid') if output_dir is not None and output_dir != '': midi_file = os.path.join(output_dir, midi_file) midi.write(midi_file) return midi_file #### end of code copied from img2midi.py ### dataset routines, called from train.h class RandomVerticalShift(torch.nn.Module): """ Update: UNUSED. Instead we do all transposing as pre-processing to facilitate chord detection. Randomly shift the image vertically by up to max_shift pixels, which correspond to semitones. """ def __init__(self, max_shift=12): super().__init__() self.max_shift = max_shift def __call__(self, img): shift = torch.randint(-self.max_shift, self.max_shift, (1,)) return self.vertical_shift(img, shift.item()) def vertical_shift(self, img, shift): img = ImageOps.exif_transpose(img) # Handle EXIF Orientation img = img.transform(img.size, Image.AFFINE, (1, 0, 0, 0, 1, shift), fillcolor=0) return img class RandomBarCrop(torch.nn.Module): """ Given a PIL image of a piano roll (non-square!), do random cropping the level of measures, i.e. bars, i.e. 16 16th-note pixels NOTE: might be nice if piano roll images have initial silence pre-removed -- assuming the first note is supposed to start on the first beat """ def __init__(self, bar_length=16, window_length=512): super().__init__() self.bl = bar_length # in 16th notes (16 pixels) self.wl = window_length # in pixels self.bic = self.wl // self.bl # bars in crop def __call__(self, img: Image, debug=False): bars_in_image = img.size[0] // self.bl # number of bars in full image if self.bic >= bars_in_image: # pad horizontal end of image with zeros if needed pad = self.wl - img.size[0] + 1 img = ImageOps.expand(img, (0, 0, pad, 0), fill=0) bars_in_image = img.size[0] // self.bl try: start_ind = torch.randint(0, bars_in_image - self.bic+1, (1,)).item() # start index of crop except Exception as e: print(f"***MY ERROR: {e}. bars_in_image = {bars_in_image}, self.bic = {self.bic}") assert False start_pixel = start_ind * self.bl # start pixel of crop new_img = img.crop((start_pixel, 0, start_pixel + self.wl, img.size[1])) assert new_img.size[0] == self.wl and new_img.size[1]==128, f"ERROR: new_img.size = {new_img.size}, self.wl = {self.wl}" return new_img class StackPianoRollsImage(torch.nn.Module): """ Given a PIL image of a piano roll, cut in in half horizontally, stack the two halves, with the lower half mirrored horzontally. """ def __init__(self, final_size=(256, 256), max_shift=13): super().__init__() self.final_size = final_size def __call__(self, img: Image, debug=False): if img.size[0] <= 128 and img.size[1] <= 128: return img # don't stack small images # image dimensions are likely 512x128. I want 256x256 output half_width = img.size[0] // 2 #make a new image with dimensions 256x256, with the same color mode as img new_img = Image.new(img.mode, self.final_size) # paste the first half of the image into the top half of the new image first_half = img.crop((0, 0, half_width, img.size[1])) new_img.paste(first_half, (0, 0)) # paste the second half of the image into the bottom half of the new image, but flipped horizontally next_half = img.crop((half_width, 0, 2*half_width, img.size[1])) next_half = ImageOps.mirror(next_half) new_img.paste(next_half, (0, img.size[1])) return new_img class StackPianoRollsTensor(torch.nn.Module): """ Tensor version of StackPianoRollsImage. Unused, i think. Given a torch tensor of a piano roll, cut in in half horizontally, stack the two halves but have the bottom half mirrored horzontally. """ def __init__(self): super().__init__() def __call__(self, img: torch.Tensor): if img.shape[0] <= 128 and img.shape[1] <= 128: return img # don't stack small images img = img.permute(1, 2, 0) half_width = img.shape[0] // 2 img = torch.cat([img[:half_width], img[half_width:][::-1]], dim=0) img = img.permute(2, 0, 1) return img if __name__ == '__main__': import sys # testing for the StackPianoRollsImage class filename = sys.argv[-1] print("filename = ", filename) img = Image.open(filename) img = transforms.RandomCrop((128, 512))(img) # randomly crop it to 128x512 img = StackPianoRollsImage()(img, debug=True) img.show()