LayerStatistics.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Chris Bielow $
// $Authors: Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
// OpenMS_GUI config
#include <OpenMS/VISUAL/OpenMS_GUIConfig.h>
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/KERNEL/StandardTypes.h>
#include <OpenMS/MATH/STATISTICS/Histogram.h>
#include <OpenMS/VISUAL/INTERFACES/IPeptideIds.h>
 
#include <array>
#include <map>
#include <string>
#include <variant>
 
namespace OpenMS
{
  class MetaInfoInterface;
  class ConsensusMap;
  class FeatureMap;
  
  template <typename VALUE_TYPE>
  struct RangeStats
  {
    public:  
      void addDataPoint(VALUE_TYPE v)
      {
        ++count_;
        sum_ += v;
        min_ = std::min(min_, v);
        max_ = std::max(max_, v);
      }
 
      VALUE_TYPE getMin() const
      {
        return min_;
      }
 
      VALUE_TYPE getMax() const
      {
        return max_;
      }
 
      size_t getCount() const
      {
        return count_;
      }
 
      double getAvg() const
      {
        return count_ == 0 ? 0 : double(sum_) / count_;
      }
 
    protected:
      size_t count_{0};
      VALUE_TYPE min_{std::numeric_limits<VALUE_TYPE>::max()}; // init with very high value 
      VALUE_TYPE max_{std::numeric_limits<VALUE_TYPE>::lowest()}; // init with lowest (=negative) value possible
      VALUE_TYPE sum_{0};
  };
 
  using RangeStatsInt = RangeStats<int>;
  using RangeStatsDouble = RangeStats<double>;
  using RangeStatsVariant = std::variant<RangeStatsInt, RangeStatsDouble>;
 
  struct StatsCounter
  {
    size_t counter{0};
  };
 
  enum class RangeStatsSource
  {
    CORE,  
    METAINFO, 
    ARRAYINFO,  
    SIZE_OF_STATSSOURCE
  };
  
  static const std::array<const char*, (size_t)RangeStatsSource::SIZE_OF_STATSSOURCE> StatsSourceNames = {"core statistics", "meta values", "data arrays"};
 
  struct RangeStatsType
  {
    RangeStatsSource src;
    std::string name;
 
    bool operator<(const RangeStatsType& rhs) const
    {
      return std::tie(src, name) < std::tie(rhs.src, rhs.name);
    }
 
    bool operator==(const RangeStatsType& rhs) const
    {
      return src == rhs.src && name == rhs.name;
    }
  };
 
  using StatsMap = std::map<RangeStatsType, RangeStatsVariant>;
  using StatsCounterMap = std::map<std::string, StatsCounter>;
 
  class OPENMS_GUI_DLLAPI LayerStatistics
  {
  public:
 
    virtual ~LayerStatistics() = default;
 
    const StatsMap& getRangeStatistics() const
    {
      return overview_range_data_;
    }
 
    const StatsCounterMap& getCountStatistics() const
    {
      return overview_count_data_;
    }
 
    virtual Math::Histogram<> getDistribution(const RangeStatsType& which, const UInt number_of_bins = 500) const = 0;
 
 
  protected:
    virtual void computeStatistics_() = 0;
    void bringInMetaStats_(const MetaInfoInterface* meta_interface);
 
    StatsMap overview_range_data_; 
    StatsCounterMap overview_count_data_; 
  };
 
  class OPENMS_GUI_DLLAPI LayerStatisticsPeakMap
   : public LayerStatistics
  {
  public:
    LayerStatisticsPeakMap(const PeakMap& pm);
 
    Math::Histogram<> getDistribution(const RangeStatsType& which, const UInt number_of_bins) const override;
 
  private:
    void computeStatistics_() override;
    const PeakMap* pm_; 
  };
 
  class OPENMS_GUI_DLLAPI LayerStatisticsFeatureMap : public LayerStatistics
  {
  public:
    LayerStatisticsFeatureMap(const FeatureMap& fm);
 
    Math::Histogram<> getDistribution(const RangeStatsType& which,
                                      const UInt number_of_bins) const override;
 
  private:
    void computeStatistics_() override;
    const FeatureMap* fm_; 
  };
 
  class OPENMS_GUI_DLLAPI LayerStatisticsConsensusMap : public LayerStatistics
  {
  public:
    LayerStatisticsConsensusMap(const ConsensusMap& cm);
 
    Math::Histogram<> getDistribution(const RangeStatsType& which,
                                      const UInt number_of_bins) const override;
 
  private:
    void computeStatistics_() override;
    const ConsensusMap* cm_; 
  };
 
  class OPENMS_GUI_DLLAPI LayerStatisticsIdent : public LayerStatistics
  {
  public:
    LayerStatisticsIdent(const IPeptideIds::PepIds& cm);
 
    Math::Histogram<> getDistribution(const RangeStatsType& which,
                                      const UInt number_of_bins) const override;
 
  private:
    void computeStatistics_() override;
    const IPeptideIds::PepIds* ids_; 
  };
  
} // namespace OpenMS