Фильтр савицкого голея python

Saved searches

Use saved searches to filter your results more quickly

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session.

Savitzky Golay Filter Implementation in Python

License

sadimanna/savitzky_golay

This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Sign In Required

Please sign in to use Codespaces.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

Savitzky Golay Filter Implementation in Python

Example is shown in comments at the end of the code

Pass the data to the savgol1Dfilt or savgol2Dfilt functions along with the other parameters The functions will return the result

The implementation takes about 170 milliseconds for a 2nd order 2D filter with 11 data points in both direction for smoothing.

And about 3.2 milliseconds for a 3rd order filter taking 13 data pints for smoothing.

[[Intel i3 1.7GHz processor with 4GB RAM]]

About

Savitzky Golay Filter Implementation in Python

Источник

DataTechNotes

Savitzky-Golay filter is used in signal processing to eliminate noise in a signal and improve the smoothness of a signal trend. The filter calculates a polynomial fit of each window based on polynomial degree and window size.

SciPy API provides the savgol_filter() function to implement Savitzky-Golay filter in Python. In this tutorial, we’ll briefly learn how to smooth the signal data by using savgol_filter() function in Python.

1. Preparing signal data
2. Smoothing with Savitzky-Golay filter
3. Source code listing

We’ll start by loading the required libraries.

import numpy as np from scipy import signal import matplotlib.pyplot as plt 

x = np.arange(-2, 2, 0.02) y = np.array(x**2 + 2*np.sin(x*np.pi)) y = y + np.array(np.random.random(len(x))*2.3)

plt.plot(x, y, label="y_signal") plt.legend() plt.grid(True) plt.show() 

To smooth the signal data, Savitzky-Golay filter calculates a polynomial fit of each window based on polynomial degree and window size. Scipy savgol_filter () function requires one dimensional array data, window length, polynomial order, and other optional parameters. We can set the parameters as shown below.

y_smooth = signal.savgol_filter(y, window_length=11, polyorder=3, mode="nearest") 

‘mode’ is an optional parameter and it determines the type of extension to use for the padded signal to which the filter is applied. Mode can be defined as ‘mirror’, ‘nearest’, ‘constant’, and ‘wrap’ type. You can check the definition of each mode and other optional parameters of the function in SciPy reference page.

Now, we can visualize smoothed data in a graph.

plt.figure(figsize=(12, 9)) plt.plot(x, y, label="y_signal") plt.plot(x, y_smooth, linewidth=3, label="y_smoothed") plt.legend() plt.grid(True) plt.show() 

You can change the window size and polynomial order parameters to smooth signal trend well. Here, we’ll test multiple window size and check smoothing effect in a given data.

ig, ax = plt.subplots(4, figsize=(8, 14)) i = 0

 # define window sizes 5, 11, 21, 31 for w_size in [5, 11, 21, 31]: y_fit = signal.savgol_filter(y, w_size, 3, mode="nearest") ax[i].plot(x, y, label="y_signal", color="green") ax[i].plot(x, y_fit, label="y_smoothed", color="red") ax[i].set_title("Window size: " + str(w_size)) ax[i].legend() ax[i].grid(True) i+=1 plt.tight_layout() plt.show() 

As you have seen in above graph, we can change smoothness of signal trend by changing the window size. This helps us to decide optimal window size value for our target data.

In this tutorial, we’ve briefly learned how to smooth signal data by using savgol_filter () function in Python. The full source code is listed below.

import numpy as np from scipy import signal import matplotlib.pyplot as plt x = np.arange(-2, 2, 0.02) y = np.array(x**2+2*np.sin(x*np.pi)) y = y + np.array(np.random.random(len(x))*2.3)

plt.plot(x, y, label="y_signal") plt.legend() plt.grid(True) plt.show() y_smooth = signal.savgol_filter(y, window_length=11, polyorder=3, mode="nearest") plt.figure(figsize=(12, 9)) plt.plot(x, y, label="y_signal") plt.plot(x, y_smooth, linewidth=3, label="y_smoothed") plt.legend() plt.grid(True) plt.show() ig, ax = plt.subplots(4, figsize=(8, 14)) i = 0

 # define window sizes 5, 11, 21, 31 for w_size in [5, 11, 21, 31]: y_fit = signal.savgol_filter(y, w_size, 3, mode="nearest") ax[i].plot(x, y, label="y_signal", color="green") ax[i].plot(x, y_fit, label="y_smoothed", color="red") ax[i].set_title("Window size: " + str(w_size)) ax[i].legend() ax[i].grid(True) i+=1 plt.tight_layout() plt.show() 

Источник

scipy.signal.savgol_filter#

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

Parameters : 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). 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.

Returns : y ndarray, same shape as x

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 

>>> import numpy as np >>> 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]) 

Источник