SavitzkyGolay Class Reference

Collaboration diagram for SavitzkyGolay:

Public Member Functions
	SavitzkyGolay (int radius, int poly_order)
std::vector< Point >	filter (const std::vector< Point > &data)
std::vector< Point >	filter_wrap (const std::vector< Point > &data)
std::vector< float >	get_coeffs () const

Private Member Functions
std::vector< std::vector< float > >	invert_matrix (std::vector< std::vector< float > > A)
void	compute_coefficients ()

Private Attributes
int	window_size_
int	window_radius_
int	poly_order_
std::vector< float >	coeffs_

Detailed Description

Definition at line 10 of file SavitskyGolay.h.

Constructor & Destructor Documentation

SavitzkyGolay()

SavitzkyGolay::SavitzkyGolay	(	int	radius,
		int	poly_order
	)

Definition at line 8 of file SavitskyGolay.cpp.

    : window_radius_(radius), window_size_(2 * radius + 1), poly_order_(poly_order) {
    assert(radius >= 0);
    assert(window_size_ > poly_order_);
 
    compute_coefficients();
}

Member Function Documentation

compute_coefficients()

void SavitzkyGolay::compute_coefficients ( )

private

Definition at line 101 of file SavitskyGolay.cpp.

                                         {
    // 1. Create the matrix J = (A^T * A)
    // Size is (poly_order + 1) x (poly_order + 1)
    // Element J[i][j] is the sum of k^(i+j) for k in -m..m
 
    int rows = poly_order_ + 1;
    std::vector<std::vector<float>> J(rows, std::vector<float>(rows));
 
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < rows; ++j) {
            float sum = 0;
            for (int k = -window_radius_; k <= window_radius_; ++k) {
                sum += std::pow(k, i + j);
            }
            J[i][j] = sum;
        }
    }
 
    // 2. Invert J to solve the normal equations
    auto J_inv = invert_matrix(J);
 
    // 3. Compute the weights
    // The smoothed value is the coefficient c_0 of the polynomial.
    // c_0 = sum( weight_k * y_k )
    // weight_k = sum( J_inv[0][j] * k^j ) for j=0..order
 
    coeffs_.resize(window_size_);
    for (int k = -window_radius_; k <= window_radius_; ++k) {
        float weight = 0.0;
        for (int j = 0; j < rows; ++j) {
            weight += J_inv[0][j] * std::pow(k, j);
        }
        coeffs_[k + window_radius_] = weight;
    }
}

filter()

std::vector< Point > SavitzkyGolay::filter

(

const std::vector< Point > &

data

)

Definition at line 16 of file SavitskyGolay.cpp.

                                                                   {
    if (data.size() < window_size_) {
        return data;  // Data too short to filter
    }
 
    std::vector<Point> result(data.size());
 
    // 1. Convolution for the valid range
    for (size_t i = window_radius_; i < data.size() - window_radius_; ++i) {
        Point val{0.0, 0.0};
        for (int j = -window_radius_; j <= window_radius_; ++j) {
            val += data[i + j] * coeffs_[j + window_radius_];
        }
        result[i] = val;
    }
 
    // 2. Handle Edges (Simple Repeat/Nearest padding strategy)
    // For a robust production app, you might calculate asymmetric kernels here.
    for (int i = 0; i < window_radius_; ++i) result[i] = data[i];
    for (size_t i = data.size() - window_radius_; i < data.size(); ++i) result[i] = data[i];
 
    return result;
}

filter_wrap()

std::vector< Point > SavitzkyGolay::filter_wrap

(

const std::vector< Point > &

data

)

Definition at line 40 of file SavitskyGolay.cpp.

                                                                        {
    // wrap around
    if (data.size() < window_size_) {
        return data;  // Data too short to filter
    }
 
    std::vector<Point> result(data.size());
    std::copy(data.begin(), data.end(), result.begin());
 
    for (size_t i = 0; i < data.size(); ++i) {
        Point val{0.0, 0.0};
        for (int j = -window_radius_; j <= window_radius_; ++j) {
            int k = i + j;
            if (k < 0) {
                k = data.size() + k;
            } else if (k >= data.size()) {
                k = k - data.size();
            }
            val = val + data[k] * coeffs_[j + window_radius_];
        }
        result[i] = val;
    }
 
    return result;
}

get_coeffs()

std::vector< float > SavitzkyGolay::get_coeffs ( ) const

inline

Definition at line 24 of file SavitskyGolay.h.

                                        {
        return coeffs_;
    }

invert_matrix()

std::vector< std::vector< float > > SavitzkyGolay::invert_matrix ( std::vector< std::vector< float > >  A )

private

Definition at line 68 of file SavitskyGolay.cpp.

                                                                                      {
    int n = A.size();
    std::vector<std::vector<float>> inv(n, std::vector<float>(n, 0.0));
 
    // Initialize inverse as identity
    for (int i = 0; i < n; ++i) inv[i][i] = 1.0;
 
    for (int i = 0; i < n; ++i) {
        // Find pivot
        float pivot = A[i][i];
        // (Simple pivot check, typically you'd swap rows for stability)
        if (std::abs(pivot) < 1e-10) throw std::runtime_error("Matrix singular, cannot invert.");
 
        // Normalize row
        for (int j = 0; j < n; ++j) {
            A[i][j] /= pivot;
            inv[i][j] /= pivot;
        }
 
        // Eliminate other rows
        for (int k = 0; k < n; ++k) {
            if (k != i) {
                float factor = A[k][i];
                for (int j = 0; j < n; ++j) {
                    A[k][j] -= factor * A[i][j];
                    inv[k][j] -= factor * inv[i][j];
                }
            }
        }
    }
    return inv;
}

Member Data Documentation

coeffs_

std::vector<float> SavitzkyGolay::coeffs_

private

Definition at line 15 of file SavitskyGolay.h.

poly_order_

int SavitzkyGolay::poly_order_

private

Definition at line 14 of file SavitskyGolay.h.

window_radius_

int SavitzkyGolay::window_radius_

private

Definition at line 13 of file SavitskyGolay.h.

window_size_

int SavitzkyGolay::window_size_

private

Definition at line 12 of file SavitskyGolay.h.

---

The documentation for this class was generated from the following files:

• include/internal/SavitskyGolay.h
• src/internal/SavitskyGolay.cpp