def main():
sys.stdout.write("Working...")
sys.stdout.flush()
# Open infile
infbfile = filterbank.filterbank(options.infile)
# Open outfile
outfbfile = open(options.outname, 'wb')
# Write header
header = infbfile.header
header_params = infbfile.header_params
write_header(outfbfile, header_params, header)
sys.stdout.write("\rHeader written... Writing data...")
sys.stdout.flush()
# Write file
write_data(infbfile, outfbfile)
sys.stdout.write("\rDone!" + " "*50 + "\n")
sys.stdout.flush()
# Close files
outfbfile.close()
infbfile.close()
def main():
warnings.warn(colour.cstring("Not checking if .fil files are contiguous " \
"frequency bands, or the same length, etc.", \
'warning'))
sys.stdout.write("Working...")
sys.stdout.flush()
# Open infiles
infbfiles = [filterbank.filterbank(infile) for infile in options.infiles]
outfile = open(options.outname, 'wb')
# Write header
write_header(infbfiles, outfile)
sys.stdout.write("\rHeader written... Writing data...")
sys.stdout.flush()
# Write data
write_data(infbfiles, outfile)
sys.stdout.write("\rDone!" + " "*50 + "\n")
sys.stdout.flush()
outfile.close()
# Close infiles
for fb in infbfiles:
fb.close()
def main():
# Open infile
infbfile = filterbank.filterbank(options.infile)
# Write .inf file (open/write/close)
writeInfoFile(infbfile)
# Open outfiles
if infbfile.header['foff'] > 0:
filenames = ["%s.sub%04d" % (options.outname, subnum) for subnum in range(0,infbfile.header['nchans'])]
elif infbfile.header['foff'] < 0:
# Invert subband files with respect to filterbank file.
filenames = ["%s.sub%04d" % (options.outname, subnum) for subnum in range(infbfile.header['nchans']-1,0-1,-1)]
else:
sys.stderr.write("Channel bandwidth is 0! Exiting...\n")
sys.exit(1)
outfiles = [open(fn, 'wb') for fn in filenames]
sys.stdout.write("Working...")
# Loop
for i in range(1, infbfile.number_of_samples/SAMPLES_PER_READ):
# Read samples
data = infbfile.read_Nsamples(SAMPLES_PER_READ)
# Re-organize data
data.shape = (SAMPLES_PER_READ, infbfile.header['nchans'])
data = data.transpose()
# Loop
for j in range(0, infbfile.header['nchans']):
# Write to outfiles
data[j].tofile(outfiles[j])
# Write leftover samples to outfiles
num_samples_leftover = infbfile.number_of_samples % SAMPLES_PER_READ
data = infbfile.read_Nsamples(num_samples_leftover)
# Re-organize data
data.shape = (num_samples_leftover, infbfile.header['nchans'])
data = data.transpose()
# Loop
for j in range(0, infbfile.header['nchans']):
# Write to outfiles
data[j].tofile(outfiles[j])
# Close infile
infbfile.close()
# Close outfiles
for outfile in outfiles:
outfile.close()
sys.stdout.write('\rDone! \n')
sys.stdout.flush()
def __init__(self, filfns):
fbs = [filterbank.filterbank(fn) for fn in filfns]
startmjds = np.array([fb.header['tstart'] for fb in fbs])
sortinds = startmjds.argsort()
self.fbs = [fbs[ii] for ii in sortinds]
self.filenames = [fb.filename for fb in fbs]
self.numfiles = len(self.fbs)
self.startmjds = startmjds[sortinds]
self.nsamps = np.array([fb.number_of_samples for fb in self.fbs])
self.tsamp = fbs[0].header['tsamp'] # Assume sample time is uniform over observation
self.lengths = self.nsamps*self.tsamp # length of each file in seconds
self.endsamps = np.cumsum(self.nsamps)
self.endtimes = self.endsamps*self.tsamp
self.startsamps = np.concatenate(([0],self.endsamps[:-1]))
self.starttimes = self.startsamps*self.tsamp
self.obslen = self.endtimes[-1]
self.number_of_samples = self.endsamps[-1]
self.fbs[0].compute_frequencies()
self.frequencies = self.fbs[0].frequencies
self.nchans = self.fbs[0].header['nchans']
help="If --smooth option is used,smoothing to the bandpass before bandpass correction is applied (otherwise no smoothing).", default=0)
(options, args) = parser.parse_args()
print(args)
if len(args) == 0:
parser.print_help()
sys.exit(1)
elif len(args) != 1:
sys.stderr.write("Only one input file must be provided!\n")
else:
options.infile = args[-1]
dm = options.dm
filename = options.infile
if filename.endswith(".fil"):
fil = filterbank.filterbank(filename)
total_N = fil.number_of_samples
tot_freq = fil.header['nchans']
picklename = re.search('(.*).fil', filename).group(1)
t_samp = fil.header['tsamp']
tstart = fil.header['tstart']
freqs = np.flip(fil.frequencies)
if filename.endswith(".fits"):
fits = psrfits.PsrfitsFile(filename)
total_N = fits.specinfo.N
t_samp = fits.specinfo.dt
freqs = np.flip(fits.frequencies)
if options.AO == True:
total_N = int(0.2 / t_samp)
picklename = re.search('(.*).fits', filename).group(1)
def waterfall(filename,
start,
duration,
dm=0,
mask=False,
maskfn=None,
favg=1,
tavg=1,
scaleindep=False,
extra_begin_chan=None,
extra_end_chan=None):
"""
"""
if filename.endswith('.fil'):
rawdatafile = filterbank.filterbank(filename)
tsamp = rawdatafile.header['tsamp']
nchans = rawdatafile.header['nchans']
freqs = rawdatafile.frequencies
total_N = rawdatafile.number_of_samples
df = np.abs(freqs[-1] - freqs[0])
fres = df / int(nchans + 1)
scan_start = rawdatafile.tstart
if filename.endswith('.fits'):
rawdatafile = psrfits.PsrfitsFile(filename)
tsamp = rawdatafile.tsamp
nchans = rawdatafile.nchan
freqs = rawdatafile.frequencies
total_N = rawdatafile.specinfo.N
df = np.abs(freqs[-1] - freqs[0])
fres = df / int(nchans + 1)
scan_start = rawdatafile.header['STT_IMJD'] + (
rawdatafile.header['STT_SMJD'] +
rawdatafile.header['STT_OFFS']) / (24. * 3600.)
start_bin = np.round(start / tsamp).astype(
'int') #convert begin time to bins
dmdelay_coeff = 4.15e3 * np.abs(1. / freqs[0]**2 - 1. / freqs[-1]**2)
nbins = np.round(duration / tsamp).astype('int') #convert duration to bins
if dm != 0:
nbinsextra = np.round(
(duration + dmdelay_coeff * dm) / tsamp).astype('int')
else:
nbinsextra = nbins
# If at end of observation
if (start_bin + nbinsextra) > total_N - 1:
nbinsextra = total_N - 1 - start_bin
data = rawdatafile.get_spectra(start_bin, nbinsextra)
#masking
if mask and maskfn:
data, masked_chans = maskfile(maskfn,
data,
start_bin,
nbinsextra,
extra_begin_chan=extra_begin_chan,
extra_end_chan=extra_end_chan)
else:
masked_chans = np.zeros(nchans, dtype=bool)
data_masked = np.ma.masked_array(data.data)
data_masked[masked_chans] = np.ma.masked
data.data = data_masked
if dm != 0:
data.dedisperse(dm, padval='mean')
data.downsample(tavg)
# scale data
data_noscale = data
data = data.scaled(scaleindep)
return data, data_noscale, nbinsextra, nbins, start, tsamp, fres, scan_start
def analyse(s, Fs, D, L, rank, n=128, l=129, rmax=None):
"""
Estimation of the complex poles and the associated complex amplitudes for the Exponential Sinusoidal Model (ESM)
using an adaptive ESPRIT algorithm.
See Roland Badeau PhD thesis for more information about the algorithms.
Parameters
----------
s : numpy array (n,)
input data
Fs : int
sampling frequency
D : int
number of positive frequency subbands
L : int, MUST BE ODD (!!!)
length of the analysis filters
rank : numpy array of integer (kk x 1, with kk <= D)
rank of the model in each subband. If rank[k] == 0, then the rank of the model in the subband k
is estimated automatically
n : int
dimension of the data vectors (used for the Hankel matrix constructed on N = n+l-1 samples of s)
l : int
number of data vectors for each analysis window ( which size is N = n+l-1)
rmax : int
maximum rank of the ESM. Only used if rank[k] == 0. Then the "ESTER criterion" is used to select the rank
(i.e. number of poles)
Returns
-------
The_z : numpy array of complex numbers (? x ?)
estimated poles of the sin model in all the subbands
The_alpha : numpy array of complex numbers (same size as The_z)
estimated amplitude of the model
Copyright (C) 2004-2008 Roland Badeau
Send bugs and requests to [email protected]
Translation from Matlab to python : ELB - [email protected] - 08/2018
"""
M = 2 * D # total number of subbands (D postive frequency subbands and D negative frequency subbands)
h = filterbank.filterbank(L, D) # computation of the analysis filters
The_alpha = np.zeros([], dtype=np.complex128)
The_z = np.zeros([], dtype=np.complex128)
The_Freq = np.zeros([], dtype=np.complex128)
s2 = lfilter([1, -0.98], 1, s, axis=0) # pre-emphasis, "!!! axis = 0 !!!
for k in range(len(rank)):
y0 = lfilter(h[:, k], 1, s2, axis=0) # filter bank
y1 = y0[::D]
z, alpha = estim(y1, rank[k], n, l, rmax)
Freq = np.mod(np.angle(z) / (2 * np.pi),
1) # computationn of the frequencies in the subbands
# INITIALIZATIONS
Freq2 = np.zeros_like(Freq) # frequencies in the full bandwidth
z2 = np.zeros_like(z) # complex poles in the full bandwidth
alpha2 = np.zeros_like(
alpha) # complex amplitudes in the full bandwidth
# RE-MAP THE FREQUENCIES IN THE FULL BANDWIDTH
for t in range(Freq.shape[1]): # for each analysis time points
if np.mod(k + 1, 2) == 1: # for odd subbands
I = Freq[:,
t] < .5 # keep only the frequencies between 0 and 0.5
# (the others are aliased)
Freq2[:sum(I), t] = (k + 2 * Freq[I, t]) / M # re-map
else: # case of even subbands
I = Freq[:,
t] >= .5 # keep only the frequencies between 0.5 et 1
# (the others are aliased)
Freq2[:np.sum(I),
t] = (k + 2 * (Freq[I, t] - .5)) / M # re-map
# re-map the poles in the full bandwidth
z2[:np.sum(I), t] = np.exp(
np.log(np.abs(z[I, t])) / D +
1j * 2 * np.pi * Freq2[:np.sum(I), t])
# CORRECTION OF THE COMPLEX AMPLITUDES
V = np.exp(-np.outer(np.log(z2[:np.sum(I), t]),
np.arange(h.shape[0]))) # Vandermonde matrix
# built on the poles
alpha2[:np.sum(I),
t] = alpha[I, t] / (V.dot(h[:, k]) * V[:, :2].dot(
np.array([1, -0.98]))) # compensation
# for the pre-emphasis step
# CONCATENATION OF THE PARAMETERS FROM THE SUBBANDS
if k == 0:
The_alpha = alpha2
The_z = z2
The_Freq = Freq2
else:
The_alpha = np.concatenate((The_alpha, alpha2), axis=0)
The_z = np.concatenate((The_z, z2), axis=0)
The_Freq = np.concatenate((The_Freq, Freq2), axis=0)
return The_z, The_alpha
for value in np.arange(int(np.ceil(blocks_without_overlap/2))):
if np.sum(Y_predict[zz:zz+4]) >= 3:
lead = np.append(lead, ones_vec)
else:
lead = np.append(lead, zeros_vec)
zz += 4
lead = np.array(lead)
# get lead-vector that has same length as signal, because we are calculating
# a little bit more than that
lead = lead[0:signal_length]
# divide signal into three filter-bands
lower_border_freq = 250
upper_border_freq = 4000
filt = filterbank.filterbank(fs, lower_border_freq, upper_border_freq)
low_sig, mid_sig, high_sig = filt.filter(signal)
# compress signal in filter-bands depending on where speech was detected
comp = compressor.compressor(fs=fs, ratio=2, mu_auto=True)
gain = 1/4 # -12 dB
compressed_low = comp.compress_mono(low_sig, lead)
compressed_mid = comp.compress_mono(mid_sig, lead)
compressed_high = comp.compress_mono(high_sig, lead)
signal_out = gain * compressed_low + compressed_mid + gain * compressed_high
# write signal into file so that you can (hopefully) hear a difference
sf.write('test_signal_compressed.wav', data=signal_out, samplerate=fs)
# plotting classifier output (lead) and the original audio signal
time_vec = np.linspace(0, signal_length/fs, signal_length )
