def __init__(self, F, accountForDelay=True): """Constructor applies sinx/x interpolating filter. @param F float amount of delay to apply. The delay is in samples of the input waveform. @param accountForDelay (optional) boolean whether to account for the delay @remark if accountForDelay, then the filter provides a sample phase adjustment, meaning that there is no actual delay applied to the waveform, but the time axis under the waveform is shifted. This is the usual way to apply this filter and is used to adapt waveforms on different time axes to each other.\n if not accountForDelay, then the filter actually delays waveforms by the delay specified. @remark The filter is hard-coded in a static member to have 64 samples on each side of a center sample. In other words, it is 2*64+1=129 samples in length. """ # pragma: silent exclude from SignalIntegrity.Lib.TimeDomain.Filters.FilterDescriptor import FilterDescriptor # pragma: include U = 1 FirFilter.__init__( self, FilterDescriptor(U, self.S + F if accountForDelay else self.S, 2 * self.S), SinX(self.S, U, F))
def __init__(self, S=1): """Constructor @param S integer side samples. The filter is 2*S+1 total samples. """ L = 2 * S + 1 w = [math.cos(2 * math.pi * (k - S) / L) * 0.5 + 0.5 for k in range(L)] Scale = sum(w) w = [tap / Scale for tap in w] FirFilter.__init__(self, FilterDescriptor(1, S, 2 * S), w)
def __init__(self, U): """Constructor applies a sinx/x interpolating filter. @param U integer upsample factor of the filter. """ # pragma: silent exclude from SignalIntegrity.Lib.TimeDomain.Filters.FilterDescriptor import FilterDescriptor # pragma: include F = 0. FirFilter.__init__(self, FilterDescriptor(U, self.S + F, 2 * self.S), SinX(self.S, U, F))
def __init__(self, U): """Constructor applies a linear interpolating filter. @param U integer upsample factor of the filter. """ # pragma: silent exclude from SignalIntegrity.Lib.TimeDomain.Filters.FilterDescriptor import FilterDescriptor # pragma: include FirFilter.__init__( self, FilterDescriptor(U, (U - 1.) / float(U), 2 * (U - 1.) / float(U)), [float(u + 1) / float(U) for u in range(U)] + [1 - float(u + 1) / float(U) for u in range(U - 1)])
def FirFilter(self): """FIR filter equivalent of impulse response for processing @return an instance of class FirFilter that can be convolved with a waveform """ td = self.td return FirFilter(FilterDescriptor(1, -td.H * td.Fs, td.K - 1), self.Values())
def __init__(self, F, accountForDelay=True): """Constructor applies a two-tap linear interpolating filter. @param F float amount of delay to apply. The delay is in samples of the input waveform. @param accountForDelay (optional) boolean whether to account for the delay @remark if accountForDelay, then the filter provides a sample phase adjustment, meaning that there is no actual delay applied to the waveform, but the time axis under the waveform is shifted. This is the usual way to apply this filter and is used to adapt waveforms on different time axes to each other.\n if not accountForDelay, then the filter actually delays waveforms by the delay specified. """ # pragma: silent exclude from SignalIntegrity.Lib.TimeDomain.Filters.FilterDescriptor import FilterDescriptor # pragma: include FirFilter.__init__( self, FilterDescriptor(1, (F if F >= 0 else 1 + F) if accountForDelay else 0, 1), [1 - F, F] if F >= 0 else [-F, 1 + F])
def FilterWaveform(self, wf): """overloads base class FilterWaveform @param wf instance of class Waveform @return instance of class Waveform containing the upsampled, interpolated wf @remark This method first classically upsamples the waveform by inserting zeros between the samples and then passes the upsampled waveform through the sinx/x interpolation filter. """ # pragma: silent exclude from SignalIntegrity.Lib.TimeDomain.Waveform.Waveform import Waveform # pragma: include fd = self.FilterDescriptor() us = [0. for k in range(len(wf) * fd.U)] for k in range(len(wf)): us[k * fd.U] = wf[k] return FirFilter.FilterWaveform(self, Waveform(wf.td, us))