DRange.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg$
// $Authors: Marc Sturm $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/DIntervalBase.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <OpenMS/CONCEPT/Macros.h>
#include <OpenMS/CONCEPT/Types.h>
 
#include <functional>
 
namespace OpenMS
{
  template <UInt D>
  class DRange :
    public Internal::DIntervalBase<D>
  {
public:
 
    enum {DIMENSION = D};
    typedef Internal::DIntervalBase<D> Base;
    typedef typename Base::PositionType PositionType;
    typedef typename Base::CoordinateType CoordinateType;
    enum DRangeIntersection
    {
      Disjoint, 
      Intersects, 
      Inside 
    };
 
 
    using Base::min_;
    using Base::max_;
 
    DRange() :
      Base()
    {
    }
 
    DRange(const PositionType& lower, const PositionType& upper) :
      Base(lower, upper)
    {
    }
 
    DRange(const DRange& range) :
      Base(range)
    {
    }
 
    DRange(DRange&&) noexcept = default;
 
    DRange(const Base& range) :
      Base(range)
    {
    }
 
    DRange(CoordinateType minx, CoordinateType miny, CoordinateType maxx, CoordinateType maxy)
    {
      static_assert(D == 2);
      min_[0] = minx;
      min_[1] = miny;
      max_[0] = maxx;
      max_[1] = maxy;
      Base::normalize_();
    }
 
    DRange& operator=(const DRange& rhs)
    {
      Base::operator=(rhs);
      return *this;
    }
 
    DRange& operator=(const Base& rhs)
    {
      Base::operator=(rhs);
      return *this;
    }
 
    ~DRange()
    {
    }
 
 
    bool operator==(const DRange& rhs) const
    {
      return Base::operator==(rhs);
    }
 
    bool operator==(const Base& rhs) const
    {
      return Base::operator==(rhs);
    }
 
    bool encloses(const PositionType& position) const
    {
      for (UInt i = 0; i != D; i++)
      {
        if (position[i] < min_[i]) return false;
 
        if (position[i] >= max_[i]) return false;
      }
      return true;
    }
 
    bool encloses(CoordinateType x, CoordinateType y) const
    {
      if (x < min_[0]) return false;
 
      if (x >= max_[0]) return false;
 
      if (y < min_[1]) return false;
 
      if (y >= max_[1]) return false;
 
      return true;
    }
 
    DRange united(const DRange<D>& other_range) const
    {
      PositionType united_min;
      PositionType united_max;
      DRange<D> united_range = DRange<D>::empty;
 
      PositionType other_min = other_range.minPosition();
      PositionType other_max = other_range.maxPosition();
 
      for (Size i = 0; i != D; ++i)
      {
        united_min[i] = min_[i] < other_min[i] ? min_[i] : other_min[i];
        united_max[i] = max_[i] > other_max[i] ? max_[i] : other_max[i];
      }
      united_range.setMinMax(united_min, united_max);
 
      return united_range;
    }
 
    DRangeIntersection intersects(const DRange& range) const
    {
      //check if r.min_ is in this area
      if (encloses(range.min_))
      {
        //check if r.max_ in this area => Inside / Intersects
        for (Size i = 0; i != D; i++)
        {
          if (range.max_[i] > max_[i])
          {
            return Intersects;
          }
        }
        return Inside;
      }
      // => r.min_ is not inside this area
      //check if any r.min_ >= max_ => Disjoint
      for (Size i = 0; i != D; i++)
      {
        if (range.min_[i] >= max_[i])
        {
          return Disjoint;
        }
      }
      // => some coordinate of r.min_ has to be smaller than the one of min_
      //check if all coords of r are smaller than the those of the range
      for (Size i = 0; i != D; i++)
      {
        if (range.max_[i] <= min_[i])
        {
          return Disjoint;
        }
      }
      return Intersects;
    }
 
    bool isIntersected(const DRange& range) const
    {
      //check if r.min_ is in this area
      if (encloses(range.min_))
      {
        return true;
      }
 
      // => r.min_ is not inside this area
      //check if any r.min_ >= max_ => Disjoint
      for (Size i = 0; i != D; i++)
      {
        if (range.min_[i] >= max_[i])
        {
          return false;
        }
      }
      // => some coordinate of r.min_ has to be smaller than the one of min_
      //check if all coords of r are smaller than the those of the range
      for (Size i = 0; i != D; i++)
      {
        if (range.max_[i] <= min_[i])
        {
          return false;
        }
      }
      return true;
    }
 
    DRange<D>& extend(double factor)
    {
      if (factor < 0)
      {
        throw Exception::InvalidParameter(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "DRange::extend(): factor must not be negative!");
      }
 
      for (UInt i = 0; i != D; ++i)
      {
        Internal::DIntervalBase<1>::CoordinateType extra = (max_[i] - min_[i]) / 2.0 * (factor - 1);
        min_[i] -= extra;
        max_[i] += extra;
      }
      return *this;
    }
 
    DRange<D>& extend(typename Base::PositionType addition)
    {
      addition /= 2;
      min_ -= addition;
      max_ += addition;
      for (UInt i = 0; i != D; ++i)
      {
        // invalid range --> reduce to single center point
        if (min_[i] > max_[i]) min_[i] = max_[i] = (min_[i] + max_[i]) / 2;
      }
      return *this;
    }
 
    DRange<D>& ensureMinSpan(typename Base::PositionType min_span)
    {
      typename Base::PositionType extend_by {};
      for (UInt i = 0; i != D; ++i)
      {
        // invalid range --> reduce to single center point
        if (max_[i] - min_[i] < min_span[i])
        {
          extend_by[i] = min_span[i] - (max_[i] - min_[i]); // add whatever is missing to get to min_span
        }
      }
      extend(extend_by);
      return *this;
    }
 
    DRange<D>& swapDimensions()
    {
      static_assert(D==2);
      std::swap(min_[0], min_[1]);
      std::swap(max_[0], max_[1]);
      return *this;
    }
 
    void pullIn(DPosition<D>& point) const
    {
      for (UInt i = 0; i != D; ++i)
      {
        point[i] = std::max(min_[i], std::min(point[i], max_[i]));
      }
    }
 
  };
 
  template <UInt D>
  std::ostream& operator<<(std::ostream& os, const DRange<D>& area)
  {
    os << "--DRANGE BEGIN--\n";
    os << "MIN --> " << area.min_ << '\n';
    os << "MAX --> " << area.max_ << '\n';
    os << "--DRANGE END--\n";
    return os;
  }
 
} // namespace OpenMS
 
// Hash function specialization for DRange
namespace std
{
  template<OpenMS::UInt D>
  struct hash<OpenMS::DRange<D>>
  {
    std::size_t operator()(const OpenMS::DRange<D>& range) const noexcept
    {
      std::size_t seed = 0;
      // Hash min_ position (all D coordinates)
      for (OpenMS::UInt i = 0; i < D; ++i)
      {
        OpenMS::hash_combine(seed, OpenMS::hash_float(range.minPosition()[i]));
      }
      // Hash max_ position (all D coordinates)
      for (OpenMS::UInt i = 0; i < D; ++i)
      {
        OpenMS::hash_combine(seed, OpenMS::hash_float(range.maxPosition()[i]));
      }
      return seed;
    }
  };
} // namespace std