def process_folder(folder_path, quantization, binary_piano, binary_orch, temporal_granularity, gapopen=3, gapextend=1): # Get instrus and prs from a folder name name pr0, instru0, T0, name0, pr1, instru1, T1, name1 = get_instru_and_pr_from_folder_path(folder_path, quantization) pr_piano, instru_piano, T_piano, name_piano, pr_orch, instru_orch, T_orch, name_orch=\ discriminate_between_piano_and_orchestra(pr0, instru0, T0, name0, pr1, instru1, T1, name1) pr_piano = process_data_piano(pr_piano, binary_piano) pr_orch = process_data_orch(pr_orch, binary_orch) # Temporal granularity if temporal_granularity == 'event_level': event_piano = get_event_ind_dict(pr_piano) event_orch = get_event_ind_dict(pr_orch) def get_duration(event, last_time): start_ind = event[:] end_ind = np.zeros(event.shape, dtype=np.int) end_ind[:-1] = event[1:] end_ind[-1] = last_time duration_list = end_ind - start_ind return duration_list duration_piano = get_duration(event_piano, T_piano) duration_orch = get_duration(event_orch, T_orch) # Get the duration of each event pr_piano = warp_pr_aux(pr_piano, event_piano) pr_orch = warp_pr_aux(pr_orch, event_orch) else: event_piano = None event_orch = None # Align tracks piano_aligned, trace_piano, orch_aligned, trace_orch, trace_prod, total_time = align_pianorolls(pr_piano, pr_orch, gapopen, gapextend) # Clean events if (temporal_granularity == 'event_level'): if (trace_piano is None) or (trace_orch is None): event_piano_aligned = None event_orch_aligned = None duration_piano_aligned = None duration_orch_aligned = None else: event_piano_aligned = clean_event(event_piano, trace_piano, trace_prod) event_orch_aligned = clean_event(event_orch, trace_orch, trace_prod) duration_piano_aligned = clean_event(duration_piano, trace_piano, trace_prod) duration_orch_aligned = clean_event(duration_orch, trace_orch, trace_prod) else: event_piano_aligned = [] event_orch_aligned = [] duration_piano_aligned = [] duration_orch_aligned = [] return piano_aligned, event_piano, duration_piano, instru_piano, name_piano, orch_aligned, event_orch, duration_orch, instru_orch, name_orch, total_time
def process_folder(folder_path, quantization, unit_type, temporal_granularity, gapopen=3, gapextend=1): # Get instrus and prs from a folder name name pr0, instru0, _, name0, pr1, instru1, _, name1 = get_instru_and_pr_from_folder_path( folder_path, quantization) # Unit type pr0 = Unit_type.from_rawpr_to_type(pr0, unit_type) pr1 = Unit_type.from_rawpr_to_type(pr1, unit_type) # Temporal granularity if temporal_granularity == 'event_level': event_0 = get_event_ind_dict(pr0) event_1 = get_event_ind_dict(pr1) pr0 = warp_pr_aux(pr0, event_0) pr1 = warp_pr_aux(pr1, event_1) else: event_0 = None event_1 = None # Align tracks pr0_aligned, trace_0, pr1_aligned, trace_1, trace_prod, duration = align_tracks( pr0, pr1, unit_type, gapopen, gapextend) # Clean events event0_aligned = clean_event(event_0, trace_0, trace_prod) event1_aligned = clean_event(event_1, trace_1, trace_prod) # Find which pr is orchestra, which one is piano pr_piano, event_piano, instru_piano, name_piano,\ pr_orch, event_orch, instru_orch, name_orch,\ duration =\ discriminate_between_piano_and_orchestra(pr0_aligned, event0_aligned, instru0, name0, pr1_aligned, event1_aligned, instru1, name1, duration) return pr_piano, event_piano, instru_piano, name_piano, pr_orch, event_orch, instru_orch, name_orch, duration
def load_solo(piano_midi, quantization, binarize_piano, temporal_granularity): # Read piano pr pr_piano = Read_midi(path, quantization).read_file() # Process pr_piano pr_piano = process_data_piano(pr_piano, binarize_piano) # Take event level representation if temporal_granularity == 'event_level': event_piano = get_event_ind_dict(pr_piano) pr_piano = warp_pr_aux(pr_piano, event_piano) else: event_piano = None name_piano = re.sub(r'/.*\.mid', '', piano_midi) duration = get_pianoroll_time(pr_piano) return pr_piano, event_piano, name_piano, None, None, duration
def process_folder_NP(folder_path, quantization, binary_piano, binary_orch, temporal_granularity): """Get the pianoroll from a folder path with containing only an orchestral score. Piano score is created by simply crushing all the instruments on 88 pitches """ # Get instrus and prs from a folder name name pr_orch, instru_orch, T, name = get_instru_and_pr_from_folder_path_NP( folder_path, quantization) # Create the piano score pr_piano = {'Piano': sum_along_instru_dim(pr_orch)} # Process the two files (remember that even in this context, piano can be real-valued and orchestra discrete) pr_piano = process_data_piano(pr_piano, binary_piano) pr_orch = process_data_orch(pr_orch, binary_orch) # Temporal granularity (use only orchestra to compute events) if temporal_granularity == 'event_level': event_orch = get_event_ind_dict(pr_orch) T = len(event_orch) def get_duration(event, last_time): start_ind = event[:] end_ind = np.zeros(event.shape, dtype=np.int) end_ind[:-1] = event[1:] end_ind[-1] = last_time duration_list = end_ind - start_ind return duration_list duration_orch = get_duration(event_orch, T) # Get the duration of each event pr_orch = warp_pr_aux(pr_orch, event_orch) pr_piano = warp_pr_aux(pr_piano, event_orch) else: event_orch = None # Fill identical values event_piano = event_orch duration_piano = duration_orch instru_piano = {'Piano': 'Piano'} name_piano = name return pr_piano, event_piano, duration_piano, instru_piano, name_piano, pr_orch, event_orch, duration_orch, instru_orch, name, T
def process_folder(folder_path, quantization, binary_piano, binary_orch, temporal_granularity, gapopen=3, gapextend=1, align_bool=True): ############################## # Get instrus and prs from a folder name name pr0, articulation_0, staccato_0, T0, name0, pr1, articulation_1, staccato_1, T1, name1 = get_instru_and_pr_from_folder_path(folder_path, quantization) data_0 = (pr0, articulation_0, staccato_0, T0, name0) data_1 = (pr1, articulation_1, staccato_1, T1, name1) (pr_piano_X, articulation_piano, staccato_piano, T_piano, name_piano), \ (pr_orch, articulation_orch, staccato_orch, T_orch, name_orch)=\ discriminate_between_piano_and_orchestra(data_0, data_1) # if pr_contrabass[:, 62:].sum() > 1: # import pdb; pdb.set_trace() # If corrupted files, pr_piano (and pr_orch) will be None if pr_piano_X is None: return [None] * 9 # Remove from orch if "Remove" in pr_orch.keys(): pr_orch.pop("Remove") # Group in piano pr_piano = {'Piano': sum_along_instru_dim(pr_piano_X)} # try: # write_midi(pr_piano, ticks_per_beat=quantization, write_path="../DEBUG/test_piano.mid", articulation=articulation_piano) # write_midi(pr_orch, ticks_per_beat=quantization, write_path="../DEBUG/test_orch.mid", articulation=articulation_orch) # write_midi({k: v*90 for k,v in pr_piano.items()}, ticks_per_beat=quantization, write_path="../DEBUG/test_piano.mid", articulation=articulation_piano) # write_midi({k: v*90 for k,v in pr_orch.items() if (v.sum()>0)}, ticks_per_beat=quantization, write_path="../DEBUG/test_orch.mid", articulation=articulation_orch) # except: # print("Because of mixed instru cannot write reference") ############################## # Process pr (mostly binarized) pr_piano = process_data_piano(pr_piano, binary_piano) pr_orch = process_data_orch(pr_orch, binary_orch) # Temporal granularity if temporal_granularity == 'event_level': event_piano = get_event_ind_dict(articulation_piano, pr_piano) event_orch = get_event_ind_dict(articulation_orch, pr_orch) def get_duration(event, last_time): start_ind = event[:] end_ind = np.zeros(event.shape, dtype=np.int) end_ind[:-1] = event[1:] end_ind[-1] = last_time duration_list = end_ind - start_ind return duration_list duration_piano = get_duration(event_piano, T_piano) duration_orch = get_duration(event_orch, T_orch) # Get the duration of each event pr_piano_event = warp_pr_aux(pr_piano, event_piano) pr_orch_event = warp_pr_aux(pr_orch, event_orch) else: event_piano = None event_orch = None duration_piano = None duration_orch = None pr_piano_event = pr_piano pr_orch_event = pr_orch ############################## ############################## # # Test for event-leve -> beat reconstruction # ############################## # # Instru mapping # import pickle as pkl # import LOP_database.utils.event_level as event_level # import LOP_database.utils.reconstruct_pr as reconstruct_pr # temp = pkl.load(open("/Users/crestel/Recherche/lop/LOP/Data/Data_A_ref_bp_bo_noEmb_tempGran32/temp.pkl", 'rb')) # instru_mapping = temp['instru_mapping'] # N_orchestra = temp['N_orchestra'] # N_piano = temp['instru_mapping']['Piano']['index_max'] # matrix_orch = cast_small_pr_into_big_pr(pr_orch_event, 0, len(event_orch), instru_mapping, np.zeros((len(event_orch), N_orchestra))) # matrix_piano = cast_small_pr_into_big_pr(pr_piano_event, 0, len(event_piano), instru_mapping, np.zeros((len(event_piano), N_piano))) # ############################## # # Reconstruct rhythm # pr_orchestra_rhythm = event_level.from_event_to_frame(matrix_orch, event_orch) # pr_orchestra_rhythm_I = reconstruct_pr.instrument_reconstruction(pr_orchestra_rhythm, instru_mapping) # pr_piano_rhythm = event_level.from_event_to_frame(matrix_piano, event_piano) # pr_piano_rhythm_I = reconstruct_pr.instrument_reconstruction_piano(pr_piano_rhythm, instru_mapping) # ############################## # # Write midi # write_midi({k: v*90 for k,v in pr_piano_rhythm_I.items()}, ticks_per_beat=quantization, write_path="../DEBUG/test_piano_event.mid", articulation=articulation_piano) # write_midi({k: v*90 for k,v in pr_orchestra_rhythm_I.items() if (v.sum()>0)}, ticks_per_beat=quantization, write_path="../DEBUG/test_orch_event.mid", articulation=articulation_orch) ############################## ############################## # Align tracks if align_bool: # piano_aligned, trace_piano, orch_aligned, trace_orch, trace_prod, total_time = align_pianorolls(pr_piano_event, pr_orch_event, gapopen, gapextend) piano_aligned, trace_piano, orch_aligned, trace_orch, trace_prod, total_time = align_pianorolls(pr_piano_event, pr_orch_event, gapopen, gapextend) # Clean events if (temporal_granularity == 'event_level'): if (trace_piano is None) or (trace_orch is None): event_piano_aligned = None event_orch_aligned = None duration_piano_aligned = None duration_orch_aligned = None else: event_piano_aligned = clean_event(event_piano, trace_piano, trace_prod) event_orch_aligned = clean_event(event_orch, trace_orch, trace_prod) duration_piano_aligned = clean_event(duration_piano, trace_piano, trace_prod) duration_orch_aligned = clean_event(duration_orch, trace_orch, trace_prod) else: event_piano_aligned = [] event_orch_aligned = [] duration_piano_aligned = [] duration_orch_aligned = [] else: piano_aligned = pr_piano_event event_piano_aligned = event_piano duration_piano_aligned = duration_piano orch_aligned = pr_orch_event event_orch_aligned = event_orch duration_orch_aligned = duration_orch total_time = T_piano ############################## ############################## ############################## # Test for aligned event Piano/Orch ############################## # Instru mapping # import pickle as pkl # import LOP_database.utils.event_level as event_level # import LOP_database.utils.reconstruct_pr as reconstruct_pr # temp = pkl.load(open("/Users/leo/Recherche/lop/LOP/Data/Data_DEBUG_bp_bo_noEmb_tempGran32/temp.pkl", 'rb')) # instru_mapping = temp['instru_mapping'] # N_orchestra = temp['N_orchestra'] # N_piano = temp['instru_mapping']['Piano']['index_max'] # matrix_orch = cast_small_pr_into_big_pr(orch_aligned, 0, len(event_orch_aligned), instru_mapping, np.zeros((len(event_orch_aligned), N_orchestra))) # matrix_piano = cast_small_pr_into_big_pr(piano_aligned, 0, len(event_piano_aligned), instru_mapping, np.zeros((len(event_piano_aligned), N_piano))) # ############################## # # Reconstruct rhythm # pr_orchestra_I = reconstruct_pr.instrument_reconstruction(matrix_orch, instru_mapping) # pr_orchestra_rhythm = event_level.from_event_to_frame(matrix_orch, event_orch_aligned) # pr_orchestra_rhythm_I = reconstruct_pr.instrument_reconstruction(pr_orchestra_rhythm, instru_mapping) # # # pr_piano_I = reconstruct_pr.instrument_reconstruction_piano(matrix_piano, instru_mapping) # pr_piano_rhythm = event_level.from_event_to_frame(matrix_piano, event_piano_aligned) # pr_piano_rhythm_I = reconstruct_pr.instrument_reconstruction_piano(pr_piano_rhythm, instru_mapping) # ############################## # # Write midi # write_midi({k: v*90 for k,v in pr_piano_I.items()}, ticks_per_beat=1, write_path="../DEBUG/test_piano_event_aligned.mid", articulation=None) # write_midi({k: v*90 for k,v in pr_piano_rhythm_I.items()}, ticks_per_beat=quantization, write_path="../DEBUG/test_piano_rhythm_aligned.mid", articulation=None) # # # write_midi({k: v*90 for k,v in pr_orchestra_I.items() if (v.sum()>0)}, ticks_per_beat=1, write_path="../DEBUG/test_orch_event_aligned.mid", articulation=None) # write_midi({k: v*90 for k,v in pr_orchestra_rhythm_I.items() if (v.sum()>0)}, ticks_per_beat=quantization, write_path="../DEBUG/test_orch_rhythm_aligned.mid", articulation=None) # import pdb; pdb.set_trace() ############################## return piano_aligned, event_piano_aligned, duration_piano_aligned, name_piano, orch_aligned, event_orch_aligned, duration_orch_aligned, name_orch, total_time