'[2000;1000,1000;500,500,1000;2000]',

'[1000,1000;500,500,1000;1000,1000;2000]',

'[1000,--(1000);1000,--(1000);500,250,250,1000;--(1000),1000]',

'[500;1000,500,1000,500;500,500,500,250,250,500,500;250,250,500,500,1000]',

'[1000,--(1000);1000,--(1000);1000,-(500),500;1000,1000]',

'[750,250,500,500,500,-(500);500,1000,500,500,-(500);750,250,500,500,500,-(500)]',

'[500,1000,500,500,250,250;1000,500,750,250,500;3000]',

'[500,500,500;1000,500;500,500,500;1500;500,500,500;1000,500;500;1000;1500]',

'[5,5,3,2,1,2,5,3,2]',

'[5,5,3,2,1,2,2,3,2,6-,5-]',

'[5,1+,7,1+,2+,1+,7,6,5,2,4,3,6,5]',

'[3,6,7,1+,2+,1+,7,6,3]',

'[1+,7,1+,2+,3+,2+,1+,7,6,7,1+,2+,7,1+,7,1+,2+,1+]',

'[5,6,1+,6,2,3,1,6-,5-]',

'[5,5,6,5,6,5,1,3,0,2,2,5-,2,1]',

'[3,2,1,2,1,1,2,3,4,5,3,6,5,5,3]',

'[1000,1000;500,500,1000;1000,500,500; 2000]',

'[1000,1000;500,500,1000;500,250,250,500,500;2000]',

'[500,1000,500;250,250,250,250,500,500;500,500,500,500;2000]',

'[1000;500,500,1000;500,500,500,500;2000]',

'[500;500,500,500,500;500,500,500,500;500,500,500,500;250,250,250,250,500]',

'[1000,750,250,2000;500,500,500,500,2000]',

'[1000,1000,1000,500,500;1000,1000,1000,--(1000);1000,1000,1000;1000,4000]',

'[1500,500,500,500;2500,500;1000,500,500,500,500;2500,500]',

if type == 1:

code = test_codes[index]

if type == 2:

code = test_rhythm_codes[index]

if type == 3:

code = test_note_codes[index]

# code = code.replace(";", ',')

# code = code.replace("[", '')

# code = code.replace("]", '')

# code = [x for x in code.split(',')]

if filename.find("节奏10") >= 0 or filename.find("节奏十") >= 0 or filename.find("节奏题十") >= 0 or filename.find(

"节奏题10") >= 0 or filename.find("节10") >= 0:

return 9

elif filename.find("节奏1") >= 0 or filename.find("节奏一") >= 0 or filename.find("节奏题一") >= 0 or filename.find(

"节奏题1") >= 0 or filename.find("节1") >= 0:

return 0

elif filename.find("节奏2") >= 0 or filename.find("节奏二") >= 0 or filename.find("节奏题二") >= 0 or filename.find(

"节奏题2") >= 0 or filename.find("节2") >= 0:

return 1

elif filename.find("节奏3") >= 0 or filename.find("节奏三") >= 0 or filename.find("节奏题三") >= 0 or filename.find(

"节奏题3") >= 0 or filename.find("节3") >= 0:

return 2

elif filename.find("节奏4") >= 0 or filename.find("节奏四") >= 0 or filename.find("节奏题四") >= 0 or filename.find(

"节奏题4") >= 0 or filename.find("节4") >= 0:

return 3

elif filename.find("节奏5") >= 0 or filename.find("节奏五") >= 0 or filename.find("节奏题五") >= 0 or filename.find(

"节奏题5") >= 0 or filename.find("节5") >= 0:

return 4

elif filename.find("节奏6") >= 0 or filename.find("节奏六") >= 0 or filename.find("节奏题六") >= 0 or filename.find(

"节奏题6") >= 0 or filename.find("节6") >= 0:

return 5

elif filename.find("节奏7") >= 0 or filename.find("节奏七") >= 0 or filename.find("节奏题七") >= 0 or filename.find(

"节奏题7") >= 0 or filename.find("节7") >= 0:

return 6

elif filename.find("节奏8") >= 0 or filename.find("节奏八") >= 0 or filename.find("节奏题八") >= 0 or filename.find(

"节奏题8") >= 0 or filename.find("节8") >= 0:

return 7

elif filename.find("节奏9") >= 0 or filename.find("节奏九") >= 0 or filename.find("节奏题九") >= 0 or filename.find(

"节奏题9") >= 0 or filename.find("节9") >= 0:

return 8

else:

if filename.find("旋律10") >= 0 or filename.find("旋律十") >= 0 or filename.find("视唱十") >= 0 or filename.find(

"视唱10") >= 0 or filename.find("旋10") >= 0:

return 9

elif filename.find("旋律1") >= 0 or filename.find("旋律一") >= 0 or filename.find("视唱一") >= 0 or filename.find(

"视唱1") >= 0 or filename.find("旋1") >= 0:

return 0

elif filename.find("旋律2") >= 0 or filename.find("旋律二") >= 0 or filename.find("视唱二") >= 0 or filename.find(

"视唱2") >= 0 or filename.find("旋2") >= 0:

return 1

elif filename.find("旋律3") >= 0 or filename.find("旋律三") >= 0 or filename.find("视唱三") >= 0 or filename.find(

"视唱3") >= 0 or filename.find("旋3") >= 0:

return 2

elif filename.find("旋律4") >= 0 or filename.find("旋律四") >= 0 or filename.find("视唱四") >= 0 or filename.find(

"视唱4") >= 0 or filename.find("旋4") >= 0:

return 3

elif filename.find("旋律5") >= 0 or filename.find("旋律五") >= 0 or filename.find("视唱五") >= 0 or filename.find(

"视唱5") >= 0 or filename.find("旋5") >= 0:

return 4

elif filename.find("旋律6") >= 0 or filename.find("旋律六") >= 0 or filename.find("视唱六") >= 0 or filename.find(

"视唱6") >= 0 or filename.find("旋6") >= 0:

return 5

elif filename.find("旋律7") >= 0 or filename.find("旋律七") >= 0 or filename.find("视唱七") >= 0 or filename.find(

"视唱7") >= 0 or filename.find("旋7") >= 0:

return 6

elif filename.find("旋律8") >= 0 or filename.find("旋律八") >= 0 or filename.find("视唱八") >= 0 or filename.find(

"视唱8") >= 0 or filename.find("旋8") >= 0:

return 7

elif filename.find("旋律9") >= 0 or filename.find("旋律九") >= 0 or filename.find("视唱九") >= 0 or filename.find(

"视唱9") >= 0 or filename.find("旋9") >= 0:

return 8

else:

"""保存txt数据

:param content:需要保存的数据,type->list

:param filename:文件名

:param mode:读写模式:'w' or 'a'

:return: void

"""

with open(filename, mode) as f:

y, sr = librosa.load(filename)

rms = librosa.feature.rmse(y=y)[0]

rms = [x / np.std(rms) for x in rms]

CQT = librosa.amplitude_to_db(librosa.cqt(y, sr=16000), ref=np.max)

w, h = CQT.shape

CQT = np.where(CQT > -22, np.max(CQT), np.min(CQT))

min_cqt = np.min(CQT)

max_cqt = np.max(CQT)

result = [0,0,0,0,0,0,0,0,0,0]

for i in range(10,h):

col_cqt = CQT[:,i]

before_col_cqt = CQT[:,i-1]

diff_sum = np.sum([1 if col_cqt[i] == max_cqt and before_col_cqt[i] == min_cqt else 0 for i in range(len(col_cqt))])

result.append(diff_sum)

# b, a = signal.butter(4, 0.3, analog=False)

#

# sig_ff = signal.filtfilt(b, a, result)

from scipy.signal import savgol_filter

sig_ff = savgol_filter(rms, 11, 1) # window size 51, polynomial order 3

sig_ff = [x / np.max(sig_ff) for x in sig_ff]

max_indexs = [i for i in range(1,len(sig_ff)-1) if sig_ff[i]>sig_ff[i-1] and sig_ff[i]>sig_ff[i+1] and sig_ff[i] > 0.2]

#print("filename is {}".format(filename))

# y, sr = librosa.load(filename)

# CQT = librosa.amplitude_to_db(librosa.cqt(y, sr=16000), ref=np.max)

# w, h = CQT.shape

# CQT = np.where(CQT > -22, np.max(CQT), np.min(CQT))

# min_cqt = np.min(CQT)

# max_cqt = np.max(CQT)

#

# CQT = signal.medfilt(CQT, (15, 15)) # 二维中值滤波

#

#

# result = []

# last_i = 0

# for i in range(10,h):

# col_cqt = CQT[30:,i]

# before_col_cqt_1 = CQT[30:,i-1]

# before_col_cqt_2 = CQT[30:, i - 2]

# before_col_cqt_3 = CQT[30:, i - 3]

# before_col_cqt_4 = CQT[30:, i - 4]

# before_col_cqt_5 = CQT[30:, i - 5]

# sum_col_cqt = np.sum([1 for i in range(len(col_cqt)) if col_cqt[i] == max_cqt])

# sum_before_col_cqt_1 = np.sum([1 for i in range(len(before_col_cqt_1)) if before_col_cqt_1[i] == max_cqt])

# sum_before_col_cqt_2 = np.sum([1 for i in range(len(before_col_cqt_2)) if before_col_cqt_2[i] == max_cqt])

# sum_before_col_cqt_3 = np.sum([1 for i in range(len(before_col_cqt_3)) if before_col_cqt_3[i] == max_cqt])

# sum_before_col_cqt_4 = np.sum([1 for i in range(len(before_col_cqt_4)) if before_col_cqt_4[i] == max_cqt])

# sum_before_col_cqt_5 = np.sum([1 for i in range(len(before_col_cqt_5)) if before_col_cqt_5[i] == max_cqt])

# sum_min = np.min([sum_before_col_cqt_1,sum_before_col_cqt_2,sum_before_col_cqt_3,sum_before_col_cqt_4,sum_before_col_cqt_5])

# #if sum_col_cqt >=5 + sum_min and sum_min <3 and i - last_i > 5:

# if sum_col_cqt >= 1 + sum_min and i - last_i > 5:

# result.append(i)

# last_i = i

#

# return result

sum_cols, sig_ff = get_sum_max_for_cols(filename,filter_p1,filter_p2,row_level)

sig_ff = [x / np.std(sig_ff) for x in sig_ff]

starts = [i for i in range(1,len(sig_ff)-1) if sig_ff[i] > sig_ff[i-1] and sig_ff[i] >= sig_ff[i+1] and sig_ff[i] >np.mean(sig_ff)*0.5]

# starts = [i for i in range(10,len(sum_cols)-1) if sum_cols[i] > sum_cols[i-1] and np.max(sum_cols[i-5:i-1]) == 0]

if len(starts) == 0:

return []

selected_starts = [starts[0]]

for i in range(1,len(starts)):

s = selected_starts[-1]

e = starts[i]

if np.min(sum_cols[s:e]) <= sum_cols_threshold and (sig_ff[e] - np.min(sig_ff[s:e]) > np.mean(sig_ff)*0.5 and sig_ff[s] - np.min(sig_ff[s:e]) > np.mean(sig_ff)*0.5):

selected_starts.append(e)

selected_starts = [x -2 for x in selected_starts]

sum_cols, sig_ff = get_sum_max_for_cols(filename,filter_p1,filter_p2,row_level)

tmp = np.zeros(len(sum_cols))

for i in range(1, len(sum_cols) - 1):

tmp[i] = np.max(sum_cols[i - 1:i + 2])

sig_ff = signal.medfilt(tmp, 1) # 二维中值滤波

sig_ff = [x / np.std(sig_ff) for x in sig_ff]

#starts = [i for i in range(1,len(sig_ff)-1) if sig_ff[i] > sig_ff[i-1] and sig_ff[i] >= sig_ff[i+1] and sig_ff[i] >np.mean(sig_ff)*0.5]

# starts = [i for i in range(1, len(sig_ff) - 6) if sig_ff[i] > sig_ff[i - 1] and sig_ff[i-1] == 0 or(sig_ff[i-1] > sig_ff[i] and sig_ff[i+1] > sig_ff[i] and np.max(sig_ff[i-1:i+5]) - np.min(sig_ff[i-1:i+5]) > np.max(sig_ff)*0.5)]

starts = [i for i in range(1, len(sig_ff) - 6) if sig_ff[i] > sig_ff[i - 1] and sig_ff[i-1] == 0 and sig_ff[i-1] == 0 or(sig_ff[i-1] > sig_ff[i] and sig_ff[i+1] > sig_ff[i] and np.max(sig_ff[i-1:i+5]) - np.min(sig_ff[i-1:i+5]) > np.max(sig_ff)*0.5)]

selected_starts = starts

# sig_ff_on_starts = [sig_ff[i] for i in starts]

# starts = [x for x in starts if sig_ff[x] > np.mean(sig_ff_on_starts)* 0.80]

# starts = [i for i in range(10,len(sig_ff)-1) if sig_ff[i] > sig_ff[i-1] and np.max(sig_ff[i-4:i]) == 0]

# if len(starts) == 0:

# return []

# selected_starts = [starts[0]]

# for i in range(1,len(starts)):

# s = selected_starts[-1]

# e = starts[i]

# if np.min(sum_cols[s:e]) <= sum_cols_threshold and (sig_ff[e] - np.min(sig_ff[s:e]) > np.mean(sig_ff)*0.5 and sig_ff[s] - np.min(sig_ff[s:e]) > np.mean(sig_ff)*0.5):

# selected_starts.append(e)

selected_starts = [x for x in selected_starts]

base_total = len(base_frames)

# print("start, end,base_total is {},{},{}".format(start, end,base_total))

best_gap_number = 1000

best_start_indexs = []

rms, rms_diff, sig_ff, max_indexs = get_rms_max_indexs_for_onset(filename)

for row_level in range(30,60,3):

start_indexs = get_cqt_start_indexs_v2(filename, filter_p1=7, filter_p2=1, row_level = row_level, sum_cols_threshold=1)

start_indexs = [x for x in start_indexs if x > start-6 and x < end]

# if len(start_indexs) == len(max_indexs):

# gaps = [np.abs(max_indexs[i] - start_indexs[i]) for i in range(len(start_indexs))]

# if np.max(gaps) < 6:

# return start_indexs

# print("row_level is {}".format(row_level))

# print("base_frames is {} ,size {}".format(base_frames, len(base_frames)))

# print("start_indexs is {} ,size {}".format(start_indexs, len(start_indexs)))

xc, yc, path1, path2,loss_indexs = get_matched_frames(base_frames, start_indexs)

if len(xc) == len(base_frames) and len(yc) != 0:

return yc

tmp = []

for x in start_indexs:

offset = [np.abs(x - m) for m in max_indexs]

if np.min(offset) < 10:

tmp.append(x)

start_indexs = tmp

# if len(start_indexs) >= base_total:

# return start_indexs

if np.abs(len(start_indexs) - base_total) < best_gap_number:

best_gap_number = np.abs(len(start_indexs) - base_total)

best_start_indexs = start_indexs

if len(best_start_indexs) == base_total:

return best_start_indexs

else:

xc, yc, path1, path2,loss_indexs = get_matched_frames(base_frames, best_start_indexs)

y, sr = librosa.load(filename)

CQT = librosa.amplitude_to_db(librosa.cqt(y, sr=16000), ref=np.max)

w, h = CQT.shape

CQT = np.where(CQT > -22, np.max(CQT), np.min(CQT))

CQT = signal.medfilt(CQT, (15, 15)) # 二维中值滤波

result = []

for i in range(1,h-4):

col_cqt = CQT[10:,i]

before_col_cqt = CQT[10:,i-1]

sum = np.sum([1 if before_col_cqt[i] != col_cqt[i] else 0 for i in range(len(col_cqt))])

result.append(sum)

code = parse_onset_code(onset_code)

code = [int(x) for x in code]

sum_cols, sig_ff = get_sum_max_for_cols(filename)

#cqt_col_diff = get_cqt_col_diff(filename)

cqt_col_diff = np.array(sum_cols)

cqt_col_diff[-10:] = 0

#cqt_col_diff = [x if x > 2 else 0 for x in cqt_col_diff]

end = len(cqt_col_diff)

starts = get_cqt_start_indexs(filename)

if len(starts) == 0:

return 0,0,0

start = starts[0]

# for i in range(2,len(cqt_col_diff)):

# if np.max(cqt_col_diff[:i-1]) <= 2 and cqt_col_diff[i] >2:

# start = i

for i in range(len(cqt_col_diff)-6,0,-1):

if np.max(cqt_col_diff[i+1:]) <= 1 and cqt_col_diff[i] >=1:

end = i

start_indexs = get_cqt_start_indexs(filename)

if code[-1] >= 2000:

end = end + (end - start - (end - start_indexs[-1])) * code[-1]/(np.sum(code[:-1])) - (end - start_indexs[-1])

if end > len(sum_cols):

end = len(sum_cols) - 10

y, sr = librosa.load(filename)

CQT = librosa.amplitude_to_db(librosa.cqt(y, sr=16000), ref=np.max)

w, h = CQT.shape

CQT = np.where(CQT > -22, np.max(CQT), np.min(CQT))

min_cqt = np.min(CQT)

max_cqt = np.max(CQT)

CQT = signal.medfilt(CQT, (5, 5)) #二维中值滤波

# 滤波去噪声

for i in range(10, h):

col_cqt = CQT[:, i]

sum_col = np.sum([1 if x == max_cqt else 0 for x in col_cqt])

# if sum_col <= 5:

# CQT[:, i] = min_cqt

# continue

for j in range(10, w - 5):

if col_cqt[j + 1] == min_cqt and col_cqt[j - 1] == min_cqt and col_cqt[j] == max_cqt:

CQT[j, i] = min_cqt

result = [0,0,0,0,0,0,0,0,0,0]

for i in range(10, h):

col_cqt = CQT[row_level:, i]

sum_col_cqt = np.sum([1 for i in range(len(col_cqt)) if col_cqt[i] == max_cqt])

result.append(sum_col_cqt)

from scipy.signal import savgol_filter

sig_ff = savgol_filter(result, filter_p1, filter_p2) # window size 51, polynomial order 3

# b, a = signal.butter(4, 0.2, analog=False)

# sig_ff = signal.filtfilt(b, a, result)

#sig_ff = [x / np.max(sig_ff) for x in sig_ff]

code = onset_code

indexs = []

code = code.replace(";", ',')

code = code.replace("[", '')

code = code.replace("]", '')

tmp = [x for x in code.split(',')]

for i in range(len(tmp)):

if tmp[i].find("(") >= 0:

indexs.append(i)

while code.find("(") >= 0:

code = code.replace("(", '')

code = code.replace(")", '')

code = code.replace("-", '')

code = code.replace("--", '')

code = [x for x in code.split(',')]

result = []

for i in range(len(code)):

if i in indexs:

continue

elif i+1 not in indexs:

result.append(code[i])

else:

t = int(code[i]) + int(code[i+1])

result.append(t)

code = parse_onset_code(onset_code)

result = []

less_end = 0

for i in range(len(code)):

x = int(code[i])

if i >= less_end:

if x < 500:

for n in range(i,len(code)):

if int(code[n]) >= 500:

less_end = n

break

tmp = np.sum([int(code[m]) for m in range(i,less_end)])

result.append(tmp)

else:

result.append(x)

if len(start_indexs) == 0:

return []

#print("start_index is {},size is {}".format(start_indexs,len(start_indexs)))

code = parse_onset_code(onset_code)

code = [int(x) for x in code]

#print("code is {},size is {}".format(code, len(code)))

total_length_no_last = np.sum(code[:-1])

real_total_length_no_last = start_indexs[-1] - start_indexs[0]

rate = real_total_length_no_last/total_length_no_last

code_dict = {}

for x in range(125, 4000, 125):

code_dict[x] = int(x * rate)

# width_2000 = int(2000 * rate)

# width_1500 = int(1500 * rate)

# width_1000 = int(1000 * rate)

# width_750 = int(750 * rate)

# width_500 = int(500 * rate)

# width_375 = int(375 * rate)

# width_250 = int(250 * rate)

# width_125 = int(125 * rate)

# code_dict = {2000: width_2000, 1500: width_1500, 1000: width_1000, 750: width_750, 500: width_500, 375: width_375, 250: width_250, 125: width_125}

less_500 = [i for i in range(len(code)) if int(code[i]) < 500 and int(code[i]) == np.min(code)]

if len(less_500) == len(code) - len(start_indexs):

for i in less_500:

start_indexs.append(start_indexs[i] + code_dict.get(int(code[i])))

start_indexs.sort()

else:

for i in range(len(code) -1):

if i+1 >= len(start_indexs) -1:

return start_indexs

onset_width = start_indexs[i+1] - start_indexs[i]

base_width = code_dict.get(code[i])

next_base_width = code_dict.get(code[i+1])

offset = np.abs((base_width - onset_width)/base_width) # 宽度误差

offset_with_next = np.abs((base_width + next_base_width - onset_width) / (base_width + next_base_width)) # 宽度误差

next_code = int(code[i+1])

if next_code < 500:

if offset_with_next < 0.35 and len(code) > len(start_indexs):

start_indexs.append(start_indexs[i] + int(onset_width*base_width/(base_width + next_base_width)))

start_indexs.sort()

#print("add")

else:

#print("ok")

pass

sum_cols, sig_ff = get_sum_max_for_cols(filename, filter_p1=31, filter_p2=12)

starts = [i for i in range(1, len(sig_ff) - 1) if sig_ff[i] > sig_ff[i - 1] and sig_ff[i] >= sig_ff[i + 1] and sig_ff[i] > 3]

starts_diff = np.diff(starts)

#print("starts_diff is {},size is {}".format(starts_diff, len(starts_diff)))

code = parse_onset_code(onset_code)

code = [int(x) for x in code]

#print("code is {},size is {}".format(code, len(code)))

total_length_no_last = np.sum(code[:-1])

if len(start_indexs) == 0:

return

real_total_length_no_last = start_indexs[-1] - start_indexs[0]

rate = real_total_length_no_last / total_length_no_last

width_375 = int(375 * rate)

#print("width_375 is {}".format(width_375))

width_250 = int(250 * rate)

#print("width_250 is {}".format(width_250))

width_125 = int(125 * rate)

euclidean_norm = lambda x, y: np.abs(x - y)

d, cost_matrix, acc_cost_matrix, path = dtw(onset_frames,base_frames, dist=euclidean_norm)

dis = d * np.sum(acc_cost_matrix.shape)

start, end, total_frames_number = get_onset_frame_length(filename,onset_code)

base_frames = onsets_base_frames(onset_code, total_frames_number)

base_frames = get_base_frames_for_onset(filename,onset_code)

base_frames_diff = np.diff(base_frames)

best_dis = 0

best_start_indexs = get_cqt_start_indexs(filename)

best_row_level = 31

for row_level in range(31,55):

start_indexs = get_cqt_start_indexs(filename, filter_p1=31, filter_p2=12, row_level=row_level)

start_indexs_diff = np.diff(start_indexs)

base_frames = [x - (base_frames[0]-start_indexs[0]) for x in base_frames]

dis = get_dtw(start_indexs_diff,base_frames_diff)

print("row_level,dis is {},{}".format(row_level, dis))

if dis > best_dis and len(start_indexs) == len(base_frames):

best_dis = dis

best_start_indexs = start_indexs

best_row_level = row_level

print("best_row_level,best_start_indexs is {},{}".format(best_row_level,best_start_indexs))

if len(start_indexs) == 0:

return []

#print("start_index is {},size is {}".format(start_indexs,len(start_indexs)))

code = parse_onset_code(onset_code)

code = [int(x) for x in code]

#print("code is {},size is {}".format(code, len(code)))

total_length_no_last = np.sum(code[:-1])

real_total_length_no_last = start_indexs[-1] - start_indexs[0]

rate = real_total_length_no_last/total_length_no_last

code_dict = {}

for x in range(125,4000,125):

code_dict[x] = int(x * rate)

for i in range(len(code)):

#print("code {} is {}".format(i,code[i]))

if i + 1 > len(start_indexs) - 1:

return start_indexs

onset_width = start_indexs[i+1] - start_indexs[i]

if i+2 <= len(start_indexs) - 1:

next_onset_width = start_indexs[i+2] - start_indexs[i+1]

else:

next_onset_width = 1

base_width = code_dict.get(code[i])

if i+1 <= len(code) -1:

next_base_width = code_dict.get(code[i+1])

else:

next_base_width = 0

offset = np.abs((base_width - onset_width)/base_width) # 宽度误差

offset_with_next = np.abs((base_width + next_base_width - onset_width) / (base_width + next_base_width)) # 宽度误差

offset_with_next_real = np.abs((onset_width + next_onset_width - base_width) / base_width) # 宽度误差

#如果是2000，则要判断是否拖带尾声

if int(code[i]) == 2000:

if i == len(code)-1 and start_indexs[i + 1] is not None: #最后一个拖带尾声

start_indexs.remove(start_indexs[i + 1])

#print("remove")

elif onset_width < base_width * 0.4 and offset_with_next_real < 0.48: #拖带尾声

start_indexs.remove(start_indexs[i+1])

#print("remove")

#如果是375或250，则要判断是否漏检

elif int(code[i]) == 375 or int(code[i]) == 250:

if offset_with_next < 0.3: #漏检

start_indexs.append(start_indexs[i] + int(onset_width * base_width / (base_width + next_base_width)))

start_indexs.sort()

#print("add")

else:

#print("ok")

pass

base_frames_diff = np.diff(base_frames)

max_indexs_diff = np.diff(max_indexs)

raw_dis = get_dtw(max_indexs_diff,base_frames_diff)

del_maxs = []

last_del_i = 0

last_del_dis = 100000

selected_max_indexs = max_indexs.copy()

for i in range(1,len(max_indexs)):

x = max_indexs[i]

offset = [np.abs(x - s) for s in start_indexs]

if np.min(offset)<=2: #即在cqt识别出的节拍中，则不作删除处理，相信cqt识别结果

continue

tmp = [m for m in max_indexs if m != x]

dis = get_dtw(np.diff(tmp), base_frames_diff)

dis_selected = get_dtw(np.diff(selected_max_indexs), base_frames_diff)

if dis < raw_dis and dis < dis_selected:

if i - last_del_i == 1:

if dis < last_del_dis:

del_maxs.append(x)

if max_indexs[last_del_i] in del_maxs:

del_maxs.remove(max_indexs[last_del_i])

# else:

# del_maxs.append(max_indexs[last_del_i])

else:

del_maxs.append(x)

last_del_i = i

last_del_dis = dis

selected_max_indexs = [x for x in max_indexs if x not in del_maxs]

#通过与cqt起始点的距离判断可能的伪节拍

fake_onset_frames = []

for x in onset_frames:

offset = [np.abs(x-s) for s in start_indexs]

if np.min(offset) > 5:

fake_onset_frames.append(x)

code = parse_onset_code(onset_code)

code = [int(x) for x in code]

if len(onset_frames) - len(fake_onset_frames) == len(code):

tmp = [ x for x in onset_frames if x not in fake_onset_frames]

return tmp,fake_onset_frames

best_dis = 1000000

best_onset_frames = onset_frames

if len(fake_onset_frames)>0:

while len(best_onset_frames) > len(code):

onset_frames_tmp = best_onset_frames.copy()

flag = True

for f in fake_onset_frames:

tmp = [o for o in onset_frames_tmp if o != f]

types = get_onset_type(tmp, onset_code)

dis = get_dtw(types, code[:-1])

if dis < best_dis:

best_onset_frames = tmp

best_dis = dis

flag = False

if flag == True:

return best_onset_frames, fake_onset_frames

else:

return onset_frames,fake_onset_frames