35 #ifndef OPENMS_FILTERING_BASELINE_MORPHOLOGICALFILTER_H 
   36 #define OPENMS_FILTERING_BASELINE_MORPHOLOGICALFILTER_H 
   57     template <
typename IteratorT>
 
   59       public std::iterator<std::forward_iterator_tag, typename IteratorT::value_type::IntensityType>
 
   62       typedef typename IteratorT::value_type::IntensityType 
value_type;
 
   63       typedef typename IteratorT::value_type::IntensityType & 
reference;
 
   64       typedef typename IteratorT::value_type::IntensityType * 
pointer;
 
   74         return base->getIntensity();
 
   77       template <
typename IndexT>
 
   80         return base[index].getIntensity();
 
   96         IteratorT tmp = *
this;
 
  116     template <
typename IteratorT>
 
  169       struct_size_in_datapoints_(0)
 
  172       defaults_.setValue(
"struc_elem_length", 3.0, 
"Length of the structuring element. This should be wider than the expected peak width.");
 
  173       defaults_.setValue(
"struc_elem_unit", 
"Thomson", 
"The unit of the 'struct_elem_length'.");
 
  174       defaults_.setValidStrings(
"struc_elem_unit", 
StringList::create(
"Thomson,DataPoints"));
 
  176       defaults_.setValue(
"method", 
"tophat", 
"Method to use, the default is 'tophat'.  Do not change this unless you know what you are doing.  The other methods may be useful for tuning the parameters, see the class documentation of MorpthologicalFilter.");
 
  177       defaults_.setValidStrings(
"method", 
StringList::create(
"identity,erosion,dilation,opening,closing,gradient,tophat,bothat,erosion_simple,dilation_simple"));
 
  198     template <
typename InputIterator, 
typename OutputIterator>
 
  199     void filterRange(InputIterator input_begin, InputIterator input_end, OutputIterator output_begin)
 
  202       static std::vector<typename InputIterator::value_type> buffer;
 
  203       const UInt size = input_end - input_begin;
 
  206       if (struct_size_in_datapoints_ == 0)
 
  208         struct_size_in_datapoints_ = (
UInt)(
DoubleReal)param_.getValue(
"struc_elem_length");
 
  212       String method = param_.getValue(
"method");
 
  213       if (method == 
"identity")
 
  215         std::copy(input_begin, input_end, output_begin);
 
  217       else if (method == 
"erosion")
 
  219         applyErosion_(struct_size_in_datapoints_, input_begin, input_end, output_begin);
 
  221       else if (method == 
"dilation")
 
  223         applyDilation_(struct_size_in_datapoints_, input_begin, input_end, output_begin);
 
  225       else if (method == 
"opening")
 
  227         if (buffer.size() < size) buffer.resize(size);
 
  228         applyErosion_(struct_size_in_datapoints_, input_begin, input_end, buffer.begin());
 
  229         applyDilation_(struct_size_in_datapoints_, buffer.begin(), buffer.begin() + size, output_begin);
 
  231       else if (method == 
"closing")
 
  233         if (buffer.size() < size) buffer.resize(size);
 
  234         applyDilation_(struct_size_in_datapoints_, input_begin, input_end, buffer.begin());
 
  235         applyErosion_(struct_size_in_datapoints_, buffer.begin(), buffer.begin() + size, output_begin);
 
  237       else if (method == 
"gradient")
 
  239         if (buffer.size() < size) buffer.resize(size);
 
  240         applyErosion_(struct_size_in_datapoints_, input_begin, input_end, buffer.begin());
 
  241         applyDilation_(struct_size_in_datapoints_, input_begin, input_end, output_begin);
 
  242         for (
UInt i = 0; i < size; ++i) output_begin[i] -= buffer[i];
 
  244       else if (method == 
"tophat")
 
  246         if (buffer.size() < size) buffer.resize(size);
 
  247         applyErosion_(struct_size_in_datapoints_, input_begin, input_end, buffer.begin());
 
  248         applyDilation_(struct_size_in_datapoints_, buffer.begin(), buffer.begin() + size, output_begin);
 
  249         for (
UInt i = 0; i < size; ++i) output_begin[i] = input_begin[i] - output_begin[i];
 
  251       else if (method == 
"bothat")
 
  253         if (buffer.size() < size) buffer.resize(size);
 
  254         applyDilation_(struct_size_in_datapoints_, input_begin, input_end, buffer.begin());
 
  255         applyErosion_(struct_size_in_datapoints_, buffer.begin(), buffer.begin() + size, output_begin);
 
  256         for (
UInt i = 0; i < size; ++i) output_begin[i] = input_begin[i] - output_begin[i];
 
  258       else if (method == 
"erosion_simple")
 
  260         applyErosionSimple_(struct_size_in_datapoints_, input_begin, input_end, output_begin);
 
  262       else if (method == 
"dilation_simple")
 
  264         applyDilationSimple_(struct_size_in_datapoints_, input_begin, input_end, output_begin);
 
  267       struct_size_in_datapoints_ = 0;
 
  284     template <
typename PeakType>
 
  291       if (spectrum.size() <= 1) 
return;
 
  294       if ((
String)(param_.getValue(
"struc_elem_unit")) == 
"Thomson")
 
  296         struct_size_in_datapoints_ =
 
  299               (
DoubleReal)(param_.getValue(
"struc_elem_length"))
 
  303               (spectrum.back().getMZ() - spectrum.begin()->getMZ())
 
  309         struct_size_in_datapoints_ = (
UInt)(
DoubleReal)param_.getValue(
"struc_elem_length");
 
  312       if (!
Math::isOdd(struct_size_in_datapoints_)) ++struct_size_in_datapoints_;
 
  315       std::vector<typename PeakType::IntensityType> output(spectrum.size());
 
  322       for (
Size i = 0; i < spectrum.size(); ++i)
 
  324         spectrum[i].setIntensity(output[i]);
 
  334     template <
typename PeakType>
 
  337       startProgress(0, exp.
size(), 
"filtering baseline");
 
  338       for (
UInt i = 0; i < exp.
size(); ++i)
 
  355     template <
typename InputIterator, 
typename OutputIterator>
 
  356     void applyErosion_(
Int struc_size, InputIterator input, InputIterator input_end, OutputIterator output)
 
  358       typedef typename InputIterator::value_type ValueType;
 
  359       const Int size = input_end - input;
 
  360       const Int struc_size_half = struc_size / 2;           
 
  362       static std::vector<ValueType> buffer;
 
  363       if (
Int(buffer.size()) < struc_size) buffer.resize(struc_size);
 
  372       if (size <= struc_size || size <= 5)
 
  374         applyErosionSimple_(struc_size, input, input_end, output);
 
  380         for (++ii; ii < struc_size_half; ++ii) if (current > input[ii]) current = input[ii];
 
  381         for (; ii < std::min(
Int(struc_size), size); ++ii, ++oi)
 
  383           if (current > input[ii]) current = input[ii];
 
  384           output[oi] = current;
 
  389         for (anchor = struc_size;
 
  390              anchor <= size - struc_size;
 
  397           for (i = 1; i < struc_size; ++i, ++ii)
 
  399             if (current > input[ii]) current = input[ii];
 
  403           oi = ii + struc_size_half;
 
  405           for (i = 1; i < struc_size; ++i, --ii, --oi)
 
  407             if (current > input[ii]) current = input[ii];
 
  408             output[oi] = std::min(buffer[struc_size - i], current);
 
  410           if (current > input[ii]) current = input[ii];
 
  411           output[oi] = current;
 
  419         for (--ii; ii >= size - struc_size_half; --ii) 
if (current > input[ii]) current = input[ii];
 
  420         for (; ii >= std::max(size - 
Int(struc_size), 0); --ii, --oi)
 
  422           if (current > input[ii]) current = input[ii];
 
  423           output[oi] = current;
 
  425         anchor = size - struc_size;
 
  429         for (i = 1; i < struc_size; ++i, ++ii)
 
  431           if (current > input[ii]) current = input[ii];
 
  435         oi = ii + struc_size_half;
 
  437         for (i = 1; (ii >= 0) && (i < struc_size); ++i, --ii, --oi)
 
  439           if (current > input[ii]) current = input[ii];
 
  440           output[oi] = std::min(buffer[struc_size - i], current);
 
  444           if (current > input[ii]) current = input[ii];
 
  445           output[oi] = current;
 
  455     template <
typename InputIterator, 
typename OutputIterator>
 
  456     void applyDilation_(
Int struc_size, InputIterator input, InputIterator input_end, OutputIterator output)
 
  458       typedef typename InputIterator::value_type ValueType;
 
  459       const Int size = input_end - input;
 
  460       const Int struc_size_half = struc_size / 2;           
 
  462       static std::vector<ValueType> buffer;
 
  463       if (
Int(buffer.size()) < struc_size) buffer.resize(struc_size);
 
  472       if (size <= struc_size || size <= 5)
 
  474         applyDilationSimple_(struc_size, input, input_end, output);
 
  480         for (++ii; ii < struc_size_half; ++ii) 
if (current < input[ii]) current = input[ii];
 
  481         for (; ii < std::min(
Int(struc_size), size); ++ii, ++oi)
 
  483           if (current < input[ii]) current = input[ii];
 
  484           output[oi] = current;
 
  489         for (anchor = struc_size;
 
  490              anchor <= size - struc_size;
 
  497           for (i = 1; i < struc_size; ++i, ++ii)
 
  499             if (current < input[ii]) current = input[ii];
 
  503           oi = ii + struc_size_half;
 
  505           for (i = 1; i < struc_size; ++i, --ii, --oi)
 
  507             if (current < input[ii]) current = input[ii];
 
  508             output[oi] = std::max(buffer[struc_size - i], current);
 
  510           if (current < input[ii]) current = input[ii];
 
  511           output[oi] = current;
 
  519         for (--ii; ii >= size - struc_size_half; --ii) 
if (current < input[ii]) current = input[ii];
 
  520         for (; ii >= std::max(size - 
Int(struc_size), 0); --ii, --oi)
 
  522           if (current < input[ii]) current = input[ii];
 
  523           output[oi] = current;
 
  525         anchor = size - struc_size;
 
  529         for (i = 1; i < struc_size; ++i, ++ii)
 
  531           if (current < input[ii]) current = input[ii];
 
  535         oi = ii + struc_size_half;
 
  537         for (i = 1; (ii >= 0) && (i < struc_size); ++i, --ii, --oi)
 
  539           if (current < input[ii]) current = input[ii];
 
  540           output[oi] = std::max(buffer[struc_size - i], current);
 
  544           if (current < input[ii]) current = input[ii];
 
  545           output[oi] = current;
 
  552     template <
typename InputIterator, 
typename OutputIterator>
 
  553     void applyErosionSimple_(
Int struc_size, InputIterator input_begin, InputIterator input_end, OutputIterator output_begin)
 
  555       typedef typename InputIterator::value_type ValueType;
 
  556       const int size = input_end - input_begin;
 
  557       const Int struc_size_half = struc_size / 2;           
 
  558       for (
Int index = 0; index < size; ++index)
 
  560         Int start = std::max(0, index - struc_size_half);
 
  561         Int stop  = std::min(size - 1, index + struc_size_half);
 
  562         ValueType value = input_begin[start];
 
  563         for (
Int i = start + 1; i <= stop; ++i) if (value > input_begin[i]) value = input_begin[i];
 
  564         output_begin[index] = value;
 
  570     template <
typename InputIterator, 
typename OutputIterator>
 
  573       typedef typename InputIterator::value_type ValueType;
 
  574       const int size = input_end - input_begin;
 
  575       const Int struc_size_half = struc_size / 2;           
 
  576       for (
Int index = 0; index < size; ++index)
 
  578         Int start = std::max(0, index - struc_size_half);
 
  579         Int stop   = std::min(size - 1, index + struc_size_half);
 
  580         ValueType value = input_begin[start];
 
  581         for (
Int i = start + 1; i <= stop; ++i) 
if (value < input_begin[i]) value = input_begin[i];
 
  582         output_begin[index] = value;
 
UInt struct_size_in_datapoints_
Member for struct size in data points. 
Definition: MorphologicalFilter.h:349
This class implements baseline filtering operations using methods from mathematical morphology...
Definition: MorphologicalFilter.h:159
bool isOdd(UInt x)
Returns true if the given interger is odd. 
Definition: MathFunctions.h:124
IntensityIteratorWrapper< IteratorT > intensityIteratorWrapper(const IteratorT &rhs)
make-function so that we need no write out all those type names to get the wrapped iterator...
Definition: MorphologicalFilter.h:117
void applyDilation_(Int struc_size, InputIterator input, InputIterator input_end, OutputIterator output)
Applies dilation. This implementation uses van Herk's method. Only 3 min/max comparisons are required...
Definition: MorphologicalFilter.h:456
IntensityIteratorWrapper(const IteratorT &rhs)
Definition: MorphologicalFilter.h:67
An iterator wrapper to access peak intensities instead of the peak itself. 
Definition: MorphologicalFilter.h:58
value_type operator[](const IndexT &index)
Definition: MorphologicalFilter.h:78
A more convenient string class. 
Definition: String.h:56
IteratorT::difference_type difference_type
Definition: MorphologicalFilter.h:65
Size size() const 
Definition: MSExperiment.h:117
bool operator==(const IntensityIteratorWrapper &rhs) const 
Definition: MorphologicalFilter.h:101
MorphologicalFilter()
Constructor. 
Definition: MorphologicalFilter.h:166
void filterRange(InputIterator input_begin, InputIterator input_end, OutputIterator output_begin)
Applies the morphological filtering operation to an iterator range. 
Definition: MorphologicalFilter.h:199
IntensityIteratorWrapper & operator++()
Definition: MorphologicalFilter.h:88
IteratorT base
Definition: MorphologicalFilter.h:112
unsigned int UInt
Unsigned integer type. 
Definition: Types.h:92
virtual ~MorphologicalFilter()
Destructor. 
Definition: MorphologicalFilter.h:183
bool operator!=(const IntensityIteratorWrapper &rhs) const 
Definition: MorphologicalFilter.h:106
Raw data (also called profile data) 
Definition: SpectrumSettings.h:75
void filter(MSSpectrum< PeakType > &spectrum)
Applies the morphological filtering operation to an MSSpectrum. 
Definition: MorphologicalFilter.h:285
static StringList create(const String &list, const char splitter= ',')
Returns a list that is created by splitting the given (comma-separated) string (String are not trimme...
void filterExperiment(MSExperiment< PeakType > &exp)
Applies the morphological filtering operation to an MSExperiment. 
Definition: MorphologicalFilter.h:335
difference_type operator-(IntensityIteratorWrapper &rhs) const 
Definition: MorphologicalFilter.h:83
Representation of a mass spectrometry experiment. 
Definition: MSExperiment.h:68
void applyDilationSimple_(Int struc_size, InputIterator input_begin, InputIterator input_end, OutputIterator output_begin)
Applies dilation. Simple implementation, possibly faster if struc_size is very small, and used in some special cases. 
Definition: MorphologicalFilter.h:571
void setType(SpectrumType type)
sets the spectrum type 
void applyErosion_(Int struc_size, InputIterator input, InputIterator input_end, OutputIterator output)
Applies erosion. This implementation uses van Herk's method. Only 3 min/max comparisons are required ...
Definition: MorphologicalFilter.h:356
size_t Size
Size type e.g. used as variable which can hold result of size() 
Definition: Types.h:144
Base class for all classes that want to report their progess. 
Definition: ProgressLogger.h:56
IteratorT::value_type::IntensityType & reference
Definition: MorphologicalFilter.h:63
A base class for all classes handling default parameters. 
Definition: DefaultParamHandler.h:90
IteratorT::value_type::IntensityType * pointer
Definition: MorphologicalFilter.h:64
void applyErosionSimple_(Int struc_size, InputIterator input_begin, InputIterator input_end, OutputIterator output_begin)
Applies erosion. Simple implementation, possibly faster if struc_size is very small, and used in some special cases. 
Definition: MorphologicalFilter.h:553
int Int
Signed integer type. 
Definition: Types.h:100
IteratorT::value_type::IntensityType value_type
Definition: MorphologicalFilter.h:62
IntensityIteratorWrapper operator++(int)
Definition: MorphologicalFilter.h:94
value_type operator*()
Definition: MorphologicalFilter.h:72
double DoubleReal
Double-precision real type. 
Definition: Types.h:118