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