DRange.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-2021.
//
// 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: Timo Sachsenberg$
// $Authors: Marc Sturm $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/DIntervalBase.h>
#include <OpenMS/CONCEPT/Macros.h>
#include <OpenMS/CONCEPT/Types.h>
 
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;
    }
 
    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;
    }
 
    bool isEmpty() const
    {
      for (UInt i = 0; i != D; i++)
      {
        if (max_[i] <= min_[i])
        {
          return true;
        }
      }
      return false;
    }
 
    void 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;
      }
    }
 
    DRange<D>& swapDimensions()
    {
      static_assert(D==2);
      std::swap(min_[0], min_[1]);
      std::swap(max_[0], max_[1]);
      return *this;
    }
 
  };
 
  template <UInt D>
  std::ostream& operator<<(std::ostream& os, const DRange<D>& area)
  {
    os << "--DRANGE BEGIN--" << std::endl;
    os << "MIN --> " << area.min_ << std::endl;
    os << "MAX --> " << area.max_ << std::endl;
    os << "--DRANGE END--" << std::endl;
    return os;
  }
 
} // namespace OpenMS