LayerStatistics.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2022.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $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