libpappsomspp
Library for mass spectrometry
Loading...
Searching...
No Matches
savgolfilter.h
Go to the documentation of this file.
1/* BEGIN software license
2 *
3 * msXpertSuite - mass spectrometry software suite
4 * -----------------------------------------------
5 * Copyright(C) 2009,...,2018 Filippo Rusconi
6 *
7 * http://www.msxpertsuite.org
8 *
9 * This file is part of the msXpertSuite project.
10 *
11 * The msXpertSuite project is the successor of the massXpert project. This
12 * project now includes various independent modules:
13 *
14 * - massXpert, model polymer chemistries and simulate mass spectrometric data;
15 * - mineXpert, a powerful TIC chromatogram/mass spectrum viewer/miner;
16 *
17 * This program is free software: you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation, either version 3 of the License, or
20 * (at your option) any later version.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program. If not, see <http://www.gnu.org/licenses/>.
29 *
30 * END software license
31 */
32
33
34#pragma once
35
36
37#include <QObject>
38
39#include "../../trace/trace.h"
40#include "../../exportinmportconfig.h"
41#include "filternameinterface.h"
42
43
44namespace pappso
45{
46
47
48//! Parameters for the Savitzky-Golay filter
50{
51 int nL = 15;
52 //!< number of data points on the left of the filtered point
53 int nR = 15;
54 //!< number of data points on the right of the filtered point
55 int m = 4;
56 //!< order of the polynomial to use in the regression analysis leading to the
57 //! Savitzky-Golay coefficients (typically between 2 and 6)
58 int lD = 0;
59 //!< specifies the order of the derivative to extract from the Savitzky-Golay
60 //! smoothing algorithm (for regular smoothing, use 0)
61 bool convolveWithNr = false;
62 //!< set to false for best results
63
65
67 : nL{other.nL},
68 nR{other.nR},
69 m{other.m},
70 lD{other.lD},
71 convolveWithNr{other.convolveWithNr}
72 {
73 }
74
76 int nLParam, int nRParam, int mParam, int lDParam, bool convolveWithNrParam)
77 {
78 nL = nLParam;
79 nR = nRParam;
80 m = mParam;
81 lD = lDParam;
82 convolveWithNr = convolveWithNrParam;
83 }
84
85 void
87 int nLParam, int nRParam, int mParam, int lDParam, bool convolveWithNrParam)
88 {
89 nL = nLParam;
90 nR = nRParam;
91 m = mParam;
92 lD = lDParam;
93 convolveWithNr = convolveWithNrParam;
94 }
95
96 void
98 {
99 nL = other.nL;
100 nR = other.nR;
101 m = other.m;
102 lD = other.lD;
103 convolveWithNr = other.convolveWithNr;
104 }
105
106 QString
107 toString() const
108 {
109 return QString("%1;%2;%3;%4;%5")
110 .arg(QString::number(nL))
111 .arg(QString::number(nR))
112 .arg(QString::number(m))
113 .arg(QString::number(lD))
114 .arg(convolveWithNr ? "true" : "false");
115 }
116};
117
118
119class FilterSavitzkyGolay;
120
121typedef std::shared_ptr<FilterSavitzkyGolay> FilterSavitzkyGolaySPtr;
122typedef std::shared_ptr<const FilterSavitzkyGolay> FilterSavitzkyGolayCstSPtr;
123
124
125/**
126 * @brief uses Savitsky-Golay filter on trace
127 */
129{
130 public:
131 /** Construct a FilterSavitzkyGolay instance using the Savitzky-Golay
132 parameters \param nL number of data point left of the point being filtered
133 \param nR number of data point right of the point being filtered
134 \param m order of the polynomial to use in the regression analysis
135 \param lD order of the derivative to extract
136 \param convolveWithNr set to false
137 */
139 int nL, int nR, int m, int lD, bool convolveWithNr = false);
140
141 FilterSavitzkyGolay(const SavGolParams sav_gol_params);
142
143 FilterSavitzkyGolay(const QString &parameters);
144
145 /**
146 * Copy constructor
147 *
148 * @param other TODO
149 */
151
152 /**
153 * Destructor
154 */
155 virtual ~FilterSavitzkyGolay();
156
157 FilterSavitzkyGolay &operator=(const FilterSavitzkyGolay &other);
158
159 Trace &filter(Trace &data_points) const override;
160
161 SavGolParams getParameters() const;
162
163 char runFilter(double *y_data_p,
164 double *y_filtered_data_p,
165 int data_point_count) const;
166
167 void filteredData(std::vector<pappso_double> &data);
168
169 QString name() const override;
170
171 // Utility function
172
173 QString toString() const override;
174
175 protected:
176 void buildFilterFromString(const QString &strBuildParams) override;
177
178 private:
179 ///// Parameters to configure the Savitzky-Golay filter algorithm
180
182
183 ///// Data used for running the algorithm.
184
185 //! C array of keys of the Trace
187
188 //! C array of raw values of the Trace
190
191 //! C array of filtered values after the computation has been performed
193
194
195 ///// Functions that actually implement the algorithm.
196 int *ivector(long nl, long nh) const;
197 pappso_double *dvector(long nl, long nh) const;
198 pappso_double **dmatrix(long nrl, long nrh, long ncl, long nch) const;
199 void free_ivector(int *v, long nl, long nh) const;
200 void free_dvector(pappso_double *v, long nl, long nh) const;
201 void
202 free_dmatrix(pappso_double **m, long nrl, long nrh, long ncl, long nch) const;
203 void lubksb(pappso_double **a, int n, int *indx, pappso_double b[]) const;
204 void ludcmp(pappso_double **a, int n, int *indx, pappso_double *d) const;
205 void four1(pappso_double data[], unsigned long nn, int isign);
206 void twofft(pappso_double data1[],
207 pappso_double data2[],
208 pappso_double fft1[],
209 pappso_double fft2[],
210 unsigned long n);
211 void realft(pappso_double data[], unsigned long n, int isign);
212 char convlv(pappso_double data[],
213 unsigned long n,
214 pappso_double respns[],
215 unsigned long m,
216 int isign,
217 pappso_double ans[]);
218 char sgcoeff(pappso_double c[], int np, int nl, int nr, int ld, int m) const;
219};
220} // namespace pappso
Interface that allows to build filter objects from strings.
uses Savitsky-Golay filter on trace
pappso_double * m_yr
C array of raw values of the Trace.
void filteredData(std::vector< pappso_double > &data)
pappso_double * m_x
C array of keys of the Trace.
pappso_double * m_yf
C array of filtered values after the computation has been performed.
A simple container of DataPoint instances.
Definition trace.h:148
#define PMSPP_LIB_DECL
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition aa.cpp:39
std::shared_ptr< FilterSavitzkyGolay > FilterSavitzkyGolaySPtr
std::shared_ptr< const FilterSavitzkyGolay > FilterSavitzkyGolayCstSPtr
double pappso_double
A type definition for doubles.
Definition types.h:50
Parameters for the Savitzky-Golay filter.
SavGolParams(int nLParam, int nRParam, int mParam, int lDParam, bool convolveWithNrParam)
SavGolParams(const SavGolParams &other)
void initialize(int nLParam, int nRParam, int mParam, int lDParam, bool convolveWithNrParam)
QString toString() const
int nR
number of data points on the right of the filtered point
int nL
number of data points on the left of the filtered point
bool convolveWithNr
set to false for best results
void initialize(const SavGolParams &other)