libpappsomspp
Library for mass spectrometry
Loading...
Searching...
No Matches
filterpass.cpp
Go to the documentation of this file.
1/**
2 * \file pappsomspp/filers/filterpass.cpp
3 * \date 26/04/2019
4 * \author Olivier Langella
5 * \brief collection of filters concerned by Y selection
6 */
7
8/*******************************************************************************
9 * Copyright (c) 2019 Olivier Langella <Olivier.Langella@u-psud.fr>.
10 *
11 * This file is part of the PAPPSOms++ library.
12 *
13 * PAPPSOms++ is free software: you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation, either version 3 of the License, or
16 * (at your option) any later version.
17 *
18 * PAPPSOms++ is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with PAPPSOms++. If not, see <http://www.gnu.org/licenses/>.
25 *
26 ******************************************************************************/
27
28#include "filterpass.h"
29#include "../../trace/trace.h"
30#include <algorithm>
31#include <cmath>
35
36#include <QObject>
37
38using namespace pappso;
39
40
41FilterLowPass::FilterLowPass(double pass_y) : m_passY(pass_y)
42{
43}
45 : m_passY(other.m_passY)
46{
47}
48
51{
52 m_passY = other.m_passY;
53
54 return *this;
55}
56
57
58Trace &
59FilterLowPass::filter(Trace &data_points) const
60{
61 Trace new_data_points;
62 for(auto &&data_point : data_points)
63 {
64 if(data_point.y < m_passY)
65 {
66 new_data_points.push_back(data_point);
67 }
68 }
69 data_points = std::move(new_data_points);
70 return data_points;
71}
72
73FilterHighPass::FilterHighPass(double pass_y) : m_passY(pass_y)
74{
75}
77 : m_passY(other.m_passY)
78{
79}
80
83{
84 m_passY = other.m_passY;
85
86 return *this;
87}
88
89
90Trace &
91FilterHighPass::filter(Trace &data_points) const
92{
93 Trace new_data_points;
94 for(auto &&data_point : data_points)
95 {
96 if(data_point.y > m_passY)
97 {
98 new_data_points.push_back(data_point);
99 }
100 }
101 data_points = std::move(new_data_points);
102 return data_points;
103}
104
105
107 : m_ratioPassY(ratio_pass_y)
108{
109}
110
112 const FilterHighPassPercentage &other)
113 : m_ratioPassY(other.m_ratioPassY)
114{
115}
116
119{
121
122 return *this;
123}
124
125
126Trace &
128{
129 auto it_max = maxYDataPoint(data_points.begin(), data_points.end());
130 if(it_max == data_points.end())
131 return data_points;
132 double pass = (it_max->y * m_ratioPassY);
133 Trace new_data_points;
134 for(auto &&data_point : data_points)
135 {
136 if(data_point.y > pass)
137 {
138 new_data_points.push_back(data_point);
139 }
140 }
141 data_points = std::move(new_data_points);
142 return data_points;
143}
144
145
146FilterGreatestY::FilterGreatestY(std::size_t number_of_points)
147 : m_numberOfPoints(number_of_points)
148{
149}
150
151
153 : m_numberOfPoints(other.m_numberOfPoints)
154{
155}
156
157
160{
162
163 return *this;
164}
165
166
167Trace &
169{
170
171 // Reverse-sort the data points (in y decreasing order) so that we get the
172 // greatest to the front of the vector and we'll then copy the first n data
173 // points to the returned vector. See that return (b < a) ?
174 if(m_numberOfPoints >= data_points.size())
175 return data_points;
176
177 std::sort(data_points.begin(),
178 data_points.end(),
179 [](const DataPoint &a, const DataPoint &b) { return (b.y < a.y); });
180
181 data_points.erase(data_points.begin() + m_numberOfPoints, data_points.end());
182
183 // And now sort the Trace conventionally, that is in x increasing order.
184 std::sort(data_points.begin(),
185 data_points.end(),
186 [](const DataPoint &a, const DataPoint &b) { return (a.x < b.x); });
187
188
189 return data_points;
190}
191
192std::size_t
197
198
200 double window_range, std::size_t number_of_points_per_window)
201 : m_xWindowRange(window_range), m_numberOfPoints(number_of_points_per_window)
202{
203
204 qDebug();
205 if(m_xWindowRange < 0.5)
206 {
208 QObject::tr("window_range must be greater than 0.5"));
209 }
210
211 qDebug();
212}
213
214
216 const FilterGreatestYperWindow &other)
217 : m_xWindowRange(other.m_xWindowRange),
218 m_numberOfPoints(other.m_numberOfPoints)
219{
220 qDebug();
221}
222
225{
226 qDebug();
229
230 return *this;
231}
232
233
234Trace &
236{
237
238 std::vector<DataPoint> new_trace(data_points);
239 data_points.clear();
240
241 int window_number = 0;
242 int old_window_number = -1;
243 std::size_t number_of_peaks_in_window = 0;
244 auto itbegin = data_points.begin();
245 std::vector<DataPoint>::iterator it_min;
246
247
248 // std::sort(data_points.begin(),
249 // data_points.end(),
250 // [](const DataPoint &a, const DataPoint &b) { return (a.y > b.y);
251 // });
252
253 qDebug() << " m_xWindowRange=" << m_xWindowRange
254 << " m_numberOfPoints=" << m_numberOfPoints;
255 for(const pappso::DataPoint &data_point : new_trace)
256 {
257 qDebug() << " data_point.x=" << data_point.x
258 << " data_point.y=" << data_point.y;
259 window_number = trunc(data_point.x / m_xWindowRange);
260 qDebug() << window_number;
261 if(window_number != old_window_number)
262 {
263 old_window_number = window_number;
264 number_of_peaks_in_window = 0;
265 itbegin = data_points.end();
266 }
267 if(number_of_peaks_in_window < m_numberOfPoints)
268 {
269 qDebug();
270 data_points.push_back(data_point);
271 number_of_peaks_in_window++;
272 if(number_of_peaks_in_window == 1)
273 {
274 itbegin = data_points.begin() + (data_points.size() - 1);
275 }
276 }
277 else
278 {
279 qDebug();
280
281 it_min = minYDataPoint(itbegin, data_points.end());
282 if(it_min != data_points.end())
283 {
284 qDebug();
285 if(it_min->y < data_point.y)
286 {
287 qDebug();
288 *it_min = data_point;
289 // it_min->x = data_point.x;
290 // it_min->y = data_point.y;
291 }
292 }
293 }
294 }
295 qDebug();
296 // new_trace.sortX();
297 // qDebug() << new_trace.size();
298 // data_points.clear();
299 // data_points = new_trace;
300 // data_points = std::move(new_trace);
301 // qDebug() << data_points.size();
302 data_points.sortX();
303 qDebug();
304 return data_points;
305}
306
307std::size_t
312
313
317FilterFloorY::FilterFloorY([[maybe_unused]] const FilterFloorY &other)
318{
319}
320
322FilterFloorY::operator=([[maybe_unused]] const FilterFloorY &other)
323{
324 return *this;
325}
326
327
328Trace &
329FilterFloorY::filter(Trace &data_points) const
330{
331 for(auto &&dataPoint : data_points)
332 {
333 dataPoint.y = std::floor(dataPoint.y);
334 }
335 return data_points;
336}
337
338
342FilterRoundY::FilterRoundY([[maybe_unused]] const FilterRoundY &other)
343{
344}
345
347FilterRoundY::operator=([[maybe_unused]] const FilterRoundY &other)
348{
349 return *this;
350}
351
352Trace &
353FilterRoundY::filter(Trace &data_points) const
354{
355 for(auto &&dataPoint : data_points)
356 {
357 dataPoint.y = std::round(dataPoint.y);
358 }
359 return data_points;
360}
361
362
363FilterRescaleY::FilterRescaleY(double dynamic) : m_dynamic(dynamic)
364{
365}
367 : m_dynamic(other.m_dynamic)
368{
369}
370Trace &
371FilterRescaleY::filter(Trace &data_points) const
372{
373 if(m_dynamic == 0)
374 return data_points;
375 auto it_max = maxYDataPoint(data_points.begin(), data_points.end());
376 if(it_max == data_points.end())
377 return data_points;
378 double maximum = it_max->y;
379 for(auto &&dataPoint : data_points)
380 {
381 dataPoint.y = (dataPoint.y / maximum) * m_dynamic;
382 }
383 return data_points;
384}
385
388{
389 m_dynamic = other.m_dynamic;
390
391 return *this;
392}
393
394
395double
397{
398 return m_dynamic;
399}
400
401
403 std::size_t number_of_points)
404 : m_filterGreatestY(number_of_points)
405{
406}
407
410 : m_filterGreatestY(other.m_filterGreatestY)
411{
412}
413
422
423
426{
427 m_filterGreatestY.filter(spectrum);
428 return spectrum;
429}
430
431
432FilterScaleFactorY::FilterScaleFactorY(double dynamic) : m_factor(dynamic)
433{
434}
436 : m_factor(other.m_factor)
437{
438}
439
442{
443 m_factor = other.m_factor;
444
445 return *this;
446}
447
448
449Trace &
451{
452 if(m_factor == 1)
453 return data_points;
454 for(auto &&dataPoint : data_points)
455 {
456 dataPoint.y = dataPoint.y * m_factor;
457 }
458 return data_points;
459}
460double
462{
463 return m_factor;
464}
465
466FilterRemoveY::FilterRemoveY(double valueToRemove)
467 : m_valueToRemove(valueToRemove)
468{
469}
470
472 : m_valueToRemove(other.m_valueToRemove)
473{
474}
475
478{
480 return *this;
481}
482
483double
485{
486 return m_valueToRemove;
487}
488
489Trace &
490FilterRemoveY::filter(Trace &data_points) const
491{
492 for(auto &&dataPoint : data_points)
493 {
494 if(dataPoint.y < m_valueToRemove)
495 dataPoint.y = 0;
496 else
497 dataPoint.y = dataPoint.y - m_valueToRemove;
498 }
499 return data_points;
500}
501
502
504 : m_quantile(quantile)
505{
506}
507
509 const FilterQuantileBasedRemoveY &other)
510 : m_quantile(other.m_quantile)
511{
512}
513
516{
517 m_quantile = other.m_quantile;
518 return *this;
519}
520
521double
526
527Trace &
529{
530
531 if(data_points.size() == 0)
532 return data_points;
533 double value_to_temove =
534 quantileYTrace(data_points.begin(), data_points.end(), m_quantile);
535 for(auto &&dataPoint : data_points)
536 {
537 if(dataPoint.y < value_to_temove)
538 dataPoint.y = 0;
539 else
540 dataPoint.y = dataPoint.y - value_to_temove;
541 }
542 return data_points;
543}
544
546 const QString &strBuildParams)
547{
548 buildFilterFromString(strBuildParams);
549}
550
551
552void
554 const QString &strBuildParams)
555{
556 //"passQuantileBasedRemoveY|0.6"
557 qDebug();
558 if(strBuildParams.startsWith("passQuantileBasedRemoveY|"))
559 {
560 QStringList params =
561 strBuildParams.split("|").back().split(";", Qt::SkipEmptyParts);
562
563 QString value = params.at(0);
564 m_quantile = value.toDouble();
565 }
566 else
567 {
569 QString(
570 "building passQuantileBasedRemoveY from string %1 is not possible")
571 .arg(strBuildParams));
572 }
573 qDebug();
574}
575
576
577QString
579{
580 return "passQuantileBasedRemoveY";
581}
582
583
584QString
586{
587 QString strCode = QString("%1|%2").arg(name()).arg(m_quantile);
588
589 return strCode;
590}
excetion to use when an item type is not recognized
apply std::floor (round to lowest integer) to all Y values
Definition filterpass.h:166
FilterFloorY & operator=(const FilterFloorY &other)
Trace & filter(Trace &data_points) const override
keep N datapoints form the greatest intensities to the lowest
Definition filterpass.h:96
Trace & filter(Trace &data_points) const override
FilterGreatestY(std::size_t number_of_points=0)
constructor with the number of datapoints to keep
FilterGreatestY & operator=(const FilterGreatestY &other)
std::size_t getNumberOfPoints() const
std::size_t m_numberOfPoints
Definition filterpass.h:114
keep N datapoints form the greatest intensities to the lowest within a mass range in dalton
Definition filterpass.h:122
Trace & filter(Trace &data_points) const override
FilterGreatestYperWindow(double window_range, std::size_t number_of_points_per_window)
constructor with the number of datapoints to keep
FilterGreatestYperWindow & operator=(const FilterGreatestYperWindow &other)
std::size_t getNumberOfPoints() const
remove datapoints below a given intensity percentage (ratio) of the maximum intensity
Definition filterpass.h:76
FilterHighPassPercentage(double y_ratio)
Trace & filter(Trace &data_points) const override
FilterHighPassPercentage & operator=(const FilterHighPassPercentage &other)
remove datapoints below a given Y value (intensity)
Definition filterpass.h:58
Trace & filter(Trace &data_points) const override
FilterHighPass & operator=(const FilterHighPass &other)
FilterHighPass(double pass_y)
remove datapoints higher than a given Y value (intensity)
Definition filterpass.h:41
FilterLowPass(double pass_y)
Trace & filter(Trace &data_points) const override
FilterLowPass & operator=(const FilterLowPass &other)
removes a value found by quantile to all Y values
Definition filterpass.h:258
FilterQuantileBasedRemoveY & operator=(const FilterQuantileBasedRemoveY &other)
FilterQuantileBasedRemoveY(double quantile_threshold)
void buildFilterFromString(const QString &strBuildParams) override
build this filter using a string
Trace & filter(Trace &data_points) const override
QString toString() const override
virtual QString name() const override
removes a value to all Y values
Definition filterpass.h:235
FilterRemoveY(double valueToRemove)
double getValue() const
Trace & filter(Trace &data_points) const override
FilterRemoveY & operator=(const FilterRemoveY &other)
rescales Y values into a dynamic range if the dynamic range is set to 0, this filter is ignored
Definition filterpass.h:196
Trace & filter(Trace &data_points) const override
FilterRescaleY(double dynamic)
double getDynamicRange() const
FilterRescaleY & operator=(const FilterRescaleY &other)
apply std::round (round to nearest integer) to all Y values
Definition filterpass.h:181
Trace & filter(Trace &data_points) const override
FilterRoundY & operator=(const FilterRoundY &other)
rescales Y values given a tranformation factor
Definition filterpass.h:215
FilterScaleFactorY & operator=(const FilterScaleFactorY &other)
FilterScaleFactorY(double m_factor)
Trace & filter(Trace &data_points) const override
double getScaleFactorY() const
MassSpectrumFilterGreatestItensities(std::size_t number_of_points=0)
MassSpectrum & filter(MassSpectrum &spectrum) const override
MassSpectrumFilterGreatestItensities & operator=(const MassSpectrumFilterGreatestItensities &other)
Class to represent a mass spectrum.
A simple container of DataPoint instances.
Definition trace.h:148
void sortX(SortOrder sort_order=SortOrder::ascending)
Definition trace.cpp:1086
excetion to use when an item type is not recognized (file format, object type...)
basic mass spectrum
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition aa.cpp:39
std::vector< DataPoint >::const_iterator maxYDataPoint(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end)
Definition trace.cpp:180
std::vector< DataPoint >::const_iterator minYDataPoint(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end)
Definition trace.cpp:158
double quantileYTrace(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end, double quantile)
calculate the quantile of y value of a trace
Definition trace.cpp:265