예제 #1
0
def driving_signals_3d(delay, weight, sos, phaseshift, signal):
    """Get 3-dimensional NFC-HOA driving signals.

    Parameters
    ----------
    delay : float
        Overall delay in seconds.
    weight : float
        Overall weight.
    sos : list of array_like
        Second-order section filters :func:`scipy.signal.sosfilt`.
    phaseshift : (N,) array_like
        Phase shift in radians.
    signal : (L,) array_like + float
        Excitation signal consisting of (mono) audio data and a sampling
        rate (in Hertz).  A `DelayedSignal` object can also be used.

    Returns
    -------
    `DelayedSignal`
        A tuple containing the delayed signals (in a `numpy.ndarray`
        with shape ``(L, N)``), followed by the sampling rate (in Hertz)
        and a (possibly negative) time offset (in seconds).

    """
    data, fs, t_offset = _util.as_delayed_signal(signal)
    N = len(phaseshift)
    out = _np.tile(_np.expand_dims(_sig.sosfilt(sos[0], data), 1), (1, N))
    for m in range(1, len(sos)):
        modal_response = _sig.sosfilt(sos[m], data)[:, _np.newaxis]
        out += (2 * m + 1) * modal_response * _legendre(m, _np.cos(phaseshift))
    return _util.DelayedSignal(weight / 4 / _np.pi * out, fs, t_offset + delay)
예제 #2
0
파일: filter.py 프로젝트: Keita1/obspy
def highpass(data, freq, df, corners=4, zerophase=False):
    """
    Butterworth-Highpass Filter.

    Filter data removing data below certain frequency ``freq`` using
    ``corners`` corners.
    The filter uses :func:`scipy.signal.iirfilter` (for design)
    and :func:`scipy.signal.sosfilt` (for applying the filter).

    :type data: numpy.ndarray
    :param data: Data to filter.
    :param freq: Filter corner frequency.
    :param df: Sampling rate in Hz.
    :param corners: Filter corners / order.
    :param zerophase: If True, apply filter once forwards and once backwards.
        This results in twice the number of corners but zero phase shift in
        the resulting filtered trace.
    :return: Filtered data.
    """
    fe = 0.5 * df
    f = freq / fe
    # raise for some bad scenarios
    if f > 1:
        msg = "Selected corner frequency is above Nyquist."
        raise ValueError(msg)
    z, p, k = iirfilter(corners, f, btype='highpass', ftype='butter',
                        output='zpk')
    sos = zpk2sos(z, p, k)
    if zerophase:
        firstpass = sosfilt(sos, data)
        return sosfilt(sos, firstpass[::-1])[::-1]
    else:
        return sosfilt(sos, data)
예제 #3
0
파일: wavefield.py 프로젝트: lermert/noisi
 def filter_all(self,type,overwrite=False,zerophase=True,outfile=None,**kwargs):
     
     if type == 'bandpass':
         sos = filter.bandpass(df=self.stats['Fs'],**kwargs)
     elif type == 'lowpass':
         sos = filter.lowpass(df=self.stats['Fs'],**kwargs)
     elif type == 'highpass':
         sos = filter.highpass(df=self.stats['Fs'],**kwargs)
     else:
         msg = 'Filter %s is not implemented, implemented filters: bandpass, highpass,lowpass' %type
         raise ValueError(msg)
     
     if not overwrite:
         # Create a new hdf5 file of the same shape
         newfile = self.copy_setup(newfile=outfile)
     else:
         # Call self.file newfile
         newfile = self#.file
     
     with click.progressbar(range(self.stats['ntraces']),label='Filtering..' ) as ind:
         for i in ind:
             # Filter each trace
             if zerophase:
                 firstpass = sosfilt(sos, self.data[i,:]) # Read in any case from self.data
                 newfile.data[i,:] = sosfilt(sos,firstpass[::-1])[::-1] # then assign to newfile, which might be self.file
             else:
                 newfile.data[i,:] = sosfilt(sos,self.data[i,:])
             # flush?
             
     if not overwrite:
        print('Processed traces written to file %s, file closed, \
               reopen to read / modify.' %newfile.file.filename)
        
        newfile.file.close()
예제 #4
0
파일: bcv.py 프로젝트: sudughonge/bcv
def highpass(rawData, samplFreq, highpassCutOff):
  #This function high passes the data with sampling frequency samplFreq with a highpass
  # cut off of highpassCutOff
  #
  # Usage: [highPassedData] = highpass(rawData, samplFreq, highpassCutOff)
  # 
  # rawData : raw time series Data
  # samplFreq: sampling Frequency of Data
  # highpassCutOff: The high pass frequency cut off.
  #
  numberOfChannels = len(rawData)
  dataLength = len(rawData[0])
  duration = dataLength/samplFreq
  
  
  halfDataLength = dataLength/2 + 1
  
  for channelNumber in xrange(numberOfChannels):
    if(len(rawData[channelNumber]) != dataLength):
      sys.exit('Data length not consistent\n')
  
  nyquistFrequency = samplFreq/2.0
  
  lpefOrder  = 0
  
  if(highpassCutOff>0):
    hpfOrder = 12
    hpfZeros, hpfPoles, hpfGain = sig.butter(hpfOrder, highpassCutOff/nyquistFrequency, btype = 'highpass', output = 'zpk' )
    hpfSOS = sig.zpk2sos(hpfZeros, hpfPoles, hpfGain)
    
    #magnitude response of high pass filter
    minimumFrequencyStep = 1.0/duration
    frequencies = np.arange(0, nyquistFrequency, minimumFrequencyStep)
    hpfArgument = np.power((frequencies / highpassCutOff), 2*hpfOrder)
    hpfResponse = hpfArgument/(1 + hpfArgument)
    
    highPassCutOffIndex = np.ceil(highpassCutOff/minimumFrequencyStep)
  
  highPassedData = []
  for channelNumber in xrange(numberOfChannels):
    if(highpassCutOff>0):
      x = sig.sosfilt(hpfSOS, rawData[channelNumber])
      x = np.flipud(x)
      x = sig.sosfilt(hpfSOS, x)
      x = np.flipud(x)
    else:
      x = rawData[channelNumber]
    
    x[0:lpefOrder] = np.zeros(lpefOrder)
    x[dataLength - lpefOrder:dataLength-1] = np.zeros(lpefOrder)
    
    highPassedData.append(x)
  
  highPassedData = np.asarray(highPassedData)
  
  return highPassedData
예제 #5
0
def _sosfiltfilt(sos, x, axis=-1, padtype='odd', padlen=None, method='pad', irlen=None):
    """Filtfilt version using Second Order sections. Code is taken from scipy.signal.filtfilt and adapted to make it work with SOS.
    Note that broadcasting does not work.
    """
    from scipy.signal import sosfilt_zi
    from scipy.signal._arraytools import odd_ext, axis_slice, axis_reverse
    x = np.asarray(x)
    
    if padlen is None:
        edge = 0
    else:
        edge = padlen

    # x's 'axis' dimension must be bigger than edge.
    if x.shape[axis] <= edge:
        raise ValueError("The length of the input vector x must be at least "
                         "padlen, which is %d." % edge)

    if padtype is not None and edge > 0:
        # Make an extension of length `edge` at each
        # end of the input array.
        if padtype == 'even':
            ext = even_ext(x, edge, axis=axis)
        elif padtype == 'odd':
            ext = odd_ext(x, edge, axis=axis)
        else:
            ext = const_ext(x, edge, axis=axis)
    else:
        ext = x

    # Get the steady state of the filter's step response.
    zi = sosfilt_zi(sos)

    # Reshape zi and create x0 so that zi*x0 broadcasts
    # to the correct value for the 'zi' keyword argument
    # to lfilter.
    #zi_shape = [1] * x.ndim
    #zi_shape[axis] = zi.size
    #zi = np.reshape(zi, zi_shape)
    x0 = axis_slice(ext, stop=1, axis=axis)
    # Forward filter.
    (y, zf) = sosfilt(sos, ext, axis=axis, zi=zi * x0)

    # Backward filter.
    # Create y0 so zi*y0 broadcasts appropriately.
    y0 = axis_slice(y, start=-1, axis=axis)
    (y, zf) = sosfilt(sos, axis_reverse(y, axis=axis), axis=axis, zi=zi * y0)

    # Reverse y.
    y = axis_reverse(y, axis=axis)

    if edge > 0:
        # Slice the actual signal from the extended signal.
        y = axis_slice(y, start=edge, stop=-edge, axis=axis)

    return y
예제 #6
0
파일: filter.py 프로젝트: Keita1/obspy
def lowpass_cheby_2(data, freq, df, maxorder=12, ba=False,
                    freq_passband=False):
    """
    Cheby2-Lowpass Filter

    Filter data by passing data only below a certain frequency.
    The main purpose of this cheby2 filter is downsampling.
    #318 shows some plots of this filter design itself.

    This method will iteratively design a filter, whose pass
    band frequency is determined dynamically, such that the
    values above the stop band frequency are lower than -96dB.

    :type data: numpy.ndarray
    :param data: Data to filter.
    :param freq: The frequency above which signals are attenuated
        with 95 dB
    :param df: Sampling rate in Hz.
    :param maxorder: Maximal order of the designed cheby2 filter
    :param ba: If True return only the filter coefficients (b, a) instead
        of filtering
    :param freq_passband: If True return additionally to the filtered data,
        the iteratively determined pass band frequency
    :return: Filtered data.
    """
    nyquist = df * 0.5
    # rp - maximum ripple of passband, rs - attenuation of stopband
    rp, rs, order = 1, 96, 1e99
    ws = freq / nyquist  # stop band frequency
    wp = ws  # pass band frequency
    # raise for some bad scenarios
    if ws > 1:
        ws = 1.0
        msg = "Selected corner frequency is above Nyquist. " + \
              "Setting Nyquist as high corner."
        warnings.warn(msg)
    while True:
        if order <= maxorder:
            break
        wp = wp * 0.99
        order, wn = cheb2ord(wp, ws, rp, rs, analog=0)
    if ba:
        return cheby2(order, rs, wn, btype='low', analog=0, output='ba')
    z, p, k = cheby2(order, rs, wn, btype='low', analog=0, output='zpk')
    sos = zpk2sos(z, p, k)
    if freq_passband:
        return sosfilt(sos, data), wp * nyquist
    return sosfilt(sos, data)
예제 #7
0
파일: sacpy.py 프로젝트: eost/wphase
    def filter(self, freq, order=4, btype='lowpass'):
        '''
        Bandpass filter the data using a butterworth filter
        Args:
            * freq: A scalar or length-2 sequence giving the critical frequencies (in Hz)
            * order:  Order of the filter.
            * btype: {'lowpass', 'highpass', 'bandpass', 'bandstop'}, optional
              (default is 'lowpass')
        '''
        
        # Check that headers are correct
        assert not self.isempty(), 'Some sac attributes are missing (e.g., npts, delta, depvar)'

        # Filter design
        if type(freq) is list:
            freq = np.array(freq)
        Wn = freq * 2. * self.delta # Normalizing frequencies
        sos = signal.butter(order, Wn, btype, output='sos')
        
        # Filter waveform
        depvar = signal.sosfilt(sos, self.depvar)
        self.depvar = depvar.astype('float32')

        # All done
        return
예제 #8
0
 def dn(self,x,M_change = 12):
     """
     Downsample and filter the signal
     """
     y = signal.sosfilt(self.sos,x)
     y = ssd.downsample(y,M_change)
     return y
예제 #9
0
파일: wavefield.py 프로젝트: lermert/noisi
    def decimate(self,decimation_factor,outfile,taper_width=0.005):
        """
        Decimate the wavefield and save to a new file 
        """
        
        fs_old = self.stats['Fs']
        freq = self.stats['Fs'] * 0.4 / float(decimation_factor)

        # Get filter coeff
        sos = filter.cheby2_lowpass(fs_old,freq)

        # figure out new length
        temp_trace = integer_decimation(self.data[0,:], decimation_factor)
        n = len(temp_trace)
       

        # Get taper
        # The default taper is very narrow, because it is expected that the traces are very long.
        taper = cosine_taper(self.stats['nt'],p=taper_width)

       
        # Need a new file, because the length changes.
        with self.copy_setup(newfile=outfile,nt=n) as newfile:

            for i in range(self.stats['ntraces']):
                
                temp_trace = sosfilt(sos,taper*self.data[i,:])
                newfile.data[i,:] = integer_decimation(temp_trace, decimation_factor)
            
        
            newfile.stats['Fs'] = fs_old / float(decimation_factor)
예제 #10
0
 def up(self,x,L_change = 12):
     """
     Upsample and filter the signal
     """
     y = L_change*ssd.upsample(x,L_change)
     y = signal.sosfilt(self.sos,y)
     return y
def plot_filter(h, title, freq, gain, show=True):
    if h.ndim == 2:  # second-order sections
        sos = h
        n = mne.filter.estimate_ringing_samples(sos)
        h = np.zeros(n)
        h[0] = 1
        h = signal.sosfilt(sos, h)
        H = np.ones(512, np.complex128)
        for section in sos:
            f, this_H = signal.freqz(section[:3], section[3:])
            H *= this_H
    else:
        f, H = signal.freqz(h)
    fig, axs = plt.subplots(2)
    t = np.arange(len(h)) / sfreq
    axs[0].plot(t, h, color=blue)
    axs[0].set(xlim=t[[0, -1]], xlabel='Time (sec)',
               ylabel='Amplitude h(n)', title=title)
    box_off(axs[0])
    f *= sfreq / (2 * np.pi)
    axs[1].semilogx(f, 10 * np.log10((H * H.conj()).real), color=blue,
                    linewidth=2, zorder=4)
    plot_ideal(freq, gain, axs[1])
    mne.viz.tight_layout()
    if show:
        plt.show()
예제 #12
0
 def lfilter(self, signal):
     """
     Filter signal with filterbank.
     
     .. note:: This function uses :func:`scipy.signal.lfilter`.
     """
     return ( sosfilt(sos, signal) for sos in self.filters )
예제 #13
0
    def downsampling(self,cfg,zerophase_antialias):

        # Find a frequency dependent taper width
        Fs0 = self.stream[0].stats.sampling_rate
        npts =  self.stream[0].stats.npts
        taper_perc = 100. *  Fs0 / cfg.Fs_new[-1] / npts
        print(npts)
        print(taper_perc)

        # Apply antialias filter
        for trace in self.stream:

            trace.taper(type='cosine',max_percentage=taper_perc)

            if zerophase_antialias:
                firstpass = sosfilt(self.anti_alias,trace.data)
                trace.data = sosfilt(self.anti_alias,firstpass[::-1])[::-1]
            else:
                trace.data = sosfilt(self.anti_alias,trace.data)
        
        # Decimate if possible, otherwise interpolate
        for Fs in cfg.Fs_new:
            Fs_old = self.stream[0].stats.sampling_rate

            dec = ( Fs_old / Fs)
            if dec % 1.0 == 0:
                
                self.stream.decimate(int(dec), no_filter=True, 
                    strict_length=False)
                if cfg.verbose:
                    print('* decimated traces to %g Hz' %Fs,
                    file=self.ofid)
            else:
                try:
                    self.stream.interpolate(sampling_rate = Fs,
                    method='lanczos')
                    print('* interpolated traces to %g Hz' %Fs,
                    file=self.ofid)
                except:
                    self.stream.interpolate(sampling_rate = Fs)
                    print('* interpolated trace to %g Hz' %Fs,
                    file=self.ofid)
예제 #14
0
파일: filter.py 프로젝트: Brtle/obspy
def bandpass(data, freqmin, freqmax, df, corners=4, zerophase=False):
    """
    Butterworth-Bandpass Filter.

    Filter data from ``freqmin`` to ``freqmax`` using ``corners``
    corners.
    The filter uses :func:`scipy.signal.iirfilter` (for design)
    and :func:`scipy.signal.sosfilt` (for applying the filter).

    :type data: numpy.ndarray
    :param data: Data to filter.
    :param freqmin: Pass band low corner frequency.
    :param freqmax: Pass band high corner frequency.
    :param df: Sampling rate in Hz.
    :param corners: Filter corners / order.
    :param zerophase: If True, apply filter once forwards and once backwards.
        This results in twice the filter order but zero phase shift in
        the resulting filtered trace.
    :return: Filtered data.
    """
    fe = 0.5 * df
    low = freqmin / fe
    high = freqmax / fe
    # raise for some bad scenarios
    if high - 1.0 > -1e-6:
        msg = ("Selected high corner frequency ({}) of bandpass is at or "
               "above Nyquist ({}). Applying a high-pass instead.").format(
            freqmax, fe)
        warnings.warn(msg)
        return highpass(data, freq=freqmin, df=df, corners=corners,
                        zerophase=zerophase)
    if low > 1:
        msg = "Selected low corner frequency is above Nyquist."
        raise ValueError(msg)
    z, p, k = iirfilter(corners, [low, high], btype='band',
                        ftype='butter', output='zpk')
    sos = zpk2sos(z, p, k)
    if zerophase:
        firstpass = sosfilt(sos, data)
        return sosfilt(sos, firstpass[::-1])[::-1]
    else:
        return sosfilt(sos, data)
예제 #15
0
def band_pass_filter(data, minfreq = 0.5, maxfreq = 0.8, df = 4, corners = 4):

    fe = 0.5 * df
    low = minfreq / fe
    high = maxfreq / fe

    z, p, k = sig.iirfilter(corners, [low, high], btype='band',
                        ftype='butter', output='zpk')
    sos = sig.zpk2sos(z, p, k)


    return sig.sosfilt(sos, data)
def ITU_R_468_weight(signal, fs):
    """
    Return the given signal after passing through an 468-weighting filter

    signal : array_like
        Input signal
    fs : float
        Sampling frequency
    """

    sos = ITU_R_468_weighting(fs, output='sos')
    return sosfilt(sos, signal)
예제 #17
0
파일: filter.py 프로젝트: Keita1/obspy
def bandstop(data, freqmin, freqmax, df, corners=4, zerophase=False):
    """
    Butterworth-Bandstop Filter.

    Filter data removing data between frequencies ``freqmin`` and ``freqmax``
    using ``corners`` corners.
    The filter uses :func:`scipy.signal.iirfilter` (for design)
    and :func:`scipy.signal.sosfilt` (for applying the filter).

    :type data: numpy.ndarray
    :param data: Data to filter.
    :param freqmin: Stop band low corner frequency.
    :param freqmax: Stop band high corner frequency.
    :param df: Sampling rate in Hz.
    :param corners: Filter corners / order.
    :param zerophase: If True, apply filter once forwards and once backwards.
        This results in twice the number of corners but zero phase shift in
        the resulting filtered trace.
    :return: Filtered data.
    """
    fe = 0.5 * df
    low = freqmin / fe
    high = freqmax / fe
    # raise for some bad scenarios
    if high > 1:
        high = 1.0
        msg = "Selected high corner frequency is above Nyquist. " + \
              "Setting Nyquist as high corner."
        warnings.warn(msg)
    if low > 1:
        msg = "Selected low corner frequency is above Nyquist."
        raise ValueError(msg)
    z, p, k = iirfilter(corners, [low, high],
                        btype='bandstop', ftype='butter', output='zpk')
    sos = zpk2sos(z, p, k)
    if zerophase:
        firstpass = sosfilt(sos, data)
        return sosfilt(sos, firstpass[::-1])[::-1]
    else:
        return sosfilt(sos, data)
예제 #18
0
    def filter_fn(seg):
        assert seg.channels == 1

        nyq = 0.5 * seg.frame_rate
        try:
            freqs = [f / nyq for f in freq]
        except TypeError:
            freqs = freq / nyq

        sos = butter(order, freqs, btype=type, output='sos')
        y = sosfilt(sos, seg.get_array_of_samples())

        return seg._spawn(y.astype(seg.array_type))
예제 #19
0
    def calc_response(self, y_fx = None):
        """
        (Re-)calculate filter response `self.y` from either stimulus `self.x`
        (float mode) or copy fixpoint response. 
        Split response into imag. and real components `self.y_i` and `self.y_r`
        and set the flag `self.cmplx`.
        """
        if self.fx_sim: # use fixpoint simulation results instead of floating results
            if y_fx is not None:
                self.y = np.array(y_fx)
                qstyle_widget(self.ui.but_run, "normal")
            else:
                self.y = None
        else:
            # calculate response self.y_r[n] and self.y_i[n] (for complex case) =====   
            self.bb = np.asarray(fb.fil[0]['ba'][0])
            self.aa = np.asarray(fb.fil[0]['ba'][1])
            if min(len(self.aa), len(self.bb)) < 2:
                logger.error('No proper filter coefficients: len(a), len(b) < 2 !')
                return

            logger.info("Coefficient area = {0}".format(np.sum(np.abs(self.bb))))
    
            sos = np.asarray(fb.fil[0]['sos'])
            antiCausal = 'zpkA' in fb.fil[0]
            causal     = not (antiCausal)
    
            if len(sos) > 0 and causal: # has second order sections and is causal
                y = sig.sosfilt(sos, self.x)
            elif antiCausal:
                y = sig.filtfilt(self.bb, self.aa, self.x, -1, None)
            else: # no second order sections or antiCausals for current filter
                y = sig.lfilter(self.bb, self.aa, self.x)
    
            if self.ui.stim == "StepErr":
                dc = sig.freqz(self.bb, self.aa, [0]) # DC response of the system
                y = y - abs(dc[1]) # subtract DC (final) value from response
    
            self.y = np.real_if_close(y, tol = 1e3)  # tol specified in multiples of machine eps

        self.needs_redraw[0] = True
        self.needs_redraw[1] = True

        # Calculate imag. and real components from response
        self.cmplx = np.any(np.iscomplex(self.y))
        if self.cmplx:
            self.y_i = self.y.imag
            self.y_r = self.y.real
        else:
            self.y_r = self.y
            self.y_i = None
예제 #20
0
def _sosfiltfilt(sos, x, axis=-1, padtype='odd', padlen=None):
    """Do SciPy sosfiltfilt."""
    from scipy.signal import sosfilt, sosfilt_zi
    sos, n_sections = _validate_sos(sos)

    # `method` is "pad"...
    ntaps = 2 * n_sections + 1
    ntaps -= min((sos[:, 2] == 0).sum(), (sos[:, 5] == 0).sum())
    edge, ext = _validate_pad(padtype, padlen, x, axis,
                              ntaps=ntaps)

    # These steps follow the same form as filtfilt with modifications
    zi = sosfilt_zi(sos)  # shape (n_sections, 2) --> (n_sections, ..., 2, ...)
    zi_shape = [1] * x.ndim
    zi_shape[axis] = 2
    zi.shape = [n_sections] + zi_shape
    x_0 = axis_slice(ext, stop=1, axis=axis)
    (y, zf) = sosfilt(sos, ext, axis=axis, zi=zi * x_0)
    y_0 = axis_slice(y, start=-1, axis=axis)
    (y, zf) = sosfilt(sos, axis_reverse(y, axis=axis), axis=axis, zi=zi * y_0)
    y = axis_reverse(y, axis=axis)
    if edge > 0:
        y = axis_slice(y, start=edge, stop=-edge, axis=axis)
    return y
예제 #21
0
 def _make(self, subject, recording):
     raw = self.source.load(subject, recording, preload=True)
     self.log.info("Raw %s: filtering for %s/%s...", self.name, subject, recording)
     # filter data
     picks = mne.pick_types(raw.info, eeg=True, ref_meg=True)
     sos = self._sos(raw.info['sfreq'])
     for i in picks:
         raw._data[i] = signal.sosfilt(sos, raw._data[i])
     # update info
     low, high = self.args[1], self.args[2]
     if high and raw.info['lowpass'] > high:
         raw.info['lowpass'] = float(high)
     if low and raw.info['highpass'] < low:
         raw.info['highpass'] = float(low)
     return raw
예제 #22
0
def A_weight(signal, fs):
    """
    Return the given signal after passing through a digital A-weighting filter

    signal : array_like
        Input signal, with time as dimension
    fs : float
        Sampling frequency
    """
    # TODO: Upsample signal high enough that filter response meets Type 0
    # limits.  A passes if fs >= 260 kHz, but not at typical audio sample
    # rates. So upsample 48 kHz by 6 times to get an accurate measurement?
    # TODO: Also this could just be a measurement function that doesn't
    # save the whole filtered waveform.
    sos = A_weighting(fs, output='sos')
    return sosfilt(sos, signal)
예제 #23
0
def highpass(signal, cutoff, fs, order=4, zero_phase=False):
    """Filter signal with low-pass filter.
    
    :param signal: Signal
    :param fs: Sample frequency
    :param cutoff: Cut-off frequency
    :param order: Filter order
    :param zero_phase: Prevent phase error by filtering in both directions (filtfilt)
    
    A Butterworth filter is used. Filtering is done with second-order sections.
    
    .. seealso:: :func:`scipy.signal.butter`.
    
    """
    sos = butter(order, cutoff/(fs/2.0), btype='high', output='sos')
    if zero_phase:
        return _sosfiltfilt(sos, signal)
    else:
        return sosfilt(sos, signal)
예제 #24
0
def octavepass(signal, center, fs, fraction, order=8, zero_phase=True):
    """Filter signal with fractional-octave bandpass filter.
    
    :param signal: Signal
    :param center: Centerfrequency of fractional-octave band.
    :param fs: Sample frequency
    :param fraction: Fraction of fractional-octave band.
    :param order: Filter order
    :param zero_phase: Prevent phase error by filtering in both directions (filtfilt)
    
    A Butterworth filter is used. Filtering is done with second-order sections.
    
    .. seealso:: :func:`octave_filter`
    
    """
    sos = octave_filter(center, fs, fraction, order)
    if zero_phase:
        return _sosfiltfilt(sos, signal)
    else:
        return sosfilt(sos, signal)
예제 #25
0
def bandpass(signal, lowcut, highcut, fs, order=8, zero_phase=False):
    """Filter signal with band-pass filter.
    
    :param signal: Signal
    :param lowcut: Lower cut-off frequency
    :param highcut: Upper cut-off frequency
    :param fs: Sample frequency
    :param order: Filter order
    :param zero_phase: Prevent phase error by filtering in both directions (filtfilt)
    
    A Butterworth filter is used. Filtering is done with second-order sections.
    
    .. seealso:: :func:`bandpass_filter` for the filter that is used.
    
    """
    sos = bandpass_filter(lowcut, highcut, fs, order, output='sos')
    if zero_phase:
        return _sosfiltfilt(sos, signal)
    else:
        return sosfilt(sos, signal)
예제 #26
0
    def _detect(x, fs, fmin, fmax, psd_mode):
        """Detects signal stimulus."""
        x = x.astype(np.float64)

        if psd_mode:
            # Estimate power spectral density.
            f, pxx = sig.welch(x, fs, nperseg=256, noverlap=(256//2))
            # Create mask.
            mask = (f > fmin) & (f < fmax)
            # Calculate stimulus.
            y = np.mean(pxx[mask])
        else:
            # Design digital Butterworth filter in sos format.
            order, freq_nqst = 6, fs//2
            sos = sig.butter(order, [fmin/freq_nqst, fmax/freq_nqst],
                             btype='bandpass', analog=False, output='sos')
            # Filter signal.
            xf = sig.sosfilt(sos, x, axis=-1)
            # Calculate stimulus.
            y = np.mean(xf)

        return y
예제 #27
0
t = np.arange(Lh) / fs
s2z = matchedz_zpk
# s2z = bilinear_zpk

# Analog filter
H = np.zeros(num_w, dtype='complex')
num_biquad, Gb, G = shelving_filter_parameters(
    biquad_per_octave=biquad_per_octave, slope=slope, BWd=BWd)
sos_sdomain = low_shelving_2nd_cascade(w0, Gb, num_biquad, biquad_per_octave)
zs, ps, ks = sos2zpk(sos_sdomain)

# Digital filter
zpk = s2z(zs * 2 * np.pi * fc, ps * 2 * np.pi * fc, ks, fs=fs)
sos_zdomain = zpk2sos(*zpk)
H = sosfreqz(sos_zdomain, worN=f, fs=fs)[1]
h = sosfilt(sos_zdomain, xin)

# Plots
flim = fmin, fmax
fticks = fc * 2.**np.arange(-8, 4, 2)
fticklabels = ['7.8', '31.3', '125', '500', '2k', '8k']
fticks = 1000 * 2.**np.arange(-6, 6, 2)
fticklabels = ['15.6', '62.5', '250', '1k', '4k', '16k']
kw = dict(c='C0', lw=2, alpha=1)

fig, ax = plt.subplots(figsize=(13, 3), ncols=3, gridspec_kw={'wspace': 0.25})

# frequency response
ax[0].semilogx(f, db(H), **kw)
ax[1].semilogx(f, np.angle(H, deg=True), **kw)
예제 #28
0
파일: misc.py 프로젝트: nfoti/mne-python
def plot_filter(h, sfreq, freq=None, gain=None, title=None, color='#1f77b4',
                flim=None, fscale='log', alim=(-60, 10), show=True):
    """Plot properties of a filter.

    Parameters
    ----------
    h : dict or ndarray
        An IIR dict or 1D ndarray of coefficients (for FIR filter).
    sfreq : float
        Sample rate of the data (Hz).
    freq : array-like or None
        The ideal response frequencies to plot (must be in ascending order).
        If None (default), do not plot the ideal response.
    gain : array-like or None
        The ideal response gains to plot.
        If None (default), do not plot the ideal response.
    title : str | None
        The title to use. If None (default), deteremine the title based
        on the type of the system.
    color : color object
        The color to use (default '#1f77b4').
    flim : tuple or None
        If not None, the x-axis frequency limits (Hz) to use.
        If None, freq will be used. If None (default) and freq is None,
        ``(0.1, sfreq / 2.)`` will be used.
    fscale : str
        Frequency scaling to use, can be "log" (default) or "linear".
    alim : tuple
        The y-axis amplitude limits (dB) to use (default: (-60, 10)).
    show : bool
        Show figure if True (default).

    Returns
    -------
    fig : matplotlib.figure.Figure
        The figure containing the plots.

    See Also
    --------
    mne.filter.create_filter
    plot_ideal_filter

    Notes
    -----
    .. versionadded:: 0.14
    """
    from scipy.signal import freqz, group_delay
    import matplotlib.pyplot as plt
    sfreq = float(sfreq)
    _check_fscale(fscale)
    flim = _get_flim(flim, fscale, freq, sfreq)
    if fscale == 'log':
        omega = np.logspace(np.log10(flim[0]), np.log10(flim[1]), 1000)
    else:
        omega = np.linspace(flim[0], flim[1], 1000)
    omega /= sfreq / (2 * np.pi)
    if isinstance(h, dict):  # IIR h.ndim == 2:  # second-order sections
        if 'sos' in h:
            from scipy.signal import sosfilt
            h = h['sos']
            H = np.ones(len(omega), np.complex128)
            gd = np.zeros(len(omega))
            for section in h:
                this_H = freqz(section[:3], section[3:], omega)[1]
                H *= this_H
                with warnings.catch_warnings(record=True):  # singular GD
                    gd += group_delay((section[:3], section[3:]), omega)[1]
            n = estimate_ringing_samples(h)
            delta = np.zeros(n)
            delta[0] = 1
            h = sosfilt(h, delta)
        else:
            from scipy.signal import lfilter
            n = estimate_ringing_samples((h['b'], h['a']))
            delta = np.zeros(n)
            delta[0] = 1
            H = freqz(h['b'], h['a'], omega)[1]
            with warnings.catch_warnings(record=True):  # singular GD
                gd = group_delay((h['b'], h['a']), omega)[1]
            h = lfilter(h['b'], h['a'], delta)
        title = 'SOS (IIR) filter' if title is None else title
    else:
        H = freqz(h, worN=omega)[1]
        with warnings.catch_warnings(record=True):  # singular GD
            gd = group_delay((h, [1.]), omega)[1]
        title = 'FIR filter' if title is None else title
    gd /= sfreq
    fig, axes = plt.subplots(3)  # eventually axes could be a parameter
    t = np.arange(len(h)) / sfreq
    f = omega * sfreq / (2 * np.pi)
    axes[0].plot(t, h, color=color)
    axes[0].set(xlim=t[[0, -1]], xlabel='Time (sec)',
                ylabel='Amplitude h(n)', title=title)
    mag = 10 * np.log10(np.maximum((H * H.conj()).real, 1e-20))
    axes[1].plot(f, mag, color=color, linewidth=2, zorder=4)
    if freq is not None and gain is not None:
        plot_ideal_filter(freq, gain, axes[1], fscale=fscale,
                          title=None, show=False)
    axes[1].set(ylabel='Magnitude (dB)', xlabel='', xscale=fscale)
    sl = slice(0 if fscale == 'linear' else 1, None, None)
    axes[2].plot(f[sl], gd[sl], color=color, linewidth=2, zorder=4)
    axes[2].set(xlim=flim, ylabel='Group delay (sec)', xlabel='Frequency (Hz)',
                xscale=fscale)
    xticks, xticklabels = _filter_ticks(flim, fscale)
    dlim = [0, 1.05 * gd[1:].max()]
    for ax, ylim, ylabel in zip(axes[1:], (alim, dlim),
                                ('Amplitude (dB)', 'Delay (sec)')):
        if xticks is not None:
            ax.set(xticks=xticks)
            ax.set(xticklabels=xticklabels)
        ax.set(xlim=flim, ylim=ylim, xlabel='Frequency (Hz)', ylabel=ylabel)
    adjust_axes(axes)
    tight_layout()
    plt_show(show)
    return fig
예제 #29
0
 def filter_ndvar(self, ndvar):
     axis = ndvar.get_axis('time')
     sos = self._sos(1. / ndvar.time.tstep)
     x = signal.sosfilt(sos, ndvar.x, axis)
     return NDVar(x, ndvar.dims, ndvar.info.copy(), ndvar.name)
예제 #30
0
         8 + ntimesteps * size_of_float + 12 )

        #for nt in range(ntimesteps):
        #    values[nt] = np.fromfile(f_in,dtype=dtype_output,count=1)
        values = np.fromfile(f_in, dtype=dtype_output, count=ntimesteps)

        tr = Trace(data=values)

        # Filter and downsample
        # Since the same filter will be applied to all synthetics consistently, non-zero-phase should be okay
        # ToDo: Think about whether zerophase would be better

        # taper first
        #ToDo: Discuss with Andreas whether this tapering makes sense!
        tr.taper(type='cosine', max_percentage=0.001)
        tr.data = sosfilt(sos, tr.data)
        tr.stats.sampling_rate = fs_old
        tr.interpolate(fs_new)

        # Differentiate
        if output_quantity == 'VEL' or output_quantity == 'ACC':
            tr.differentiate()
            if output_quantity == 'ACC':
                tr.differentiate()

        # Remove the extra time that specfem added
        tr.trim(starttime=tr.stats.starttime + offset_seconds)

        # Set data type
        tr.data = tr.data.astype(dtype_output)
예제 #31
0
def filter20_to_20k(x, fs):
    nyq = 0.5 * fs
    sos = sig.butter(5, [20.0 / nyq, 20000.0 / nyq], btype="band", output="sos")
    return sig.sosfilt(sos, x)
sos = butter(10, [0.04, 0.16], btype="bandpass", output="sos")
w, h = sosfreqz(sos, worN=8000)

# Plot the magnitude and phase of the frequency response.
plt.figure(figsize=(4.0, 4.0))
plt.subplot(211)
plt.plot(w / np.pi, np.abs(h))
plt.grid(alpha=0.25)
plt.ylabel('Gain')
plt.subplot(212)
plt.plot(w / np.pi, np.angle(h))
yaxis = plt.gca().yaxis
yaxis.set_ticks([-np.pi, -0.5 * np.pi, 0, 0.5 * np.pi, np.pi])
yaxis.set_ticklabels([r'$-\pi$', r'$-\pi/2$', '0', r'$\pi/2$', r'$\pi$'])
plt.xlabel('Normalized frequency')
plt.grid(alpha=0.25)
plt.ylabel('Phase')
plt.tight_layout()
plt.savefig("sos_bandpass_response_freq.pdf")

# Plot the step response.
x = np.ones(200)
y = sosfilt(sos, x)

plt.figure(figsize=(4.0, 2.0))
plt.plot(y)
plt.grid(alpha=0.25)
plt.xlabel('Sample number')
plt.tight_layout()
plt.savefig("sos_bandpass_response_step.pdf")
예제 #33
0
def filter_data(data,
                dataplot=False,
                filter_response_plot=False,
                sampling_frequency=250):
    #this follows the arnav process
    #signal processing
    #	- hpf, notch filter (50 Hz) x 3 with harmonics, lpf

    #applying high pass filter - 0.5, used to remove frequencies lower than 0.5Hz
    filter_order = 1
    # critical_frequencies = [15, 50] #in Hz
    critical_frequency = 1.5  # in Hz
    FILTER = 'highpass'  #'bandpass'
    output = 'sos'
    #design butterworth bandpass filter
    sos = signal.butter(filter_order,
                        critical_frequency,
                        FILTER,
                        fs=sampling_frequency,
                        output=output)
    filtered = signal.sosfilt(sos, data)

    #response of the high pass filter
    if (filter_response_plot):
        b, a = signal.butter(filter_order, critical_frequency, FILTER,
                             sampling_frequency)
        w, h = signal.freqz(b, a, sampling_frequency)
        plt.semilogx(w, 20 * np.log10(abs(h)))
        plt.xlabel('Frequency [radians / second]')
        plt.ylabel('Amplitude [dB]')
        plt.margins(0, 0.1)
        plt.grid(which='both', axis='both')

        cutoff_freq = []
        cutoff_freq.append(critical_frequency)
        for freq in cutoff_freq:
            plt.axvline(freq, color='green')
        plt.show()

    #normalize -(normalizing to a mean amplitude of zero (still need to cross check this))
    data = data - np.mean(data, axis=0)

    #applying notch filter
    notch_times = 3
    notch_frequency = 50  #Hz
    quality_factor = 30  # -- no reason just copied.

    #power line noise @ 50 Hz and its harmonics.
    freqs = list(
        map(
            int,
            list(
                map(
                    round,
                    np.arange(1, sampling_frequency / (2. * notch_frequency)) *
                    notch_frequency))))
    for _ in range(notch_times):
        for f in reversed(freqs):
            #design notch filter
            b, a = signal.iirnotch(f, quality_factor, sampling_frequency)
            filtered = signal.lfilter(b, a, filtered)

    #response of iirnotch filter
    if filter_response_plot:
        # Frequency response
        freq, h = signal.freqz(b, a, fs=sampling_frequency)
        # Plot
        fig, ax = plt.subplots(2, 1, figsize=(8, 6))
        ax[0].plot(freq, 20 * np.log10(abs(h)), color='blue')
        ax[0].set_title("Frequency Response")
        ax[0].set_ylabel("Amplitude (dB)", color='blue')
        ax[0].set_xlim([0, 100])
        ax[0].set_ylim([-25, 10])
        ax[0].grid()
        ax[1].plot(freq, np.unwrap(np.angle(h)) * 180 / np.pi, color='green')
        ax[1].set_ylabel("Angle (degrees)", color='green')
        ax[1].set_xlabel("Frequency (Hz)")
        ax[1].set_xlim([0, 100])
        ax[1].set_yticks([-90, -60, -30, 0, 30, 60, 90])
        ax[1].set_ylim([-90, 90])
        ax[1].grid()
        plt.show()

    #applying lowpass filter  50 Hz
    filter_order = 1
    # critical_frequencies = [15, 50] #in Hz for bandpass
    critical_frequencies = 50  # in Hz
    FILTER = 'lowpass'  #'bandpass'
    output = 'sos'

    #design butterworth lowpass filter
    sos = signal.butter(filter_order,
                        critical_frequencies,
                        FILTER,
                        fs=sampling_frequency,
                        output=output)
    filtered = signal.sosfilt(sos, data)

    #response of the lowpass filter
    if (filter_response_plot):
        output = 'ba'
        b, a = signal.butter(filter_order,
                             critical_frequencies,
                             FILTER,
                             fs=sampling_frequency,
                             output=output)
        w, h = signal.freqz(b, a, fs=sampling_frequency)
        plt.semilogx(w, 20 * np.log10(abs(h)))
        plt.xlabel('Frequency [radians / second]')
        plt.ylabel('Amplitude [dB]')
        plt.margins(0, 0.1)
        plt.grid(which='both', axis='both')

        for freq in critical_frequencies:
            plt.axvline(freq, color='green')
        plt.show()

    #applying ricker
    ricker_width = 35 * sampling_frequency // 250
    ricker_sigma = 4.0 * sampling_frequency / 250  #4.0...
    ricker = signal.ricker(ricker_width, ricker_sigma)
    # normalize ricker
    ricker = np.array(ricker, np.float32) / np.sum(np.abs(ricker))
    #obtain the ricker in the data
    convolution = signal.convolve(filtered, ricker, mode="same")
    #remove the heart beat artifacts from the original signal
    filtered = filtered - 2 * convolution

    if (filter_response_plot):
        plt.plot(convolution)
        plt.show()

    return filtered
예제 #34
0
by = np.exp(-tspan / 0.05)

cn = np.convolve(n, by)
cn = cn[:len(tspan)]
s = 0.1 * np.sin(2 * np.pi * tspan) + cn

freq_sample = 0.5 * (1 / dt)  # Sampling frequency
df = 1 / tspan[-1]
freq = np.arange(df, freq_sample + df, df)
signal_fft = fft.fft(s)
signal_fft = signal_fft[:len(freq)]
signal_fft = abs(signal_fft)
# Filtered signal
f_c = 10 / freq_sample  # cut-off frequency
sos = signal.butter(5, f_c, 'lp', output='sos')
signal_filtered = signal.sosfilt(sos, s)
filtered_fft = fft.fft(signal_filtered)
filtered_fft = filtered_fft[:len(freq)]
filtered_fft = abs(filtered_fft)

fig0 = plt.figure()
ax0 = fig0.add_axes([0, 0, 1, 1])
ax0.plot(freq, signal_fft)
ax0.plot(freq, filtered_fft)
ax0.set_xlabel('Frequency (Hz)')
ax0.set_ylabel('FFT')
ax0.set_title('FFT for the random signal')
#ax0.legend(['Original signal','Filtered signal'])
ax0.grid(True)

fig3, (ax31, ax32) = plt.subplots(2, 1)
예제 #35
0
Ephys = dyn_osc.Ephys

# Setup our chirp
pt = '906'
condit = 'OffTarget'

timeseries = dbo.load_BR_dict(Ephys[pt][condit]['Filename'],sec_offset=0)
end_time = timeseries['Left'].shape[0]/422

if pt == '903':
    tidxs = np.arange(231200,329300) #DBS903
if pt == '906':
    tidxs = np.arange(256000,330200) #DBS903

sos_lpf = sig.butter(10,10,output='sos',fs = 422)
filt_L = sig.sosfilt(sos_lpf,timeseries['Left']) 
#filt_L = sig.decimate(filt_L,2)[tidxs] #-211*60*8:
filt_R = sig.sosfilt(sos_lpf,timeseries['Right'])
#filt_R = sig.decimate(filt_R,2)[tidxs]

state = np.vstack((filt_L,filt_R))
sd = np.diff(state,axis=1,append=0)


#Let's take out the BL stim first from the raw timeseries
window = np.arange(255583,296095)
chirp = state[:,window]
#plt.figure()
#plt.plot(chirp.T)

## Now we get into subwindows
예제 #36
0
    def filter(self, *filt):
        """Apply the given filter to this `TimeSeries`.

        All recognised filter arguments are converted either into cascading
        second-order sections (if scipy >= 0.16 is installed), or into the
        ``(numerator, denominator)`` representation before being applied
        to this `TimeSeries`.

        .. note::

           All filters are presumed to be digital (Z-domain), if you have
           an analog ZPK (in Hertz or in rad/s) you should be using
           `TimeSeries.zpk` instead.

        .. note::

           When using `scipy` < 0.16 some higher-order filters may be
           unstable. With `scipy` >= 0.16 higher-order filters are
           decomposed into second-order-sections, and so are much more stable.

        Parameters
        ----------
        *filt
            one of:

            - :class:`scipy.signal.lti`
            - `MxN` `numpy.ndarray` of second-order-sections
              (`scipy` >= 0.16 only)
            - ``(numerator, denominator)`` polynomials
            - ``(zeros, poles, gain)``
            - ``(A, B, C, D)`` 'state-space' representation

        Returns
        -------
        result : `TimeSeries`
            the filtered version of the input `TimeSeries`

        See also
        --------
        TimeSeries.zpk
            for instructions on how to filter using a ZPK with frequencies
            in Hertz
        scipy.signal.sosfilter
            for details on the second-order section filtering method
            (`scipy` >= 0.16 only)
        scipy.signal.lfilter
            for details on the filtering method

        Raises
        ------
        ValueError
            If ``filt`` arguments cannot be interpreted properly
        """
        sos = None
        # single argument given
        if len(filt) == 1:
            filt = filt[0]
            # detect LTI
            if isinstance(filt, signal.lti):
                filt = filt
                a = filt.den
                b = filt.num
            # detect SOS
            elif isinstance(filt, numpy.ndarray) and filt.ndim == 2:
                sos = filt
            # detect taps
            else:
                b = filt
                a = [1]
        # detect TF
        elif len(filt) == 2:
            b, a = filt
        elif len(filt) == 3:
            try:
                sos = signal.zpk2sos(*filt)
            except AttributeError:
                b, a = signal.zpk2tf(*filt)
        elif len(filt) == 4:
            try:
                zpk = signal.ss2zpk(*filt)
                sos = signal.zpk2sos(zpk)
            except AttributeError:
                b, a = signal.ss2tf(*filt)
        else:
            raise ValueError("Cannot interpret filter arguments. Please "
                             "give either a signal.lti object, or a "
                             "tuple in zpk or ba format. See "
                             "scipy.signal docs for details.")
        if sos is not None:
            new = signal.sosfilt(sos, self, axis=0).view(self.__class__)
        else:
            new = signal.lfilter(b, a, self, axis=0).view(self.__class__)
        new.__dict__ = self.copy_metadata()
        return new
예제 #37
0
 def time_sosfilt_basic(self, n_samples, order):
     sosfilt(self.sos, self.y)
예제 #38
0
 def applyComponent(self, component):
     sos = self.buildFilter(component)
     return sp.sosfilt(sos, component)
예제 #39
0
def convertData(adr="./data/features_clear_less.dat"):
    print("Program started" + "\n")
    fout_data = open(adr, 'w')
    fout_labels0 = open("./data\labels_0.dat", 'w')
    fout_labels1 = open("./data\labels_1.dat", 'w')
    fout_labels2 = open("./data\labels_2.dat", 'w')
    fout_labels3 = open("./data\labels_3.dat", 'w')

    print("\n" + "Print Successful")

    for i in range(32):  #nUser #4, 40, 32, 40, 8064
        if (i % 1 == 0):
            if i < 10:
                name = '%0*d' % (2, i + 1)
            else:
                name = i + 1
        fname = "./data_preprocessed_python\s" + str(
            name) + ".dat"  #C:/Users/lumsys/AnacondaProjects/Emo/
        f = open(fname, 'rb')
        x = pickle.load(f, encoding='latin1')
        print(fname)
        for tr in range(nTrial):
            # noise = np.random.normal(0,3000, size=(8064,))
            start = 128 * 3 - 1
            if (tr % 1 == 0):
                for dat in range(128 * 3, nTime):
                    if dat != 0:
                        if ((dat - 383) % 768 == 0):
                            if (tr == 0 and i == 0):
                                print(dat)
                            for ch in [32, 33, 36, 38]:
                                if (1 == 1):
                                    if ch == 36 or ch == 32 or ch == 33:
                                        data_fil = x['data'][tr][ch]
                                    else:
                                        data_oringin = x['data'][tr][ch]
                                        sos = signal.butter(4,
                                                            0.3,
                                                            'high',
                                                            output='sos')
                                        data_fil = signal.sosfilt(
                                            sos, data_oringin)

                                    features = extract_fre_fea(
                                        data_fil[start:dat])
                                    for fea in features:
                                        fout_data.write(str(fea) + " ")

                            start = dat

                            fout_labels0.write(str(x['labels'][tr][0]) + "\n")
                            fout_labels1.write(str(x['labels'][tr][1]) + "\n")
                            fout_labels2.write(str(x['labels'][tr][2]) + "\n")
                            fout_labels3.write(str(x['labels'][tr][3]) + "\n")
                            fout_data.write("\n")

                #个性化特征
                # fout_data.write(str(tr)+ " ")
                # fout_data.write(str(i)+ " ")
                # 总
                # print(x['data'][tr][39][:].shape)
                # for data in datas:
                #     fout_data.write(str(data)+ " ")
                # fout_labels0.write(str(x['labels'][tr][0]) + "\n")
                # fout_labels1.write(str(x['labels'][tr][1]) + "\n")
                # fout_labels2.write(str(x['labels'][tr][2]) + "\n")
                # fout_labels3.write(str(x['labels'][tr][3]) + "\n")
                # fout_data.write("\n")#40个特征换行
    fout_labels0.close()
    fout_labels1.close()
    fout_labels2.close()
    fout_labels3.close()
    fout_data.close()
    print("\n" + "Print Successful")
예제 #40
0
파일: plot.py 프로젝트: lileipku00/ants_2
def plot_converging_stack(inputfile, bandpass=None, pause=0.):

    f = h5py.File(inputfile, 'r')
    plt.ion()

    stack = f['corr_windows'].keys()[0]
    stack = f['corr_windows'][stack][:]
    stats = f['stats']
    Fs = stats.attrs['sampling_rate']
    cha1 = stats.attrs['channel1']
    cha2 = stats.attrs['channel2']

    if bandpass is not None:
        sos = get_bandpass(df=Fs,
                           freqmin=bandpass[0],
                           freqmax=bandpass[1],
                           corners=bandpass[2])
        firstpass = sosfilt(sos, stack)
        stack = sosfilt(sos, firstpass[::-1])[::-1]

    # display a counter for stacked windows
    cnt = 1

    max_lag = ((len(stack) - 1) / 2) / Fs
    lag = np.linspace(-max_lag, max_lag, len(stack))

    fig = plt.figure()
    ax1 = fig.add_subplot(212)

    ax1.set_title('{}--{}'.format(cha1, cha2))
    ax1.set_xlabel('Lag (s)')
    ax1.set_ylabel('Correlation stack')
    line1, = ax1.plot(lag, stack, 'k')

    ax2 = fig.add_subplot(211)
    ax2.set_ylim([np.min(stack) * 3, np.max(stack) * 3])
    ax2.set_ylabel('Correlation window(s)')
    line2, = ax2.plot(lag, stack)
    text1 = ax2.set_title(str(cnt))

    plt.show()

    for key in f['corr_windows'].keys():

        cwindow = f['corr_windows'][key][:]

        if bandpass is not None:

            firstpass = sosfilt(sos, cwindow)
            cwindow = sosfilt(sos, firstpass[::-1])[::-1]

        stack += cwindow

        ax1.set_ylim([np.min(stack) * 1.5, np.max(stack) * 1.5])
        text1.set_text(str(cnt))

        line1.set_ydata(stack)
        line2.set_ydata(cwindow)

        fig.canvas.draw()
        cnt += 1
        if pause > 0:
            time.sleep(pause)
예제 #41
0
def predict(request):
    # Get ML model
    storage_client = storage.Client()
    bucket = storage_client.get_bucket('sensordaten-d713c.appspot.com')
    blob = bucket.blob('ml_model/pickle_svm.sav')
    pickle_in = blob.download_as_string()
    best_svm = pickle.loads(pickle_in)
    print('ML Model:')
    print(best_svm)

    # Get CSV data
    raw_data = pd.read_csv(
        'gs://sensordaten-d713c.appspot.com/file_to_process/sensordaten.csv')
    raw_data.columns = ['time', 'x', 'y', 'z', 'abs']
    raw_data = raw_data.drop(columns=['abs'])
    print('Data Head of csv file:')
    print(raw_data.head())
    # Get SPC from CSV
    SPC = 0.31  # TODO Read SPC from CSV
    f = 100  # TODO Read frequency from CSV
    # Process Offset
    start = 10
    end = raw_data['time'].max() - 10
    offset_data = raw_data[(raw_data['time'] >= start)
                           & (raw_data['time'] <= end)]
    offset_data['time'] = offset_data['time'] - offset_data['time'].min()
    offset_data.index = offset_data.index - offset_data.index.min()
    print(offset_data.head())
    # Process Filter & SPC
    filter_data = copy.deepcopy(offset_data)
    sos = signal.butter(10, (5, 30), btype='bandpass', fs=f, output='sos')
    for col in ['x', 'y', 'z']:
        filter_data[col] = signal.sosfilt(sos, offset_data[col])
        filter_data[col] = filter_data[col] / (1 - SPC)

    # Create datatable for feature engineering
    max_time = int(filter_data['time'].max())
    period = 10
    aggregated_data = pd.DataFrame(list(range(0, max_time, period)),
                                   columns=['time'])
    for col in ['x', 'y', 'z']:
        aggregated_data[f'{col}_mean'] = np.nan
        aggregated_data[f'{col}_max'] = np.nan
        aggregated_data[f'{col}_min'] = np.nan
        aggregated_data[f'{col}_std'] = np.nan
    for timestamp in aggregated_data['time']:
        relevant_rows = raw_data[((raw_data['time'] >= timestamp) &
                                  (raw_data['time'] < timestamp + period))]
        relevant_rows.index = relevant_rows.index - relevant_rows.index.min()
        outlier_relevant = process_outlier_detection(relevant_rows,
                                                     ['x', 'y', 'z'])
        for col in ['x', 'y', 'z']:
            aggregated_data.loc[timestamp / period,
                                str(col) + str('_mean')] = np.mean(
                                    outlier_relevant[col])
            aggregated_data.loc[timestamp / period,
                                str(col) + str('_max')] = np.max(
                                    outlier_relevant[col])
            aggregated_data.loc[timestamp / period,
                                str(col) + str('_min')] = np.min(
                                    outlier_relevant[col])
            aggregated_data.loc[timestamp / period,
                                str(col) + str('_std')] = np.std(
                                    outlier_relevant[col])

    print('Aggregated Datatable:')
    print(aggregated_data)
    # Predict underground for aggregated values
    predictions = best_svm.predict(aggregated_data.drop(columns=['time']))
    export_pred = pd.DataFrame(predictions, columns=['prediction'])
    print(export_pred)
예제 #42
0
def butter_highpass(lowcut, fs, order=5):
    nyq = 0.5 * fs
    low = lowcut / nyq
    b, a = signal.butter(order, [low], btype='highpass')
    return b, a

def butter_highpass_filter(data, lowcut, fs, order=5):
    b, a = butter_highpass(lowcut, fs, order=order)
    y = signal.lfilter(b, a, data)
    return y

lc = 0.1
hc = 30

sos = signal.butter(10, lc, 'hp', fs=fs, output='sos')
filtered = signal.sosfilt(sos, cz)

plt.figure()
plt.plot(t, filtered[0:sample_window], label='Filtered signal')
plt.plot(t, sample, label='Unfiltered signal')
plt.plot(t, trig_sample, label='Trigger')
plt.legend(loc='best')
# %%

plot_freq(filtered, fs)


# %% Find the spacing of events
event_idxs = np.nonzero(trig)[0]

print(f'Number of events: {len(event_idxs)}')
예제 #43
0
def rectified_band_pass_signals(sig, sb=2048, sh=1024):
    """Compute the rectified band-pass signals as per Clause 5.1.5 of ECMA-418-2:2020

    Calculation of the rectified band-pass signals along the 53 critical band rates
    scale. Each band pass signal is segmented into time blocks according to sb and sh


    Parameters
    ----------
    signal: numpy.array
        'Pa', time signal values. The sampling frequency of the signal must be 48000 Hz.
    sb: int or list of int
        block size.
    sh: int or list of int
        Hop size.
    Returns
    -------
    block_array_rect: list of numpy.array
        rectified band-pass signals
    """

    if isinstance(sb, int):
        sb = sb * np.ones(53, dtype=int)
    elif len(sb) != 53:
        raise ValueError("ERROR: len(sb) shall be either 1 or 53")
    if isinstance(sh, int):
        sh = sh * np.ones(53, dtype=int)
    elif len(sh) != 53:
        raise ValueError("ERROR: len(sh) shall be either 1 or 53")

    # OUTER AND MIDDLE EAR FILTERING (5.1.2)

    sos_ear = ear_filter_design()
    signal_filtered = sp_signal.sosfilt(sos_ear, sig, axis=0)

    # AUDITORY FILTERING BANK (5.1.3)

    # Order of the Outer and Middle ear filter
    filter_order_k = 5
    # Sampling frequency
    fs = 48000.00
    # Auditory filters centre frequencies
    centre_freq = gen_auditory_filters_centre_freq()

    block_array_rect = []
    for band_number in range(53):
        bm_mod, am_mod = gammatone(centre_freq[band_number],
                                   k=filter_order_k,
                                   fs=fs)
        # bm_mod, am_mod = sp_signal.gammatone(centre_freq[band_number], "fir", fs=fs)
        """ 
        "scipy.signal.lfilter" instead of "scipy.signal.filtfilt" in order to maintain consistency. That process 
        makes possible to obtain a signal "band_pass_signal" that does not line up in time with the original signal 
        because of the non zero-phase filtering of "lfilter", but it has a more appropriate slope than filtfilt. 
        By using filtfilt the slope is that high that filters too much the signal. 
        """
        band_pass_signal = (2.0 * (sp_signal.lfilter(
            bm_mod,
            am_mod,
            signal_filtered,
            axis=0,
        )).real)
        """SEGMENTATION OF THE SIGNAL INTO BLOCKS (5.1.4)

        The segmentation of the signal is done in order to obtain results for intervals of time, not for the whole
        duration of the signal. The reason behind this decision resides in the fact that processing the signal in its
        full length at one time could end up in imprecise results. By using a "for loop", we are able to decompose the
        signal array "band_pass_signal_hr" into blocks. "sb_array" is the block size which changes depending on the
        "band_number" in which we are processing the signal. "sh_array" is the step size, the time shift to the next
        block.
        """
        block_array = segmentation_blocks(band_pass_signal,
                                          sb[band_number],
                                          sh[band_number],
                                          dim=1)
        """RECTIFICATION (5.1.5)

        This part acts as the activation of the auditory nerves when the basilar membrane vibrates in a certain
        direction. In order to rectify the signal we are using "np.clip" which establish a minimum and a maximum value
        for the signal. "a_min" is set to 0 float, while "a_max" is set to "None" in order to consider the positive
        value of the signal.
        """
        block_array_rect.append(np.clip(block_array, a_min=0.00, a_max=None))

    return block_array_rect
예제 #44
0
def lowpass_cheby_2(data,
                    freq,
                    df,
                    maxorder=12,
                    ba=False,
                    freq_passband=False):
    """
    Cheby2-Lowpass Filter

    Filter data by passing data only below a certain frequency.
    The main purpose of this cheby2 filter is downsampling.
    This method will iteratively design a filter, whose pass
    band frequency is determined dynamically, such that the
    values above the stop band frequency are lower than -96dB.

    Parameters
    ----------
    data : array
        Data to filter.

    freq : float 
        The frequency above which signals are attenuated with 95 dB.
    
    df : float
        Sampling rate in Hz.

    maxorder : int
        Maximal order of the designed cheby2 filter.
        **Default:** ``12``

    ba : bool
        If True return only the filter coefficients (b, a) instead of filtering.
        **Default:** ``False``

    freq_passband : bool
        If True return additionally to the filtered data, the iteratively determined pass band frequency.
        **Default:** ``False``

    
    Returns
    -------
    data : array
        Filtered data.
    
    """

    nyquist = df * 0.5
    # rp - maximum ripple of passband, rs - attenuation of stopband
    rp, rs, order = 1, 96, 1e99
    ws = freq / nyquist  # stop band frequency
    wp = ws  # pass band frequency
    # raise for some bad scenarios
    if ws > 1:
        ws = 1.0
        msg = "Selected corner frequency is above Nyquist. " + \
              "Setting Nyquist as high corner."
        warnings.warn(msg)
    while True:
        if order <= maxorder:
            break
        wp = wp * 0.99
        order, wn = cheb2ord(wp, ws, rp, rs, analog=0)
    if ba:
        return cheby2(order, rs, wn, btype='low', analog=0, output='ba')
    z, p, k = cheby2(order, rs, wn, btype='low', analog=0, output='zpk')
    sos = zpk2sos(z, p, k)
    if freq_passband:
        return sosfilt(sos, data), wp * nyquist
    return sosfilt(sos, data)
예제 #45
0
import scipy.signal as sg
from pysndfx import AudioEffectsChain


def filter_audio(y, sr=16_000, cutoff=15_000, low_cutoff=1, filter_order=5):
    sos = sg.butter(filter_order, [low_cutoff / sr / 2, cutoff / sr / 2],
                    btype='band',
                    analog=False,
                    output='sos')
    filtered = sg.sosfilt(sos, y)

    return filtered


def shelf(y,
          sr=16_000,
          gain=5,
          frequency=500,
          slope=0.5,
          high_frequency=7_000):
    afc = AudioEffectsChain()
    fx = afc.lowshelf(gain=gain, frequency=frequency, slope=slope)\
            .highshelf(gain=-gain, frequency=high_frequency, slope=slope)

    y = fx(y, sample_in=sr, sample_out=sr)

    return y
예제 #46
0
def bandpass(d):
    # create filter with cutoff frequencies 5 & 5,000
    sos = signal.butter(2, [5, 5000], 'bp', fs=25000, output='sos')

    # apply filter and return
    return signal.sosfilt(sos, d)
예제 #47
0
end_time = 5
order = 10
buffer_size = 200
cutoff_frequency = 10
btype = 'hp'
if __name__ == '__main__':
    # plt.figure(dpi=1200)

    f = importlib.import_module('files.blueprints.butterworth.main').P(start_time, sample_spacing, buffer_size, cutoff_frequency)
    signal = generate_signal([1, 2, 4, 8, 16, 32, 64, 128], [0, 0, 0, 0, 1, 0, 0, 0])
    noise = generate_noise(.0)
    t_range = np.arange(start_time, end_time, sample_spacing)
    output = np.zeros(len(t_range))
    plt.plot(t_range, [signal(t) + noise(t) for t in t_range])
    plt.show()
    sos = si.butter(order, cutoff_frequency, btype, fs=1 / sample_spacing, output='sos')
    filtered = si.sosfilt(sos, [signal(t) + noise(t) for t in t_range])
    plt.plot(t_range, filtered)
    plt.show()
    # asdf = np.zeros(len(t_range))
    # for i in range(len(t_range)//buffer_size):
    #     asdf[i:buffer_size] =

    for i, t in enumerate(t_range):
        f.set_inputs([0], [signal(t) + noise(t)])
        f.step(t)
        output[i] = f.get_outputs([0])[0]
    plt.plot(t_range, output)
    plt.show()

예제 #48
0
def high_pass_filter(x, low_cutoff=10000, sample_rate=sample_rate):
    nyquist = 0.5 * sample_rate
    norm_low_cutoff = low_cutoff / nyquist
    sos = butter(10, Wn=[norm_low_cutoff], btype='highpass', output='sos')
    filtered_sig = sosfilt(sos, x)
    return filtered_sig
예제 #49
0
    def draw_impz(self):
        """
        (Re-)calculate h[n] and draw the figure
        """
        log = self.chkLog.isChecked()
        stim = str(self.cmbStimulus.currentText())
        periodic_sig = stim in {"Sine","Rect", "Saw"}
        self.lblLogBottom.setVisible(log)
        self.ledLogBottom.setVisible(log)
        self.lbldB.setVisible(log)
        
        self.lblFreq.setVisible(periodic_sig)
        self.ledFreq.setVisible(periodic_sig)
        self.lblFreqUnit.setVisible(periodic_sig)

        
#        self.lblFreqUnit.setVisible(fb.fil[0]['freq_specs_unit'] == 'f_S')
        self.lblFreqUnit.setText(rt_label(fb.fil[0]['freq_specs_unit']))
        self.load_entry()
        
        
        self.bb = np.asarray(fb.fil[0]['ba'][0])
        self.aa = np.asarray(fb.fil[0]['ba'][1])
        sos = np.asarray(fb.fil[0]['sos'])

        self.f_S  = fb.fil[0]['f_S']
        
        N = self.calc_n_points(abs(int(self.ledNPoints.text())))

        t = np.linspace(0, N/self.f_S, N, endpoint=False)
        # calculate h[n]
        if stim == "Pulse":
            x = np.zeros(N)
            x[0] =1.0 # create dirac impulse as input signal
            title_str = r'Impulse Response'
            H_str = r'$h[n]$'
        elif stim == "Step":
            x = np.ones(N) # create step function
            title_str = r'Step Response'
            H_str = r'$h_{\epsilon}[n]$'
        elif stim == "StepErr":
            x = np.ones(N) # create step function
            title_str = r'Settling Error'
            H_str = r'$H(0) - h_{\epsilon}[n]$'
            
        elif stim in {"Sine", "Rect"}:
            x = np.sin(2 * np.pi * t * float(self.ledFreq.text()))
            if stim == "Sine":
                title_str = r'Response to Sine Signal'
                H_str = r'$h_{\sin}[n]$'
            else:
                x = np.sign(x)
                title_str = r'Response to Rect. Signal'
                H_str = r'$h_{rect}[n]$'
        else:
            x = sig.sawtooth(t * (float(self.ledFreq.text())* 2*np.pi))
            title_str = r'Response to Sawtooth Signal'
            H_str = r'$h_{saw}[n]$'

            
        if not np.any(sos): # no second order sections for current filter          
            h = sig.lfilter(self.bb, self.aa, x)
            dc = sig.freqz(self.bb, self.aa, [0])
        else:
#            print(sos)
            h = sig.sosfilt(sos, x)
            dc = sig.freqz(self.bb, self.aa, [0])
        
        if stim == "StepErr":
            h = h - abs(dc[1]) # subtract DC value from response


        self.cmplx = np.any(np.iscomplex(h))
        if self.cmplx:
            h_i = h.imag
            h = h.real
            H_i_str = r'$\Im\{$' + H_str + '$\}$'
            H_str = r'$\Re\{$' + H_str + '$\}$'
        if log:
            bottom = float(self.ledLogBottom.text())
            H_str = r'$|$ ' + H_str + '$|$ in dB'
            h = np.maximum(20 * np.log10(abs(h)), bottom)
            if self.cmplx:
                h_i = np.maximum(20 * np.log10(abs(h_i)), bottom)
                H_i_str = r'$\log$ ' + H_i_str + ' in dB'
        else:
            bottom = 0

        self._init_axes()


        #================ Main Plotting Routine =========================
        [ml, sl, bl] = self.ax_r.stem(t, h, bottom=bottom, markerfmt='bo', linefmt='r')
        if self.chkPltStim.isChecked():
            [ms, ss, bs] = self.ax_r.stem(t, x, bottom=bottom, markerfmt='k*', linefmt='0.5')
            for stem in ss:
                stem.set_linewidth(0.5)
            bs.set_visible(False) # invisible bottomline
        expand_lim(self.ax_r, 0.02)
        self.ax_r.set_title(title_str)

        if self.cmplx:
            [ml_i, sl_i, bl_i] = self.ax_i.stem(t, h_i, bottom=bottom,
                                                markerfmt='rd', linefmt='b')
            self.ax_i.set_xlabel(fb.fil[0]['plt_tLabel'])
            # self.ax_r.get_xaxis().set_ticklabels([]) # removes both xticklabels
            # plt.setp(ax_r.get_xticklabels(), visible=False) 
            # is shorter but imports matplotlib, set property directly instead:
            [label.set_visible(False) for label in self.ax_r.get_xticklabels()]
            self.ax_r.set_ylabel(H_str + r'$\rightarrow $')
            self.ax_i.set_ylabel(H_i_str + r'$\rightarrow $')
        else:
            self.ax_r.set_xlabel(fb.fil[0]['plt_tLabel'])
            self.ax_r.set_ylabel(H_str + r'$\rightarrow $')


        if self.ACTIVE_3D: # not implemented / tested yet

            # plotting the stems
            for i in range(len(t)):
              self.ax3d.plot([t[i], t[i]], [h[i], h[i]], [0, h_i[i]],
                             '-', linewidth=2, color='b', alpha=.5)

            # plotting a circle on the top of each stem
            self.ax3d.plot(t, h, h_i, 'o', markersize=8,
                           markerfacecolor='none', color='b', label='ib')

            self.ax3d.set_xlabel('x')
            self.ax3d.set_ylabel('y')
            self.ax3d.set_zlabel('z')

        self.mplwidget.redraw()
예제 #50
0
def plot_filter(h,
                sfreq,
                freq=None,
                gain=None,
                title=None,
                color='#1f77b4',
                flim=None,
                fscale='log',
                alim=(-60, 10),
                show=True):
    """Plot properties of a filter.

    Parameters
    ----------
    h : dict or ndarray
        An IIR dict or 1D ndarray of coefficients (for FIR filter).
    sfreq : float
        Sample rate of the data (Hz).
    freq : array-like or None
        The ideal response frequencies to plot (must be in ascending order).
        If None (default), do not plot the ideal response.
    gain : array-like or None
        The ideal response gains to plot.
        If None (default), do not plot the ideal response.
    title : str | None
        The title to use. If None (default), deteremine the title based
        on the type of the system.
    color : color object
        The color to use (default '#1f77b4').
    flim : tuple or None
        If not None, the x-axis frequency limits (Hz) to use.
        If None, freq will be used. If None (default) and freq is None,
        ``(0.1, sfreq / 2.)`` will be used.
    fscale : str
        Frequency scaling to use, can be "log" (default) or "linear".
    alim : tuple
        The y-axis amplitude limits (dB) to use (default: (-60, 10)).
    show : bool
        Show figure if True (default).

    Returns
    -------
    fig : matplotlib.figure.Figure
        The figure containing the plots.

    See Also
    --------
    mne.filter.create_filter
    plot_ideal_filter

    Notes
    -----
    .. versionadded:: 0.14
    """
    from scipy.signal import freqz, group_delay
    import matplotlib.pyplot as plt
    sfreq = float(sfreq)
    _check_fscale(fscale)
    flim = _get_flim(flim, fscale, freq, sfreq)
    if fscale == 'log':
        omega = np.logspace(np.log10(flim[0]), np.log10(flim[1]), 1000)
    else:
        omega = np.linspace(flim[0], flim[1], 1000)
    omega /= sfreq / (2 * np.pi)
    if isinstance(h, dict):  # IIR h.ndim == 2:  # second-order sections
        if 'sos' in h:
            from scipy.signal import sosfilt
            h = h['sos']
            H = np.ones(len(omega), np.complex128)
            gd = np.zeros(len(omega))
            for section in h:
                this_H = freqz(section[:3], section[3:], omega)[1]
                H *= this_H
                with warnings.catch_warnings(record=True):  # singular GD
                    gd += group_delay((section[:3], section[3:]), omega)[1]
            n = estimate_ringing_samples(h)
            delta = np.zeros(n)
            delta[0] = 1
            h = sosfilt(h, delta)
        else:
            from scipy.signal import lfilter
            n = estimate_ringing_samples((h['b'], h['a']))
            delta = np.zeros(n)
            delta[0] = 1
            H = freqz(h['b'], h['a'], omega)[1]
            with warnings.catch_warnings(record=True):  # singular GD
                gd = group_delay((h['b'], h['a']), omega)[1]
            h = lfilter(h['b'], h['a'], delta)
        title = 'SOS (IIR) filter' if title is None else title
    else:
        H = freqz(h, worN=omega)[1]
        with warnings.catch_warnings(record=True):  # singular GD
            gd = group_delay((h, [1.]), omega)[1]
        title = 'FIR filter' if title is None else title
    gd /= sfreq
    fig, axes = plt.subplots(3)  # eventually axes could be a parameter
    t = np.arange(len(h)) / sfreq
    f = omega * sfreq / (2 * np.pi)
    axes[0].plot(t, h, color=color)
    axes[0].set(xlim=t[[0, -1]],
                xlabel='Time (sec)',
                ylabel='Amplitude h(n)',
                title=title)
    mag = 10 * np.log10(np.maximum((H * H.conj()).real, 1e-20))
    axes[1].plot(f, mag, color=color, linewidth=2, zorder=4)
    if freq is not None and gain is not None:
        plot_ideal_filter(freq,
                          gain,
                          axes[1],
                          fscale=fscale,
                          title=None,
                          show=False)
    axes[1].set(ylabel='Magnitude (dB)', xlabel='', xscale=fscale)
    sl = slice(0 if fscale == 'linear' else 1, None, None)
    axes[2].plot(f[sl], gd[sl], color=color, linewidth=2, zorder=4)
    axes[2].set(xlim=flim,
                ylabel='Group delay (sec)',
                xlabel='Frequency (Hz)',
                xscale=fscale)
    xticks, xticklabels = _filter_ticks(flim, fscale)
    dlim = [0, 1.05 * gd[1:].max()]
    for ax, ylim, ylabel in zip(axes[1:], (alim, dlim),
                                ('Amplitude (dB)', 'Delay (sec)')):
        if xticks is not None:
            ax.set(xticks=xticks)
            ax.set(xticklabels=xticklabels)
        ax.set(xlim=flim, ylim=ylim, xlabel='Frequency (Hz)', ylabel=ylabel)
    adjust_axes(axes)
    tight_layout()
    plt_show(show)
    return fig
예제 #51
0
    p = pyaudio.PyAudio()  # start the PyAudio class
    stream = p.open(format=pyaudio.paInt16,
                    channels=1,
                    rate=RATE,
                    input=True,
                    frames_per_buffer=CHUNK)  #uses default input device

    data_buffer = np.array([])
    # create a numpy array holding a single read of audio data
    for i in range(30):  #to it a few times just to see
        print(i)
        data = np.frombuffer(stream.read(CHUNK), dtype=np.int16)
        data_buffer = np.concatenate([data_buffer, data])

        sos = signal.butter(10, 15, 'hp', fs=1000, output='sos')
        data_buffer = signal.sosfilt(sos, data_buffer)

    # close the stream gracefully
    stream.stop_stream()
    stream.close()
    p.terminate()

    np.save('ding69.npy', data_buffer)
    plt.plot(data_buffer)
    plt.show()

else:

    data_buffer = np.load('ding69.npy')[74700:107700]
    np.save('ding_select_floor2_left_mic.npy', data_buffer)
    plt.plot(data_buffer)
예제 #52
0
    def update(self, line_label, data):
        """

        :param line_label: Label of the segmented series
        :param data: Replace data in the segmented series with these data
        :return:
        """
        ss_info = self.segmented_series[line_label]
        n_in = data.shape[0]
        if self.plot_config['do_hp']:
            data, ss_info['hp_zi'] = signal.sosfilt(self.plot_config['hp_sos'],
                                                    data,
                                                    zi=ss_info['hp_zi'])
        if self.plot_config['do_ln']:
            pass  # TODO: Line noise / comb filter
        if self.pya_stream:
            if 'chan_label' in self.audio and self.audio['chan_label']:
                if self.audio['chan_label'] == line_label:
                    write_indices = (
                        np.arange(data.shape[0]) +
                        self.audio['write_ix']) % self.audio['buffer'].shape[0]
                    self.audio['buffer'][write_indices] = (
                        np.copy(data) *
                        (2**15 / self.plot_config['y_range'])).astype(np.int16)
                    self.audio['write_ix'] = (
                        self.audio['write_ix'] +
                        data.shape[0]) % self.audio['buffer'].shape[0]

        # Assume new samples are consecutively added to old samples (i.e., no lost samples)
        sample_indices = np.arange(n_in,
                                   dtype=np.int32) + ss_info['last_sample_ix']

        # Wrap sample indices around our plotting limit
        n_plot_samples = int(self.plot_config['x_range'] * self.samplingRate)
        sample_indices = np.int32(np.mod(sample_indices, n_plot_samples))

        # If the data length is longer than one sweep then the indices will overlap. Trim to last n_plot_samples
        if sample_indices.size > n_plot_samples:
            sample_indices = sample_indices[-n_plot_samples:]
            data = data[-n_plot_samples:]

        # Go through each plotting segment and replace data with new data as needed.
        for pci in ss_info['plot'].dataItems:
            old_x, old_y = pci.getData()
            x_lims = [old_x[0], old_x[-1]]
            if self.plot_config['downsample']:
                x_lims[1] += (DSFAC - 1)
            data_bool = np.logical_and(sample_indices >= x_lims[0],
                                       sample_indices <= x_lims[-1])
            if np.where(data_bool)[0].size > 0:
                new_x, new_y = sample_indices[data_bool], data[data_bool]
                if self.plot_config['downsample']:
                    new_x = new_x[::DSFAC] - (new_x[0] % DSFAC) + (old_x[0] %
                                                                   DSFAC)
                    new_y = new_y[::DSFAC]
                old_bool = np.in1d(old_x, new_x, assume_unique=True)
                new_bool = np.in1d(new_x, old_x, assume_unique=True)
                old_y[old_bool] = new_y[new_bool]
                # old_y[np.where(old_bool)[0][-1]+1:] = 0  # Uncomment to zero out the end of the last seg.
                pci.setData(x=old_x, y=old_y)
        # Store last_sample_ix for next iteration.
        self.segmented_series[line_label]['last_sample_ix'] = sample_indices[
            -1]
예제 #53
0
 def butter_bandpass_filter(self, data, lowcut, highcut, fs, order=5):
     sos = self.butter_bandpass(lowcut, highcut, fs, order=order)
     y = sosfilt(sos, data)
     return y
예제 #54
0
def preprocessing_proc(sos, traces):  
    return signal.sosfilt(sos, traces)
예제 #55
0
def butter_filter(timeseries, fs, cutoffs, btype='band', order=4):
    #Scipy v1.2.0
    nyquist = fs / 2
    butter_cut = np.divide(cutoffs, nyquist)  #butterworth param (digital)
    sos = butter(order, butter_cut, output='sos', btype=btype)
    return sosfilt(sos, timeseries)
예제 #56
0
 def __butter_bandstop_filter(self, data, lowcut, highcut, fs, order=5):
     sos = self.__butter_bandstop(lowcut, highcut, fs, order=order)
     y = sosfilt(sos, data).astype(np.float32)
     return y
예제 #57
0
파일: corrblock.py 프로젝트: lermert/ants_2
	def run(self,output_file=None):


		print('Working on station pairs:')
		for sta in self.station_pairs:
			print("{}--{}".format(sta[0],sta[1]))

		t_0 = UTCDateTime(self.cfg.time_begin)
		t_end = UTCDateTime(self.cfg.time_end)
		win_len_seconds = self.cfg.time_window_length
		win_len_samples = int(round(win_len_seconds*self.sampling_rate))
		min_len_samples = int(round(self.cfg.time_min_window*self.sampling_rate))
		max_lag_samples = int(round(self.cfg.corr_maxlag * self.sampling_rate))
		
		
		if self.cfg.bandpass is not None:
			fmin = self.cfg.bandpass[0]
			fmax = self.cfg.bandpass[1]
			if fmax <= fmin:
				msg = "Bandpass upper corner frequency must be above lower corner frequency."
				raise ValueError(msg)

			order = self.cfg.bandpass[2]
			sos = bandpass(freqmin=fmin,freqmax=fmax,
				df=self.sampling_rate,corners=order)


		# Time loop
		t = t_0
		
		while t <= t_end - (win_len_seconds - self.delta):
			

			print(t,file=output_file)
			
			
			
			# - check endtime, if necessary, add data from 'later' file
			self.update_data(t, win_len_seconds)
			
			

			# - slice the traces
			
			if self.cfg.time_overlap == 0:
				windows = self.data.slice(t, t + win_len_seconds - self.delta)
			else:
				# - deepcopy is used so that processing is not applied directly on the data stream
				# - This is much more expensive than using non-overlapping windows, due to the copying
				windows = self.data.slice(t, t + win_len_seconds - self.delta).copy()
			
			

			
			# - Apply preprocessing
			for w in windows:
				
			
				if self.cfg.bandpass is not None:
					w_temp = sosfilt(sos,w.data)
					w.data = sosfilt(sos,w_temp[::-1])[::-1]

				if self.cfg.cap_glitch:
					cap(w,self.cfg.cap_thresh)

				if self.cfg.whiten:
					whiten(w,self.cfg.white_freqmin,
						self.cfg.white_freqmax,
						self.cfg.white_taper_samples)

				if self.cfg.onebit:
					w.data = np.sign(w.data)

				if self.cfg.ram_norm:
					ram_norm(w,self.cfg.ram_window,self.cfg.ram_prefilt)
				

			# - station pair loop
			for sp_i in range(len(self.station_pairs)):

				pair = self.station_pairs[sp_i]
				
				# - select traces
				[net1, sta1] = pair[0].split('.')
				[net2, sta2] = pair[1].split('.')
				
				str1 = windows.select(network=net1, station=sta1)
				str2 = windows.select(network=net2, station=sta2)
				

				# - if horizontal components are involved, copy and rotate
				if any([i in self.cfg.corr_tensorcomponents for i in horizontals]):

					str1, str2 = self.rotate(str1,str2,self.baz1[sp_i],self.baz2[sp_i])
					
				# - channel loop
				
				for cpair in self.channel_pairs[sp_i]:

					cpair = [re.sub('E$','T',str) for str in cpair]
					cpair = [re.sub('N$','R',str) for str in cpair]
				
					cp_name = '{}--{}'.format(*cpair)
					print(cp_name,file=output_file)
					

					loc1, cha1 = cpair[0].split('.')[2:4]
					loc2, cha2 = cpair[1].split('.')[2:4]


					try:
						tr1 = str1.select(location=loc1,channel=cha1)[0]
						tr2 = str2.select(location=loc2,channel=cha2)[0]
						
					except IndexError:
						print("Channel not found",file=output_file)
						continue
						
					# - check minimum length requirement
					# - Quite often not fulfilled due to data gaps
					if tr1.stats.npts < min_len_samples:
						print("Trace length < min samples\n",file=output_file)
						continue
						
					if tr2.stats.npts < min_len_samples:
						print("Trace length < min samples\n",file=output_file)
						continue

					if True in np.isnan(tr1.data):
						print("Trace contains nan\n",file=output_file)
						continue

					if True in np.isnan(tr2.data):
						print("Trace contains nan\n",file=output_file)
						continue

					if True in np.isinf(tr1.data):
						print("Trace contains inf\n",file=output_file)
						continue

					if True in np.isinf(tr2.data):
						print("Trace contains inf\n",file=output_file)
						continue


					# - correlate
					correlation = cross_covar(tr1.data,tr2.data,
						max_lag_samples,self.cfg.corr_normalize)[0]
					
					# - add to stack
					if len(correlation) == 2 * max_lag_samples + 1:
						self._correlations[cp_name]._add_corr(correlation,t)
					else:
						print('Empty window or all values zero in window.',
							file=output_file)
					
						




			# - update time
			t += self.cfg.time_window_length - self.cfg.time_overlap

		# - Write results

		for corr in self._correlations.values():
			
			corr.write_stack(output_format=self.cfg.format_output)

		print('Finished a correlation block.')
예제 #58
0
def butterFilter(data, cuttof, filter_order=20, filter_type='low', plot=False):
    """Apply Butterworth filter."""

    DEBUG = False
    # DEBUG = True

    # nyquist frequency
    nyq = 0.5 * Global.simul_frequency

    # adjsut cuttof frequency
    if isinstance(cuttof, list):
        cuttof_nyq = []
        cuttof_nyq[0] = cuttof[0] / nyq
        cuttof_nyq[1] = cuttof[1] / nyq
    else:
        cuttof_nyq = cuttof / nyq

    # data time frame
    number_points = len(data)
    time_frame = number_points * Global.time_step

    number_samples = int(Global.simul_frequency * time_frame)

    t = np.linspace(0, time_frame, number_samples, False)

    if DEBUG:
        # For testing
        f0 = 10e6
        f1 = 40e6
        data = np.sin(2 * np.pi * f0 * t) + np.sin(2 * np.pi * f1 * t)
        # data = np.sin(2*np.pi*f0*t)

    if plot:
        fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
        ax1.plot(t, data)
        ax1.set_title('Time domain signal')
        ax1.grid()

    # Create filter
    sos = signal.butter(filter_order,
                        cuttof_nyq,
                        btype=filter_type,
                        output='sos')

    # yf = fftpack.fft(data)
    # xf = np.linspace(0.0, 1.0/(2.0*time_frame), int(number_samples/2))

    # fig, ax = plt.subplots()
    # ax.plot(xf, 2.0/number_samples * np.abs(yf[:number_samples//2]))
    # plt.show()

    # filtered signal
    filtered = signal.sosfilt(sos, data)

    # get filter frequency and absolute value
    w, h = signal.sosfreqz(sos, worN=number_points)

    if plot:
        ax2.plot(t, filtered)
        ax2.set_title('Filtered signal.')
        # ax2.axis([0, 1, -2, 2])
        ax2.set_xlabel('Time [seconds]')
        plt.tight_layout()
        ax2.grid()
        plt.show()

        plt.semilogx((Global.simul_frequency * 0.5 / np.pi) * w,
                     20 * np.log10(abs(h)))

        plt.title('Butterworth filter frequency response')
        plt.xlabel('Frequency [radians / second]')
        plt.ylabel('Amplitude [dB]')
        plt.margins(0, 0.1)
        plt.grid(which='both', axis='both')
        plt.axvline(cuttof, color='green')  # cutoff frequency
        # plt.grid()
        plt.show()

        # plotBode(data, time_frame, number_samples, cuttof, data2=filtered)
        plotBode(data, t, number_samples, cuttof, data2=filtered)

    return filtered
def butter_lowpass_filter(data, cutoff, fs, order=5):
    sos = butter_lowpass(cutoff, fs, order=order)
    y = signal.sosfilt(sos, data)
    return y
예제 #60
0
def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):
    z, p, k = butter_bandpass(lowcut, highcut, fs, order=order)
    convert = zpk2sos(z, p, k)
    y = sosfilt(convert, data)
    return y