signal._savitzky_golay

Module Contents

Functions

savgol_coeffs(window_length,polyorder,deriv=0,delta=1.0,pos=None,use=”conv”) Compute the coefficients for a 1-d Savitzky-Golay FIR filter.
_polyder(p,m) Differentiate polynomials represented with coefficients.
_fit_edge(x,window_start,window_stop,interp_start,interp_stop,axis,polyorder,deriv,delta,y) Given an n-d array x and the specification of a slice of x from
_fit_edges_polyfit(x,window_length,polyorder,deriv,delta,axis,y) Use polynomial interpolation of x at the low and high ends of the axis
savgol_filter(x,window_length,polyorder,deriv=0,delta=1.0,axis=None,mode=”interp”,cval=0.0) Apply a Savitzky-Golay filter to an array.
savgol_coeffs(window_length, polyorder, deriv=0, delta=1.0, pos=None, use="conv")

Compute the coefficients for a 1-d Savitzky-Golay FIR filter.

window_length : int
The length of the filter window (i.e. the number of coefficients). window_length must be an odd positive integer.
polyorder : int
The order of the polynomial used to fit the samples. polyorder must be less than window_length.
deriv : int, optional
The order of the derivative to compute. This must be a nonnegative integer. The default is 0, which means to filter the data without differentiating.
delta : float, optional
The spacing of the samples to which the filter will be applied. This is only used if deriv > 0.
pos : int or None, optional
If pos is not None, it specifies evaluation position within the window. The default is the middle of the window.
use : str, optional
Either ‘conv’ or ‘dot’. This argument chooses the order of the coefficients. The default is ‘conv’, which means that the coefficients are ordered to be used in a convolution. With use=’dot’, the order is reversed, so the filter is applied by dotting the coefficients with the data set.
coeffs : 1-d ndarray
The filter coefficients.

A. Savitzky, M. J. E. Golay, Smoothing and Differentiation of Data by Simplified Least Squares Procedures. Analytical Chemistry, 1964, 36 (8), pp 1627-1639.

savgol_filter

New in version 0.14.0.

>>> from scipy.signal import savgol_coeffs
>>> savgol_coeffs(5, 2)
array([-0.08571429,  0.34285714,  0.48571429,  0.34285714, -0.08571429])
>>> savgol_coeffs(5, 2, deriv=1)
array([  2.00000000e-01,   1.00000000e-01,   2.00607895e-16,
        -1.00000000e-01,  -2.00000000e-01])

Note that use=’dot’ simply reverses the coefficients.

>>> savgol_coeffs(5, 2, pos=3)
array([ 0.25714286,  0.37142857,  0.34285714,  0.17142857, -0.14285714])
>>> savgol_coeffs(5, 2, pos=3, use='dot')
array([-0.14285714,  0.17142857,  0.34285714,  0.37142857,  0.25714286])

x contains data from the parabola x = t**2, sampled at t = -1, 0, 1, 2, 3. c holds the coefficients that will compute the derivative at the last position. When dotted with x the result should be 6.

>>> x = np.array([1, 0, 1, 4, 9])
>>> c = savgol_coeffs(5, 2, pos=4, deriv=1, use='dot')
>>> c.dot(x)
6.0000000000000018
_polyder(p, m)

Differentiate polynomials represented with coefficients.

p must be a 1D or 2D array. In the 2D case, each column gives the coefficients of a polynomial; the first row holds the coefficients associated with the highest power. m must be a nonnegative integer. (numpy.polyder doesn’t handle the 2D case.)

_fit_edge(x, window_start, window_stop, interp_start, interp_stop, axis, polyorder, deriv, delta, y)

Given an n-d array x and the specification of a slice of x from window_start to window_stop along axis, create an interpolating polynomial of each 1-d slice, and evaluate that polynomial in the slice from interp_start to interp_stop. Put the result into the corresponding slice of y.

_fit_edges_polyfit(x, window_length, polyorder, deriv, delta, axis, y)

Use polynomial interpolation of x at the low and high ends of the axis to fill in the halflen values in y.

This function just calls _fit_edge twice, once for each end of the axis.

savgol_filter(x, window_length, polyorder, deriv=0, delta=1.0, axis=None, mode="interp", cval=0.0)

Apply a Savitzky-Golay filter to an array.

This is a 1-d filter. If x has dimension greater than 1, axis determines the axis along which the filter is applied.

x : array_like
The data to be filtered. If x is not a single or double precision floating point array, it will be converted to type numpy.float64 before filtering.
window_length : int
The length of the filter window (i.e. the number of coefficients). window_length must be a positive odd integer. If mode is ‘interp’, window_length must be less than or equal to the size of x.
polyorder : int
The order of the polynomial used to fit the samples. polyorder must be less than window_length.
deriv : int, optional
The order of the derivative to compute. This must be a nonnegative integer. The default is 0, which means to filter the data without differentiating.
delta : float, optional
The spacing of the samples to which the filter will be applied. This is only used if deriv > 0. Default is 1.0.
axis : int, optional
The axis of the array x along which the filter is to be applied. Default is -1.
mode : str, optional
Must be ‘mirror’, ‘constant’, ‘nearest’, ‘wrap’ or ‘interp’. This determines the type of extension to use for the padded signal to which the filter is applied. When mode is ‘constant’, the padding value is given by cval. See the Notes for more details on ‘mirror’, ‘constant’, ‘wrap’, and ‘nearest’. When the ‘interp’ mode is selected (the default), no extension is used. Instead, a degree polyorder polynomial is fit to the last window_length values of the edges, and this polynomial is used to evaluate the last window_length // 2 output values.
cval : scalar, optional
Value to fill past the edges of the input if mode is ‘constant’. Default is 0.0.
y : ndarray, same shape as x
The filtered data.

savgol_coeffs

Details on the mode options:

‘mirror’:
Repeats the values at the edges in reverse order. The value closest to the edge is not included.
‘nearest’:
The extension contains the nearest input value.
‘constant’:
The extension contains the value given by the cval argument.
‘wrap’:
The extension contains the values from the other end of the array.

For example, if the input is [1, 2, 3, 4, 5, 6, 7, 8], and window_length is 7, the following shows the extended data for the various mode options (assuming cval is 0):

mode       |   Ext   |         Input          |   Ext
-----------+---------+------------------------+---------
'mirror'   | 4  3  2 | 1  2  3  4  5  6  7  8 | 7  6  5
'nearest'  | 1  1  1 | 1  2  3  4  5  6  7  8 | 8  8  8
'constant' | 0  0  0 | 1  2  3  4  5  6  7  8 | 0  0  0
'wrap'     | 6  7  8 | 1  2  3  4  5  6  7  8 | 1  2  3

New in version 0.14.0.

>>> from scipy.signal import savgol_filter
>>> np.set_printoptions(precision=2)  # For compact display.
>>> x = np.array([2, 2, 5, 2, 1, 0, 1, 4, 9])

Filter with a window length of 5 and a degree 2 polynomial. Use the defaults for all other parameters.

>>> savgol_filter(x, 5, 2)
array([ 1.66,  3.17,  3.54,  2.86,  0.66,  0.17,  1.  ,  4.  ,  9.  ])

Note that the last five values in x are samples of a parabola, so when mode=’interp’ (the default) is used with polyorder=2, the last three values are unchanged. Compare that to, for example, mode=’nearest’:

>>> savgol_filter(x, 5, 2, mode='nearest')
array([ 1.74,  3.03,  3.54,  2.86,  0.66,  0.17,  1.  ,  4.6 ,  7.97])