DIntervalBase.h

Go to the documentation of this file.

// Copyright (c) 2002-2023, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Clemens Groepl, Marc Sturm $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/DPosition.h>
#include <OpenMS/CONCEPT/Types.h>
 
#include <utility>
 
namespace OpenMS
{
  namespace Internal
  {
    template <UInt D>
    class DIntervalBase
    {
public:
 
      enum {DIMENSION = D};
      typedef DPosition<D>                            PositionType;
      typedef typename PositionType::CoordinateType CoordinateType;
 
 
      DIntervalBase() :
        min_(PositionType::maxPositive()),
        max_(PositionType::minNegative())
      {
      }
 
      DIntervalBase(const DIntervalBase& rhs) :
        min_(rhs.min_),
        max_(rhs.max_)
      {
      }
 
      DIntervalBase(DIntervalBase&&) noexcept = default;
 
      DIntervalBase& operator=(const DIntervalBase& rhs)
      {
        min_ = rhs.min_;
        max_ = rhs.max_;
        return *this;
      }
 
      ~DIntervalBase()
      {
      }
 
      DIntervalBase(PositionType const& minimum, PositionType const& maximum) :
        min_(minimum),
        max_(maximum)
      {
        normalize_();
      }
 
 
 
      inline PositionType const& minPosition() const
      {
        return min_;
      }
 
      inline PositionType const& maxPosition() const
      {
        return max_;
      }
 
      void setMin(PositionType const& position)
      {
        min_ = position;
        for (UInt i = 0; i < DIMENSION; ++i)
        {
          if (min_[i] > max_[i]) max_[i] = min_[i];
        }
      }
 
      void setMax(PositionType const& position)
      {
        max_ = position;
        for (UInt i = 0; i < DIMENSION; ++i)
        {
          if (min_[i] > max_[i]) min_[i] = max_[i];
        }
      }
 
      void setMinMax(PositionType const& min, PositionType const& max)
      {
        min_ = min;
        max_ = max;
        normalize_();
      }
 
      template <UInt D2>
      void assign(const DIntervalBase<D2> rhs)
      {
        for (UInt i = 0; i < std::min(D, D2); ++i)
        {
          min_[i] = rhs.minPosition()[i];
          max_[i] = rhs.maxPosition()[i];
        }
      }
 
      //}@
 
      bool operator==(const DIntervalBase& rhs) const
      {
        return (min_ == rhs.min_) && (max_ == rhs.max_);
      }
 
      bool operator!=(const DIntervalBase& rhs) const
      {
        return !(operator==(rhs));
      }
 
      DIntervalBase operator+(const PositionType& point) const
      {
        DIntervalBase result(*this);
        result += point;
        return result;
      }
 
      DIntervalBase& operator+=(const PositionType& point)
      {
        this->min_ += point;
        this->max_ += point;
        return *this;
      }
 
      DIntervalBase operator-(const PositionType& point) const
      {
        DIntervalBase result(*this);
        result -= point;
        return result;
      }
 
      DIntervalBase& operator-=(const PositionType& point)
      {
        this->min_ -= point;
        this->max_ -= point;
        return *this;
      }
 
      inline void clear()
      {
        *this = empty;
      }
      
      bool isEmpty() const
      {
        return *this == empty;
      }
 
      bool isEmpty(UInt dim) const
      {
        return DIntervalBase<1>(std::make_pair(min_[dim], max_[dim])) == DIntervalBase<1>::empty;
      }
 
      void setDimMinMax(UInt dim, const DIntervalBase<1>& min_max)
      {
        min_[dim] = min_max.min_[0];
        max_[dim] = min_max.max_[0];
      }
 
      // make all other templates friends to allow accessing min_ and max_ in setDimMinMax 
      template<UInt> friend class DIntervalBase; 
 
 
 
      PositionType center() const
      {
        PositionType center(min_);
        center += max_;
        center /= 2;
        return center;
      }
 
      PositionType diagonal() const
      {
        return max_ - min_;
      }
 
      static DIntervalBase const empty;
      static DIntervalBase const zero;
 
      //}@
 
 
      inline CoordinateType minX() const
      {
        return min_[0];
      }
 
      inline CoordinateType minY() const
      {
        return min_[1];
      }
 
      inline CoordinateType maxX() const
      {
        return max_[0];
      }
 
      inline CoordinateType maxY() const
      {
        return max_[1];
      }
 
      void setMinX(CoordinateType const c)
      {
        min_[0] = c;
        if (min_[0] > max_[0]) max_[0] = min_[0];
      }
 
      void setMinY(CoordinateType const c)
      {
        min_[1] = c;
        if (min_[1] > max_[1]) max_[1] = min_[1];
      }
 
      void setMaxX(CoordinateType const c)
      {
        max_[0] = c;
        if (min_[0] > max_[0]) min_[0] = max_[0];
      }
 
      void setMaxY(CoordinateType const c)
      {
        max_[1] = c;
        if (min_[1] > max_[1]) min_[1] = max_[1];
      }
 
      inline CoordinateType width() const
      {
        return max_[0] - min_[0];
      }
 
      inline CoordinateType height() const
      {
        return max_[1] - min_[1];
      }
 
 
protected:
 
      PositionType min_;
 
      PositionType max_;
 
      void normalize_()
      {
        for (UInt i = 0; i < DIMENSION; ++i)
        {
          if (min_[i] > max_[i])
          {
            std::swap(min_[i], max_[i]);
          }
        }
      }
 
      DIntervalBase(const std::pair<PositionType, PositionType>& pair) :
        min_(pair.first),
        max_(pair.second)
      {
 
      }
 
    };
 
    template <UInt D>
    DIntervalBase<D> const DIntervalBase<D>::zero
      = DIntervalBase<D>(DIntervalBase<D>::PositionType::zero(), DIntervalBase<D>::PositionType::zero());
 
    template <UInt D>
    DIntervalBase<D> const DIntervalBase<D>::empty
      = DIntervalBase<D>(std::make_pair(DIntervalBase<D>::PositionType::maxPositive(), DIntervalBase<D>::PositionType::minNegative()));
 
    template <UInt D>
    std::ostream& operator<<(std::ostream& os, const DIntervalBase<D>& rhs)
    {
      os << "--DIntervalBase BEGIN--" << std::endl;
      os << "MIN --> " << rhs.minPosition() << std::endl;
      os << "MAX --> " << rhs.maxPosition() << std::endl;
      os << "--DIntervalBase END--" << std::endl;
      return os;
    }
 
  } // namespace Internal
 
} // namespace OpenMS