def analysis(compositions):
# intervals
midi_intervals = utils.get_music_data_attrib(compositions, 'intervals_midi', 'extend')
nested_midi_intervals = utils.get_music_data_attrib(compositions, 'intervals_midi', 'append')
# durations
dur = utils.get_music_data_attrib(compositions, 'durations', 'extend')
nested_dur = utils.get_music_data_attrib(compositions, 'durations', 'append')
# contour
contour_list = utils.get_music_data_attrib(compositions, 'contour', 'append')
tests = [midi_intervals,
nested_midi_intervals,
dur,
nested_dur,
contour_list]
if all(tests):
# intervals
cat_intervals = list(map(intervals.get_category, midi_intervals))
cat_nested_intervals = [list(map(intervals.get_category, s)) for s in nested_midi_intervals]
coll_freq_intervals = utils.special_counter(cat_intervals, True)
# durations
coll_freq_durations = utils.special_counter(dur, True)
# contour
freq_dist_args = {}
for size in range(2, 5):
split_seq = list(map(tuple, contour.split_and_translate_nested(contour_list, size)))
split_seq_nested = [list(map(tuple, contour.split_and_translate(c, size))) for c in contour_list]
coll_freq_dic = contour.get_frequency(split_seq, size)
freq_dist_sc = utils.frequency_distance_scatter(compositions, split_seq_nested, coll_freq_dic, True)
freq_dist_args.update({'contour_{}_distance'.format(size): freq_dist_sc})
freq_data = [
['Duration', nested_dur, coll_freq_durations],
['Interval', cat_nested_intervals, coll_freq_intervals],
]
args = {
'intervals_distance': utils.frequency_distance_scatter(compositions, cat_nested_intervals, coll_freq_intervals, True),
'durations_distance': utils.frequency_distance_scatter(compositions, nested_dur, coll_freq_durations, True),
'id_distance': utils.frequency_distance_scatter_group(compositions, freq_data, True),
}
args.update(freq_dist_args)
else:
args = {}
return args
def chromatic_leaps_frequency_pie(chromatic_intervals):
counted = utils.special_counter(chromatic_intervals, False)
for i in ['P1', 'M2', 'm2', 'M3', 'm3']:
del counted[i]
r = utils.aux_pie_chart(counted)
r.insert(0, ['Interval', 'Amount'])
return r
def analysis(compositions):
midi_intervals = utils.get_music_data_attrib(compositions, 'intervals_midi', 'extend')
nested_midi_intervals = utils.get_music_data_attrib(compositions, 'intervals_midi', 'append')
simple_intervals = [abs(x) % 12 for x in midi_intervals]
chromatic_intervals = utils.get_music_data_attrib(compositions, 'intervals')
adjacent_intervals = []
for seq in nested_midi_intervals:
adjacent_intervals.extend(get_adjacent_intervals(seq))
basic_stats = utils.aux_basic_stats(midi_intervals, 'Intervals number', False)
categorized_midi_intervals = list(map(get_category, midi_intervals))
categorized_nested_midi_intervals = [list(map(get_category, s)) for s in nested_midi_intervals]
coll_freq_dic = utils.special_counter(categorized_midi_intervals, True)
if midi_intervals and chromatic_intervals:
args = {
'frequency_scatter': frequency_scatter(midi_intervals),
'frequency_basic_scatter': frequency_scatter(simple_intervals),
'basic_stats': basic_stats,
'frequency_pie': frequency_pie(midi_intervals),
'chromatic_frequency_pie': frequency_pie(chromatic_intervals),
'chromatic_leaps_frequency_pie': chromatic_leaps_frequency_pie(chromatic_intervals),
'histogram': utils.histogram(midi_intervals, 10, ['Intervals', 'Ocurrences'], False, True),
'distribution_amount': utils.distribution(midi_intervals, basic_stats, True),
'category_frequency_pie': frequency_pie(list(map(get_category, midi_intervals))),
'adjacent_frequency_pie': frequency_pie(adjacent_intervals),
'adjacent_frequency_bubble': make_adjacent_chart(adjacent_intervals),
'pitch_class_distance': utils.frequency_distance_scatter(compositions, categorized_nested_midi_intervals, coll_freq_dic),
}
else:
args = {}
return args
def analysis(compositions):
durations = utils.get_music_data_attrib(compositions, 'durations', 'extend')
nested_durations = utils.get_music_data_attrib(compositions, 'durations', 'append')
piece_durations = utils.get_music_data_attrib(compositions, 'total_duration', 'append')
basic_stats_duration = utils.aux_basic_stats(durations, 'Durations number', False)
basic_stats_piece_duration = utils.aux_basic_stats(piece_durations, 'Durations number', False)
coll_freq_dic = utils.special_counter(durations, True)
if durations and piece_durations:
args = {
'basic_stats_duration': basic_stats_duration,
'note_frequency_scatter': frequency_scatter(durations),
'note_frequency_pie': frequency_pie(durations),
'note_histogram': utils.histogram(durations, 10, ['Durations', 'Ocurrences'], False, True),
'note_distribution_amount': utils.distribution(durations, basic_stats_duration, True),
'basic_stats_piece_duration': basic_stats_piece_duration,
'piece_frequency_scatter': frequency_scatter(piece_durations),
'piece_frequency_pie': frequency_pie(piece_durations),
'piece_histogram': utils.histogram(piece_durations, 10, ['Durations', 'Ocurrences'], False, True),
'piece_distribution_amount': utils.distribution(piece_durations, basic_stats_duration, True),
'frequency_distance': utils.frequency_distance_scatter(compositions, nested_durations, coll_freq_dic),
}
else:
args = {}
return args
def make_adjacent_chart(adjacent_intervals):
counted = utils.special_counter(adjacent_intervals, True)
seq = [['Label', 'X', 'Y', 'Value']]
for key, value in counted.items():
x, y = key
label = '{}, {}'.format(x, y)
seq.append(['', x, y, value])
return seq
def aux(composition):
intervals = composition.music_data.intervals_midi
counted = utils.special_counter(intervals, True)
seq = []
for i in range(-48, 49):
if i in counted:
seq.append(counted[i])
else:
seq.append(0)
return seq
def aux(composition):
durations = composition.music_data.durations
counted = utils.special_counter(durations, True)
seq = []
for i in range(-48, 49):
if i in counted:
seq.append(counted[i])
else:
seq.append(0)
return seq
def repetition_scatter(contour_list):
repetition = repetition_index(contour_list)
counted = utils.special_counter(repetition, True)
seq = sorted(map(list, counted.items()))
seq.insert(0, ['Proportion', 'Amount'])
return seq
def frequency_pie(intervals):
r = utils.aux_pie_chart(utils.special_counter(intervals))
r.insert(0, ['Interval', 'Amount'])
return r
def frequency_scatter(intervals):
counted = utils.special_counter(intervals, True)
seq = sorted(map(list, counted.items()))
seq.insert(0, ['Interval', 'Amount'])
return seq
def frequency_scatter(durations):
counted = utils.special_counter(durations, True)
seq = sorted(map(list, counted.items()))
seq.insert(0, ['Duration quarter', 'Amount'])
return seq
def frequency_pie(durations):
r = utils.aux_pie_chart(utils.special_counter(durations))
r.insert(0, ['Duration quarter', 'Amount'])
return r
