def getbandpass(M):
feature = '%s:%s' % ('bandpass', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
self.extracted_feature[feature] = normalize(downsample(profs.sum(0).sum(1),M).ravel())
return self.extracted_feature[feature]
def getsumprofs(M):
feature = '%s:%s' % ('phasebins', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
data = profs.sum(0).sum(0)
self.extracted_feature[feature] = normalize(downsample(data,M,align=self.align).ravel())
return self.extracted_feature[feature]
def getsumprofs(M):
feature = '%s:%s' % ('phasebins', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
data = profs.sum(0).sum(0)
self.extracted_feature[feature] = normalize(
downsample(data, M, align=self.align).ravel())
return self.extracted_feature[feature]
def getDMcurve(
M): # return the normalized DM curve downsampled to M points
feature = '%s:%s' % ('DMbins', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
ddm = (self.dms.max() - self.dms.min()) / 2.
loDM, hiDM = (self.bestdm - ddm, self.bestdm + ddm)
loDM = max((0, loDM)) #make sure cut off at 0 DM
hiDM = max((ddm, hiDM)) #make sure cut off at 0 DM
N = 100
interp = False
sumprofs = self.profs.sum(0)
if not interp:
profs = sumprofs
else:
profs = np.zeros(np.shape(sumprofs), dtype='d')
DMs = psr_utils.span(loDM, hiDM, N)
chis = np.zeros(N, dtype='f')
subdelays_bins = self.subdelays_bins.copy()
for ii, DM in enumerate(DMs):
subdelays = psr_utils.delay_from_DM(DM, self.barysubfreqs)
hifreqdelay = subdelays[-1]
subdelays = subdelays - hifreqdelay
delaybins = subdelays * self.binspersec - subdelays_bins
if interp:
interp_factor = 16
for jj in range(self.nsub):
profs[jj] = psr_utils.interp_rotate(
sumprofs[jj],
delaybins[jj],
zoomfact=interp_factor)
# Note: Since the interpolation process slightly changes the values of the
# profs, we need to re-calculate the average profile value
avgprof = (profs / self.proflen).sum()
else:
new_subdelays_bins = np.floor(delaybins + 0.5)
for jj in range(self.nsub):
#profs[jj] = psr_utils.rotate(profs[jj], new_subdelays_bins[jj])
delay_bins = int(new_subdelays_bins[jj] %
len(profs[jj]))
if not delay_bins == 0:
profs[jj] = np.concatenate(
(profs[jj][delay_bins:],
profs[jj][:delay_bins]))
subdelays_bins += new_subdelays_bins
avgprof = self.avgprof
sumprof = profs.sum(0)
chis[ii] = self.calc_redchi2(prof=sumprof, avg=avgprof)
DMcurve = normalize(downsample(chis, M))
self.extracted_feature[feature] = DMcurve
return self.extracted_feature[feature]
def getsubbands(M):
feature = '%s:%s' % ('subbands', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
img = greyscale(self.profs.sum(0))
#U,S,V = svd(img)
#if M <= len(S):
#return S[:M]
#else:
#while len(S) < M:
#np.append(S, 0.)
#return S
self.extracted_feature[feature] = normalize(downsample(img, M).ravel())
return self.extracted_feature[feature]
def getDMcurve(M): # return the normalized DM curve downsampled to M points
feature = '%s:%s' % ('DMbins', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
ddm = (self.dms.max() - self.dms.min())/2.
loDM, hiDM = (self.bestdm - ddm , self.bestdm + ddm)
loDM = max((0, loDM)) #make sure cut off at 0 DM
hiDM = max((ddm, hiDM)) #make sure cut off at 0 DM
N = 100
interp = False
sumprofs = self.profs.sum(0)
if not interp:
profs = sumprofs
else:
profs = np.zeros(np.shape(sumprofs), dtype='d')
DMs = psr_utils.span(loDM, hiDM, N)
chis = np.zeros(N, dtype='f')
subdelays_bins = self.subdelays_bins.copy()
for ii, DM in enumerate(DMs):
subdelays = psr_utils.delay_from_DM(DM, self.barysubfreqs)
hifreqdelay = subdelays[-1]
subdelays = subdelays - hifreqdelay
delaybins = subdelays*self.binspersec - subdelays_bins
if interp:
interp_factor = 16
for jj in range(self.nsub):
profs[jj] = psr_utils.interp_rotate(sumprofs[jj], delaybins[jj],
zoomfact=interp_factor)
# Note: Since the interpolation process slightly changes the values of the
# profs, we need to re-calculate the average profile value
avgprof = (profs/self.proflen).sum()
else:
new_subdelays_bins = np.floor(delaybins+0.5)
for jj in range(self.nsub):
#profs[jj] = psr_utils.rotate(profs[jj], new_subdelays_bins[jj])
delay_bins = int(new_subdelays_bins[jj] % len(profs[jj]))
if not delay_bins==0:
profs[jj] = np.concatenate((profs[jj][delay_bins:], profs[jj][:delay_bins]))
subdelays_bins += new_subdelays_bins
avgprof = self.avgprof
sumprof = profs.sum(0)
chis[ii] = self.calc_redchi2(prof=sumprof, avg=avgprof)
DMcurve = normalize(downsample(chis, M))
self.extracted_feature[feature] = DMcurve
return self.extracted_feature[feature]
def getsubbands(M):
feature = '%s:%s' % ('subbands', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
img = greyscale(self.profs.sum(0))
#U,S,V = svd(img)
#if M <= len(S):
#return S[:M]
#else:
#while len(S) < M:
#np.append(S, 0.)
#return S
#self.extracted_feature[feature] = normalize(downsample(img, M, align=self.align).ravel())
self.extracted_feature[feature] = normalize(
downsample(img, M, align=self.align)).ravel()
return self.extracted_feature[feature]
def getintervals(M):
feature = '%s:%s' % ('intervals', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
img = greyscale(self.profs.sum(1))
#U,S,V = svd(img)
#imshow(img)
#m,n = img.shape
#S = resize(S,[m,1]) * eye(m,n)
#k = 6
#imshow(np.dot(U[:,1:k], dot(S[1:k,1:k],V[1:k,:])))
#show()
#if M <= len(S):
#return S[:M]
#else:
#while len(S) < M:
#np.append(S, 0.)
#return S
self.extracted_feature[feature] = normalize(downsample(img, M).ravel())
return self.extracted_feature[feature]
def getintervals(M):
feature = '%s:%s' % ('intervals', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
img = greyscale(self.profs.sum(1))
#U,S,V = svd(img)
#imshow(img)
#m,n = img.shape
#S = resize(S,[m,1]) * eye(m,n)
#k = 6
#imshow(np.dot(U[:,1:k], dot(S[1:k,1:k],V[1:k,:])))
#show()
#if M <= len(S):
#return S[:M]
#else:
#while len(S) < M:
#np.append(S, 0.)
#return S
#self.extracted_feature[feature] = normalize(downsample(img, M, align=self.align).ravel())#wrong!
self.extracted_feature[feature] = normalize(
downsample(img, M, align=self.align)).ravel()
return self.extracted_feature[feature]
def getintervals(M):
feature = '%s:%s' % ('intervals', M)
if M == 0:
return np.array([])
if not feature in self.extracted_feature:
img = greyscale(self.profs.sum(1))
#U,S,V = svd(img)
#imshow(img)
#m,n = img.shape
#S = resize(S,[m,1]) * eye(m,n)
#k = 6
#imshow(np.dot(U[:,1:k], dot(S[1:k,1:k],V[1:k,:])))
#show()
#if M <= len(S):
#return S[:M]
#else:
#while len(S) < M:
#np.append(S, 0.)
#return S
#self.extracted_feature[feature] = normalize(downsample(img, M, align=self.align).ravel())#wrong!
self.extracted_feature[feature] = normalize(
downsample(img, M, align=self.align)).ravel()
#self.extracted_feature[feature] = img.ravel()
fig = plt.figure()
#fig.set_size_inches(5,5)
#ax = plt.Axes(fig, [0., 0., 1., 1.])
ax = plt.gca()
ax.set_axis_off()
#fig.add_axes(ax)
plt.imsave("%s_intervals.png" % os.path.join(output_dir, fn),
img,
origin='lower',
cmap=plt.cm.gray_r)
#plt.imshow(img, origin='lower', aspect='auto', interpolation='bilinear', cmap=plt.cm.gray_r) #plt.cm.Greys) #interpolation='bilinear'
#plt.savefig("%s_intervals.png" % os.path.join(output_dir, fn))
return self.extracted_feature[feature]
def rhythm_to_music(bpm, rhythm):
chords = random.sample(diatonic_consonant_triads, 4)
random.shuffle(chords)
last_tick = 0 if len(rhythm) == 0 else rhythm[-1]
measure_count = 1 + int(last_tick / 192)
# TODO : REMOVE
# measure_count = 16
minutes_per_beat = 1 / bpm
seconds_per_beat = 60 * minutes_per_beat
seconds_per_measure = 4 * seconds_per_beat
duration_seconds = measure_count * seconds_per_measure
sample_count = int(duration_seconds * 44100)
kick_channel = [0.0] * sample_count
everything_else_channel = [0.0] * sample_count
bass = WaveInstrument(wave_saw)
sub_bass = WaveInstrument(wave_sin)
arp = WaveInstrument(wave_square)
kick_samples = kick(wave=wave_triangle)
snare_samples = noise(0.2, 0.2, 0.3)
hat_samples = noise(0.6, 0.05, 0.3)
rhythm_measures = [[] for i in range(measure_count)]
for tick in rhythm:
measure_index = tick // 192
if measure_index < measure_count:
rhythm_measures[tick // 192].append(tick)
# TODO : compute this?
stream_notes_per_measure = 24
stream_offsets = list(range(0, 192, 192 // stream_notes_per_measure))
stream_measures = set()
for measure_index in range(measure_count):
hit_offsets = [t % 192 for t in rhythm_measures[measure_index]]
is_stream = hit_offsets == stream_offsets
if is_stream:
stream_measures.add(measure_index)
for measure_index in range(measure_count):
bass_pitch = chords[measure_index % len(chords)][0]
if bass_pitch <= C: bass_pitch += 12
freq = pitch_to_frequency(bass_pitch)
for beat_index in range(4):
bass_start_beat = 4 * measure_index + beat_index + 0.5
bass_start_time = seconds_per_beat * bass_start_beat
bass_duration = 0.5 * seconds_per_beat
bass.add_note(everything_else_channel,
(2 * freq, bass_start_time, bass_duration, 0.15))
sub_bass.add_note(everything_else_channel,
(freq, bass_start_time, bass_duration, 0.2))
kick_start_beat = 4 * measure_index + beat_index
kick_start_time = seconds_per_beat * kick_start_beat
add_samples(kick_channel, kick_start_time, kick_samples)
if beat_index % 2 == 1:
add_samples(everything_else_channel, kick_start_time,
snare_samples)
is_streamy = len(
rhythm_measures[measure_index]) >= stream_notes_per_measure
arp_notes_per_beat = 8 if is_streamy else 2
arp_duration = 1 / arp_notes_per_beat * seconds_per_beat
if not is_streamy: arp_duration /= 2
for step_index in range(arp_notes_per_beat):
arp_start_beat = 4 * measure_index + beat_index + step_index / arp_notes_per_beat
arp_start_time = seconds_per_beat * arp_start_beat
chord = chords[measure_index % len(chords)]
arp_pitch = chord[(beat_index * arp_notes_per_beat +
step_index) % len(chord)] + 36
arp_freq = pitch_to_frequency(arp_pitch)
v = 0.08
arp.add_note(everything_else_channel,
(arp_freq, arp_start_time, arp_duration, v))
hats_per_beat = 4 if is_streamy else 2
for step_index in range(hats_per_beat):
hat_start_beat = 4 * measure_index + beat_index + step_index / hats_per_beat
hat_start_time = seconds_per_beat * hat_start_beat
hat_volume = 1 if step_index == 2 else 0.5
add_samples(everything_else_channel, hat_start_time,
hat_samples, hat_volume)
# melody I guess
max_note_ticks = 192 // 4
prev_pitch = None
for measure_index in range(measure_count):
rhythm_measure = rhythm_measures[measure_index]
if measure_index in stream_measures:
rhythm_measure = list(
range(192 * measure_index, 192 * (measure_index + 1),
192 // 4))
for rhythm_index, tick in enumerate(rhythm_measure):
if rhythm_index + 1 == len(rhythm_measure):
tick_duration = 192 - (tick % 192)
else:
end_tick = rhythm_measure[rhythm_index + 1]
tick_duration = min(max_note_ticks, end_tick - tick)
start_time = seconds_per_measure * tick / 192
duration = seconds_per_measure * tick_duration / 192
measure_index = tick // 192
chord = chords[measure_index % len(chords)]
while True:
pitch = chord[random.randint(0, len(chord) - 1)]
if pitch != prev_pitch:
break
freq = pitch_to_frequency(pitch + 48)
arp.add_note(everything_else_channel,
(freq, start_time, duration, 0.08))
prev_pitch = pitch
print('reverb...')
everything_else_channel = reverb(everything_else_channel)
print('mix...')
samples = [sum(s) for s in zip(kick_channel, everything_else_channel)]
print('normalize...')
normalize(samples)
return samples
