libpappsomspp
Library for mass spectrometry
filtermorpho.cpp
Go to the documentation of this file.
1 /**
2  * \file pappsomspp/filers/filtermorpho.cpp
3  * \date 02/05/2019
4  * \author Olivier Langella
5  * \brief collection of morphological filters
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 "filtermorpho.h"
29 #include "../../trace/trace.h"
30 #include <QDebug>
31 #include "../../exception/exceptionoutofrange.h"
32 
33 using namespace pappso;
34 
36  : m_halfWindowSize(half_window_size)
37 {
38 }
40  const FilterMorphoWindowBase &other)
41  : m_halfWindowSize(other.m_halfWindowSize)
42 {
43 }
44 std::size_t
46 {
47  return m_halfWindowSize;
48 }
49 
52 {
54 
55  return *this;
56 }
57 
58 
59 Trace &
61 {
62 
63  qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__ << " "
64  << m_halfWindowSize << " data_points.size()" << data_points.size();
65  if(m_halfWindowSize == 0)
66  return data_points;
67  Trace old_trace(data_points);
68  auto it = old_trace.begin();
69  auto itend = old_trace.end() - m_halfWindowSize - 1;
70  auto it_target = data_points.begin();
71 
72 
73  std::size_t loop_begin = 0;
74  while((it != itend) && (loop_begin < m_halfWindowSize))
75  {
76  // maxYDataPoint(it_begin, it + m_halfWindowSize + 1);
77  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__ << " "
78  // << it->x << " " << m_halfWindowSize;
79  // it_target->x = it->x;
80  it_target->y =
81  getWindowValue(old_trace.begin(), it + m_halfWindowSize + 1);
82  it++;
83  it_target++;
84  loop_begin++;
85  }
86  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
87  while(it != itend)
88  {
89  // it_target->x = it->x;
90  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__ << " "
91  // << it->x;
92  it_target->y =
94  it++;
95  it_target++;
96  }
97  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
98  while(it != old_trace.end())
99  {
100  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__ << " "
101  // << it->x;
102  // it_target->x = it->x;
103  it_target->y = getWindowValue(it - m_halfWindowSize, old_trace.end());
104  it++;
105  it_target++;
106  }
107  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
108  // problem with move or swap : this lead to segmentation faults in some cases
109  // data_points = std::move(new_trace);
110  qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
111  return data_points;
112 }
113 
114 FilterMorphoSum::FilterMorphoSum(std::size_t half_window_size)
115  : FilterMorphoWindowBase(half_window_size)
116 {
117 }
119  : FilterMorphoWindowBase(other.m_halfWindowSize)
120 {
121 }
122 
125 {
127 
128  return *this;
129 }
130 
131 double
133  std::vector<DataPoint>::const_iterator begin,
134  std::vector<DataPoint>::const_iterator end) const
135 {
136 
137  qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
138  return sumYTrace(begin, end, 0);
139 }
140 
141 FilterMorphoMax::FilterMorphoMax(std::size_t half_window_size)
142  : FilterMorphoWindowBase(half_window_size)
143 {
144 }
146  : FilterMorphoWindowBase(other.m_halfWindowSize)
147 {
148 }
149 
152 {
154 
155  return *this;
156 }
157 
158 double
160  std::vector<DataPoint>::const_iterator begin,
161  std::vector<DataPoint>::const_iterator end) const
162 {
163 
164  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
165  return maxYDataPoint(begin, end)->y;
166 }
167 
168 std::size_t
170 {
171  return m_halfWindowSize;
172 }
173 
174 FilterMorphoMin::FilterMorphoMin(std::size_t half_window_size)
175  : FilterMorphoWindowBase(half_window_size)
176 {
177 }
179  : FilterMorphoWindowBase(other.m_halfWindowSize)
180 {
181 }
182 
185 {
187 
188  return *this;
189 }
190 
191 double
193  std::vector<DataPoint>::const_iterator begin,
194  std::vector<DataPoint>::const_iterator end) const
195 {
196  return minYDataPoint(begin, end)->y;
197 }
198 
199 std::size_t
201 {
202  return m_halfWindowSize;
203 }
204 
205 FilterMorphoMinMax::FilterMorphoMinMax(std::size_t half_window_size)
206  : m_filterMax(half_window_size), m_filterMin(half_window_size)
207 {
208 }
210  : m_filterMax(other.m_filterMax), m_filterMin(other.m_filterMin)
211 {
212 }
213 
216 {
217  m_filterMax = other.m_filterMax;
218  m_filterMin = other.m_filterMin;
219 
220  return *this;
221 }
222 
223 Trace &
225 {
226  qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
227  m_filterMax.filter(data_points);
228  m_filterMin.filter(data_points);
229  qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
230  return data_points;
231 }
232 std::size_t
234 {
235  return ((FilterMorphoMax)m_filterMax).getMaxHalfEdgeWindows();
236 }
237 
238 
239 FilterMorphoMaxMin::FilterMorphoMaxMin(std::size_t half_window_size)
240  : m_filterMin(half_window_size), m_filterMax(half_window_size)
241 {
242 }
244  : m_filterMin(other.m_filterMin), m_filterMax(other.m_filterMax)
245 {
246 }
247 
250 {
251  m_filterMin = other.m_filterMin;
252  m_filterMax = other.m_filterMax;
253 
254  return *this;
255 }
256 
257 Trace &
259 {
260  qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
261  m_filterMin.filter(data_points);
262  m_filterMax.filter(data_points);
263  qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
264  return data_points;
265 }
266 std::size_t
268 {
269  return ((FilterMorphoMax)m_filterMax).getMaxHalfEdgeWindows();
270 }
271 
272 FilterMorphoAntiSpike::FilterMorphoAntiSpike(std::size_t half_window_size)
273  : m_halfWindowSize(half_window_size)
274 {
275 }
277  : m_halfWindowSize(other.m_halfWindowSize)
278 {
279 }
280 
283 {
285 
286  return *this;
287 }
288 
289 std::size_t
291 {
292  return m_halfWindowSize;
293 }
294 Trace &
296 {
297  if(m_halfWindowSize == 0)
298  return data_points;
299  Trace old_trace(data_points);
300  auto it = old_trace.begin();
301  auto it_target = data_points.begin();
302  auto itw = old_trace.begin();
303 
304  auto itend = old_trace.end() - m_halfWindowSize - 1;
305  // new_trace.reserve(data_points.size());
306 
307  while((it != old_trace.end()) &&
308  (std::distance(old_trace.begin(), it) < (int)m_halfWindowSize))
309  {
310  // no anti spike at the begining of the signal
311  it++;
312  it_target++;
313  }
314  while(it != itend)
315  {
316  auto itwend = it + m_halfWindowSize + 1;
317  itw = findDifferentYvalue(it - m_halfWindowSize, it + 1, 0);
318  if(itw == it)
319  {
320  itw = findDifferentYvalue(it + 1, itwend, 0);
321  if(itw == itwend)
322  {
323  it_target->y = 0;
324  }
325  }
326 
327  it++;
328  it_target++;
329  }
330 
331  return data_points;
332 }
333 
334 
335 FilterMorphoMedian::FilterMorphoMedian(std::size_t half_window_size)
336  : FilterMorphoWindowBase(half_window_size)
337 {
338 }
340  : FilterMorphoWindowBase(other.m_halfWindowSize)
341 {
342 }
343 
346 {
348 
349  return *this;
350 }
351 
352 double
354  std::vector<DataPoint>::const_iterator begin,
355  std::vector<DataPoint>::const_iterator end) const
356 {
357  return medianYTrace(begin, end);
358 }
359 
360 
361 FilterMorphoMean::FilterMorphoMean(std::size_t half_window_size)
362  : FilterMorphoWindowBase(half_window_size)
363 {
364 }
366  : FilterMorphoWindowBase(other.m_halfWindowSize)
367 {
368 }
369 
372 {
374 
375  return *this;
376 }
377 
378 std::size_t
380 {
381  return m_halfWindowSize;
382 }
383 
384 double
386  std::vector<DataPoint>::const_iterator begin,
387  std::vector<DataPoint>::const_iterator end) const
388 {
389  return meanYTrace(begin, end);
390 }
391 
392 
394  std::size_t median_half_window_size, std::size_t minmax_half_window_size)
395  : m_filterMorphoMedian(median_half_window_size),
396  m_filterMorphoMinMax(minmax_half_window_size)
397 {
398 }
399 
401  const FilterMorphoBackground &other)
402  : m_filterMorphoMedian(other.m_filterMorphoMedian),
403  m_filterMorphoMinMax(other.m_filterMorphoMinMax)
404 {
405 }
406 
409 {
412 
413  return *this;
414 }
415 
416 Trace &
418 {
419  m_filterMorphoMedian.filter(data_points);
420  m_filterMorphoMinMax.filter(data_points);
421 
422  // finally filter negative values
423  for(DataPoint &point : data_points)
424  {
425  if(point.y < 0)
426  {
427  point.y = 0;
428  }
429  }
430  return data_points;
431 }
432 const FilterMorphoMedian &
434 {
435  return m_filterMorphoMedian;
436 }
437 const FilterMorphoMinMax &
439 {
440  return m_filterMorphoMinMax;
441 }
pappso::FilterMorphoMinMax::FilterMorphoMinMax
FilterMorphoMinMax(std::size_t half_window_size)
Definition: filtermorpho.cpp:205
pappso::FilterMorphoMinMax::m_filterMax
FilterMorphoMax m_filterMax
Definition: filtermorpho.h:120
pappso::FilterMorphoWindowBase::FilterMorphoWindowBase
FilterMorphoWindowBase(std::size_t half_window_size)
Definition: filtermorpho.cpp:35
pappso::FilterMorphoMean::FilterMorphoMean
FilterMorphoMean(std::size_t half_window_size)
Definition: filtermorpho.cpp:361
pappso::FilterMorphoSum::getWindowValue
double getWindowValue(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end) const override
Definition: filtermorpho.cpp:132
pappso::FilterMorphoWindowBase::getWindowValue
virtual double getWindowValue(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end) const =0
pappso::FilterMorphoMaxMin::FilterMorphoMaxMin
FilterMorphoMaxMin(std::size_t half_window_size)
Definition: filtermorpho.cpp:239
pappso::FilterMorphoBackground::filter
Trace & filter(Trace &data_points) const override
Definition: filtermorpho.cpp:417
pappso::FilterMorphoMedian
median filter apply median of y values inside the window
Definition: filtermorpho.h:178
pappso::FilterMorphoMin::operator=
FilterMorphoMin & operator=(const FilterMorphoMin &other)
Definition: filtermorpho.cpp:184
pappso::FilterMorphoMax::operator=
FilterMorphoMax & operator=(const FilterMorphoMax &other)
Definition: filtermorpho.cpp:151
pappso::FilterMorphoMaxMin::operator=
FilterMorphoMaxMin & operator=(const FilterMorphoMaxMin &other)
Definition: filtermorpho.cpp:249
pappso::FilterMorphoWindowBase
base class that apply a signal treatment based on a window
Definition: filtermorpho.h:41
pappso::FilterMorphoSum::FilterMorphoSum
FilterMorphoSum(std::size_t half_window_size)
Definition: filtermorpho.cpp:114
pappso::FilterMorphoBackground::m_filterMorphoMedian
FilterMorphoMedian m_filterMorphoMedian
Definition: filtermorpho.h:218
pappso::FilterMorphoAntiSpike::FilterMorphoAntiSpike
FilterMorphoAntiSpike(std::size_t half_window_size)
Definition: filtermorpho.cpp:272
pappso
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition: aa.cpp:39
pappso::FilterMorphoSum::operator=
FilterMorphoSum & operator=(const FilterMorphoSum &other)
Definition: filtermorpho.cpp:124
pappso::FilterMorphoMax::getWindowValue
double getWindowValue(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end) const override
Definition: filtermorpho.cpp:159
pappso::FilterMorphoBackground::operator=
FilterMorphoBackground & operator=(const FilterMorphoBackground &other)
Definition: filtermorpho.cpp:408
pappso::FilterMorphoWindowBase::filter
virtual Trace & filter(Trace &data_points) const override
Definition: filtermorpho.cpp:60
pappso::FilterMorphoMedian::FilterMorphoMedian
FilterMorphoMedian(std::size_t half_window_size)
Definition: filtermorpho.cpp:335
pappso::FilterMorphoMin
transform the trace into its minimum over a window
Definition: filtermorpho.h:99
pappso::DataPoint
Definition: datapoint.h:21
pappso::FilterMorphoMax
transform the trace into its maximum over a window
Definition: filtermorpho.h:81
pappso::FilterMorphoMin::getWindowValue
double getWindowValue(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end) const override
Definition: filtermorpho.cpp:192
pappso::FilterMorphoAntiSpike::getHalfWindowSize
std::size_t getHalfWindowSize() const
Definition: filtermorpho.cpp:290
pappso::FilterMorphoMean::getWindowValue
double getWindowValue(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end) const override
Definition: filtermorpho.cpp:385
pappso::FilterMorphoMaxMin::m_filterMax
FilterMorphoMax m_filterMax
Definition: filtermorpho.h:141
pappso::FilterMorphoMinMax::operator=
FilterMorphoMinMax & operator=(const FilterMorphoMinMax &other)
Definition: filtermorpho.cpp:215
pappso::FilterMorphoMinMax::filter
Trace & filter(Trace &data_points) const override
Definition: filtermorpho.cpp:224
pappso::Trace
A simple container of DataPoint instances.
Definition: trace.h:132
pappso::sumYTrace
double sumYTrace(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end, double init)
calculate the sum of y value of a trace
Definition: trace.cpp:202
pappso::FilterMorphoMedian::getWindowValue
double getWindowValue(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end) const override
Definition: filtermorpho.cpp:353
pappso::FilterMorphoWindowBase::getHalfWindowSize
virtual std::size_t getHalfWindowSize() const
Definition: filtermorpho.cpp:45
pappso::FilterMorphoMax::getMaxHalfEdgeWindows
std::size_t getMaxHalfEdgeWindows() const
Definition: filtermorpho.cpp:169
pappso::FilterMorphoBackground::m_filterMorphoMinMax
FilterMorphoMinMax m_filterMorphoMinMax
Definition: filtermorpho.h:219
pappso::FilterMorphoMin::getMinHalfEdgeWindows
std::size_t getMinHalfEdgeWindows() const
Definition: filtermorpho.cpp:200
pappso::FilterMorphoMin::FilterMorphoMin
FilterMorphoMin(std::size_t half_window_size)
Definition: filtermorpho.cpp:174
pappso::FilterMorphoWindowBase::m_halfWindowSize
std::size_t m_halfWindowSize
Definition: filtermorpho.h:43
pappso::maxYDataPoint
std::vector< DataPoint >::const_iterator maxYDataPoint(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end)
Definition: trace.cpp:138
pappso::FilterMorphoMaxMin::filter
Trace & filter(Trace &data_points) const override
Definition: filtermorpho.cpp:258
pappso::FilterMorphoMaxMin::m_filterMin
FilterMorphoMin m_filterMin
Definition: filtermorpho.h:140
pappso::FilterMorphoMean::operator=
FilterMorphoMean & operator=(const FilterMorphoMean &other)
Definition: filtermorpho.cpp:371
pappso::FilterMorphoMax::FilterMorphoMax
FilterMorphoMax(std::size_t half_window_size)
Definition: filtermorpho.cpp:141
pappso::FilterMorphoMedian::operator=
FilterMorphoMedian & operator=(const FilterMorphoMedian &other)
Definition: filtermorpho.cpp:345
pappso::FilterMorphoMinMax::getMinMaxHalfEdgeWindows
std::size_t getMinMaxHalfEdgeWindows() const
Definition: filtermorpho.cpp:233
pappso::FilterMorphoAntiSpike::m_halfWindowSize
std::size_t m_halfWindowSize
Definition: filtermorpho.h:160
pappso::FilterMorphoMean
mean filter apply mean of y values inside the window : this results in a kind of smoothing
Definition: filtermorpho.h:197
pappso::findDifferentYvalue
std::vector< DataPoint >::iterator findDifferentYvalue(std::vector< DataPoint >::iterator begin, std::vector< DataPoint >::iterator end, const double &y_value)
find the first element in which Y is different of value
Definition: trace.cpp:87
pappso::FilterMorphoMinMax
transform the trace with the minimum of the maximum equivalent of the dilate filter for pictures
Definition: filtermorpho.h:118
filtermorpho.h
pappso::FilterMorphoBackground::FilterMorphoBackground
FilterMorphoBackground(std::size_t median_half_window_size, std::size_t minmax_half_window_size)
Definition: filtermorpho.cpp:393
pappso::FilterMorphoMaxMin::getMaxMinHalfEdgeWindows
std::size_t getMaxMinHalfEdgeWindows() const
Definition: filtermorpho.cpp:267
pappso::FilterMorphoAntiSpike::filter
Trace & filter(Trace &data_points) const override
Definition: filtermorpho.cpp:295
pappso::FilterMorphoSum
test purpose
Definition: filtermorpho.h:64
pappso::FilterMorphoWindowBase::operator=
FilterMorphoWindowBase & operator=(const FilterMorphoWindowBase &other)
Definition: filtermorpho.cpp:51
pappso::medianYTrace
double medianYTrace(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end)
calculate the median of y value of a trace
Definition: trace.cpp:222
pappso::FilterMorphoBackground::getFilterMorphoMedian
const FilterMorphoMedian & getFilterMorphoMedian() const
Definition: filtermorpho.cpp:433
pappso::meanYTrace
double meanYTrace(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end)
calculate the mean of y value of a trace
Definition: trace.cpp:211
pappso::FilterMorphoMean::getMeanHalfEdgeWindows
std::size_t getMeanHalfEdgeWindows() const
Definition: filtermorpho.cpp:379
pappso::minYDataPoint
std::vector< DataPoint >::const_iterator minYDataPoint(std::vector< DataPoint >::const_iterator begin, std::vector< DataPoint >::const_iterator end)
Definition: trace.cpp:116
pappso::FilterMorphoAntiSpike::operator=
FilterMorphoAntiSpike & operator=(const FilterMorphoAntiSpike &other)
Definition: filtermorpho.cpp:282
pappso::FilterMorphoMaxMin
transform the trace with the maximum of the minimum equivalent of the erode filter for pictures
Definition: filtermorpho.h:138
pappso::FilterMorphoBackground
compute background of a trace compute background noise on a trace
Definition: filtermorpho.h:216
pappso::FilterMorphoBackground::getFilterMorphoMinMax
const FilterMorphoMinMax & getFilterMorphoMinMax() const
Definition: filtermorpho.cpp:438
pappso::FilterMorphoAntiSpike
anti spike filter set to zero alone values inside the window
Definition: filtermorpho.h:158
pappso::FilterMorphoMinMax::m_filterMin
FilterMorphoMin m_filterMin
Definition: filtermorpho.h:121