org.orangepalantir.filters

Class SavitzyGolayFilter

java.lang.Object

org.orangepalantir.filters.SavitzyGolayFilter

public class SavitzyGolayFilter
extends Object

Class implements the Savitzy-Golay filter. The algorithm is based on the algorithm used in Numerical Methods in C: The art of scientific computing second edition This filter is used for smoothing data. The current implementation is a 1-d approach and a symmetric 2-d approach.

Constructor Summary

Constructors

Constructor and Description
SavitzyGolayFilter(int left, int right, int order) Prepares the filter coefficients
SavitzyGolayFilter(int left, int right, int order, int derivative) Prepares the filter coefficients

Method Summary

Modifier and Type	Method and Description
static double	evaluatePolynomial(double[] poly, double x) Evaluates a polynomial where: p(x) = poly[0] * x**m + poly[1] * x**(m-1) + ...
static double	evaluatePolynomial(double[] poly, double x, int order) Evaluates derivative of polynomial where with: p(x) = poly[0] * x**m + poly[1] * x**(m-1) + ...
double	filter(double[] o, double[] mask, int start, int middle) Calculates one point in the data, similar to one step of a convolution.
float	filter(float[] o, double[] mask, int start, int middle) Calculates one point in the data, similar to one step of a convolution.
double[]	filterData(double[] data) filters the data by assuming the ends are reflected.
float[]	filterData(float[] data) filters the data by assuming the ends are reflected.
static double[][]	getKernel(int size, int order) Creates a 2-d Kernel for using a savitzky-golay filter in 2-d.
static double	pfact(int m, int n) Partial factorial,
double	rFilter(double[] o, double[] mask, int start, int middle) Calculates one point in the data, similar to one step of a convolution.
float	rFilter(float[] o, double[] mask, int start, int middle) Calculates one point in the data, similar to one step of a convolution.
static double[]	SavitzkyGolayCoefficients(int nl, int nr, int order) Creates the array of coefficients for using a least squares polynomial fit of the data.
static double[]	SavitzkyGolayCoefficients(int nl, int nr, int order, int derivative) Creates the array of coefficients for using a least squares polynomial fit of the data.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SavitzyGolayFilter

public SavitzyGolayFilter(int left,
                          int right,
                          int order)

Prepares the filter coefficients

Parameters:

left - number of places to the left of the origion

right - number of places to the right of the origion

order - of polynomial used to fit data

SavitzyGolayFilter

public SavitzyGolayFilter(int left,
                          int right,
                          int order,
                          int derivative)

Prepares the filter coefficients

Parameters:

left - number of places to the left of the origion

right - number of places to the right of the origion

order - of polynomial used to fit data

derivative - use a SavitzkyGolayFilter to calculate the derivative or order.

Method Detail

filterData

public double[] filterData(double[] data)

filters the data by assuming the ends are reflected.

Parameters:

data - the array that is going to be filtered.

filterData

public float[] filterData(float[] data)

filters the data by assuming the ends are reflected.

Parameters:

data -

filter

public float filter(float[] o,
                    double[] mask,
                    int start,
                    int middle)

Calculates one point in the data, similar to one step of a convolution.

Parameters:

o - - data that will be convolved

mask - - kernel

start - - position of the 'middle point' on the data

middle - - postion of the center of the kernel on the kernel

filter

public double filter(double[] o,
                     double[] mask,
                     int start,
                     int middle)

Calculates one point in the data, similar to one step of a convolution.

Parameters:

o - - data that will be convolved

mask - - kernel

start - - position of the 'middle point' on the data

middle - - postion of the center of the kernel on the kernel

rFilter

public double rFilter(double[] o,
                      double[] mask,
                      int start,
                      int middle)

Calculates one point in the data, similar to one step of a convolution. This one will wrap the ends of the mask. Something like a convolution with reflected boundary conditions.

Parameters:

o - - data that will be convolved

mask - - kernel

start - - position of the 'middle point' on the data

middle - - postion of the center of the kernel on the kernel

rFilter

public float rFilter(float[] o,
                     double[] mask,
                     int start,
                     int middle)

Calculates one point in the data, similar to one step of a convolution. This one will wrap the ends of the mask. Something like a convolution with reflected boundary conditions.

Parameters:

o - - data that will be convolved

mask - - kernel

start - - position of the 'middle point' on the data

middle - - postion of the center of the kernel on the kernel

SavitzkyGolayCoefficients

public static double[] SavitzkyGolayCoefficients(int nl,
                                                 int nr,
                                                 int order)

Creates the array of coefficients for using a least squares polynomial fit of the data. Due to the fact the points are equally spaced and the polynomial least squares is linear in the coefficients, a set of coefficients can be used for every element.

Parameters:

nl - - spaces to the left

nr - - spaces to the right

order - - the order of the polynomial being used, not that nl+nr+1 must be more than the order of the polynomial

Returns:

a 'time kernel' for convolving in time.

SavitzkyGolayCoefficients

public static double[] SavitzkyGolayCoefficients(int nl,
                                                 int nr,
                                                 int order,
                                                 int derivative)

Creates the array of coefficients for using a least squares polynomial fit of the data. Due to the fact the points are equally spaced and the polynomial least squares is linear in the coefficients, a set of coefficients can be used for every element.

Parameters:

nl - - spaces to the left

nr - - spaces to the right

order - - the order of the polynomial being used, not that nl+nr+1 must be more than the order of the polynomial

derivative - - returns a set of derivative coefficients

getKernel

public static double[][] getKernel(int size,
                                   int order)

Creates a 2-d Kernel for using a savitzky-golay filter in 2-d. It fits a 2-d polynomial to the data set if the order was 2. f(x) = a*x**2 + b*x + c*x*y + d*y + e*y**2 + f It is solved by least squares fiting '1' functions to polynomials to 2-d polynomials, then these 1 functions can be summed as a linear sum to create a 2d kernel. The kernel is a symmetric square kernel

Parameters:

size - is the halfwidth of the kernel.

order - is the order of polynomial being fit.

evaluatePolynomial

public static double evaluatePolynomial(double[] poly,
                                        double x)

Evaluates a polynomial where: p(x) = poly[0] * x**m + poly[1] * x**(m-1) + ... + poly[m]

Parameters:

poly - - double array representation of a polynomial

x - - the variable that will be evaluated.

evaluatePolynomial

public static double evaluatePolynomial(double[] poly,
                                        double x,
                                        int order)

Evaluates derivative of polynomial where with: p(x) = poly[0] * x**m + poly[1] * x**(m-1) + ... + poly[m]

Parameters:

poly - - double array representation of a polynomial

x - - the variable that will be evaluated.

order - - the order of the derivative. (n in description)

Returns:

m*(m-1)*...(m - n)*poly[0]*x**(m-n) + (m-1)*...(m - n - 1)*poly[1] * x**(m-2) ... + n!*poly[m - n]

pfact

public static double pfact(int m,
                           int n)

Partial factorial,

Parameters:

m - power of x

n - number of derivatives

Returns:

m*(m-1)*...(m - n)