smooth.par.lib

su 的源代码库

SMOOTH - Functions to compute smoothing of 1-D or 2-D input data

dlsq_smoothing		perform 1 or 2-D smoothing of a 2_D dataset
			via damped least squares. The user specifies
			the degree of smoothing required and the program
			outputs an rms error function to help decide if the
			degree of smoothing was right 

SG_smoothing_filter	computes a 1-D smmothing filter via Savitzky-Golay
			least squares. This filter is then convolved with 
			the data to effect the smoothing. A 2-D array can be
			smoothed in both directions with two passes through
			this function 

rwa_smoothing_filter	computes 1-D smoothing filter via running window average
			The window can be rectangular or triangular (weighted).
			This filter will then be convolved with the data.
			A 2-D array can be smoothed first in one direction and 
			then n the other with two passes through the function.

Function Prototypes:
void dlsq_smoothing (int nt, int nx, int ift, int ilt, int ifx, int ilx, 
	float r1, float r2, float rw, float **traces);

void SG_smoothing_filter(int np, int nl, int nr, int ld, int m, float *filter);

void rwa_smoothing_filter (int flag, int nl, int nr, float *filter);

void gaussian2d_smoothing (int nx, int nt, int nsx, int nst, float **data);

void gaussian1d_smoothing (int ns, int nsr, float *data);

void smooth_histogram (int nintlh, float *pdf);

dlsq_smoothing:
Input:
nt		number of samples in vertical (time) axis
nx		number of samples in horizontal axis (traces)
ift		index of upper left corner of data window to smooth
ilt		index of lower left corner of data window to smooth
ifx		index of upper right corner of data window to smooth
ilx		index of lower right corner of data window to smooth
r1		smoothing parameter in first dimension, usually between 1&20
r2		smoothing parameter in second dimension, usually between 1&20
rw		smoothing parameter of window function. If zero, the window
		will have sharp edges
traces		2-D array of data to smooth

Output:
traces		2-D array of smoothed data

Notes:
Larger r1 and r2 result in smoother data. Recommended ranges are from 1 to 20.

The program outputs a file called err which gives the rms error between the
input and the smoothed data as a function of the first dimension (time or
depth). For most applications, if this error is between 0.1 and 0.01 the 
smoothing parameters are O.K, otherwise, try changing them.

The smoothing can be done in a window of data rather than in the whole data
by specifying the index coordinates of the window. If smoothing of the whole
data is desired, ifx=0, ilx=nx, ift=0, ilt=nt.

If smoothing of only one trace is desired, ifx=0, ilx=1, ift=0, ilt=nt.

Smoothing of the window boundaries (blurring the edges of the window) can be 
done with a rw different than zero, otherwise the edges will be sharp.	

Credits:
Adapted by Gabriel Alvarez (1995) from the program smooth2.c of the CWP library 
	written by Zhenyue Liu (1992)


SG_smoothing_filter:
Input:
np		number of points in output filter (np>=nl+nr+1)
nl		number of left (past) data points used
nr		number of right (future) data points used
ld		order of desired derivative (=0 for smoothed function)
m		order of smoothing polynomial (normally 2 or 4)

Output parameters:
filter		vector of m-points filter coefficients to be convolved 
		with the data to be smoothed

Notes:
This filter is based on the assumption that the underlying function can be
well-fitted by a polynomial. When this is the case, the results are pretty
good. 
 
The filter is particularly good to smooth data that contains narrow peaks,
since it tends to honor them. If the peaks are too narrow with respect to the
filter width, however, some attenuation of the peaks occurs. Higher order 
(higher m) filters tend to perform better with narrower peaks at the expense of
the degree of smoothing of broader features. In general, the best results are
obtained when the full width (nl+nr+1) of the 4-degree filter is between 1 and
2 times the FWHM (full width at half of maximum) of the features that we
desire to smooth in the data.

Wider filters produce greater smoothing effect than narrower ones for filters
of a given order.

To within the roundoff error, the filter coefficients should add to one so that
the area under the curve is preserved after the smoothing. The sign of the 
samples is not preserved in general.

In order to compute filtered numerical derivatives (and not just to smooth 
the data), the parameter ld should be given the value of the desired
derivative (everything else is the same). 
	
A typical call to the convolution subroutine to apply the filter will be:
conv (nl+nr+1,-nl,filter,nd,0,data,nd,0,result);  where data[nd] is the input
data to smooth and result[nd] is the smoothed data

References:
Press, Teukolsky, Vettering, Flannery, Numerical Recipes in C:
		the art of scientific programming. Cambridge University
		Press. Second Edition (1992).
Ziegler, Applied Spectroscopy, Vol. 35, pp. 88-92.
Bromba and Ziegler, Analytical Chemistry, Vol. 53, pp 1582-1586.
Credits:
Adapted from Numerical Recipes in C by Gabriel Alvarez (1995)

rwa_smoothing_filter:
Input:
flag		=1 for rectangular window. =2 for triangular (weighted) window
nl		number of left (past) data points used
nr		number of right (future) data points used

Output:
filter		array[nl+nr+1] of filter points to be convolved with the data

Notes:
The rectangular window should only be used when the data to be smoothed is
fairly smooth already.  larger windows are not recommended unless real
smoothing is desired.

The triangular window will give more weight to the points that are closer
to the one to smooth. Although this is normally desirable, the degree of
smoothing for a given filter length is much less than with the rectangular
windom.

Both of this windows preserve the are under the curve and the sign of the 
samples to be smoothed.

A typical call to the convolution subroutine to apply the filter will be:
conv (nl+nr+1,-nl,filter,nd,0,data,nd,0,result);  where data[nd] is the input
data to smooth and result[nd] is the smoothed data
Credits:
Gabriel Alvarez (1995).