range.h

Go to the documentation of this file.

#ifndef ION_MATH_RANGE_H_
#define ION_MATH_RANGE_H_

#include <algorithm>
#include <istream>  // NOLINT
#include <ostream>  // NOLINT

#include "ion/base/logging.h"
#include "ion/base/static_assert.h"
#include "ion/base/stringutils.h"
#include "ion/math/vector.h"
#include "ion/math/vectorutils.h"

namespace ion {
namespace math {

template <typename T, int N> struct Range1TWrapper {
  Range1TWrapper() {}
  Range1TWrapper(const T& t_in) : t(t_in) {}  // NOLINT - needs to be implicit.
  operator T() const { return t; }
  T& operator[](int index) {
    DCHECK_EQ(index, 0);
    return t;
  }
  const T& operator[](int index) const {
    DCHECK_EQ(index, 0);
    return t;
  }

  static const T Zero() { return T(0); }

  template <typename U> friend std::istream& operator>>(
      std::istream& in, Range1TWrapper<U, 0>& w);

  T t;
};

template <typename T>
std::istream& operator>>(std::istream& in, Range1TWrapper<T, 0>& w) {
  return in >> w.t;
}

template <int Dimension, typename T>
class RangeBase {
 public:
  enum { kDimension = Dimension };

  typedef Point<Dimension, T> Endpoint;

  typedef Vector<Dimension, T> Size;
};

template <typename T>
class RangeBase<1, T> {
 public:
  enum { kDimension = 1 };
  typedef Range1TWrapper<T, 0> Endpoint;
  typedef Range1TWrapper<T, 1> Size;
};

template <int Dimension, typename T>
class Range : public RangeBase<Dimension, T> {
 public:
  typedef RangeBase<Dimension, T> BaseType;
  typedef typename BaseType::Endpoint Endpoint;
  typedef typename BaseType::Size Size;

  Range() { MakeEmpty(); }

  Range(const Endpoint& min_point, const Endpoint& max_point) {
    Set(min_point, max_point);
  }

  static const Range BuildWithSize(const Endpoint& min_point,
                                   const Size& size) {
    Range r;
    r.SetWithSize(min_point, size);
    return r;
  }

  void MakeEmpty();

  bool IsEmpty() const;

  const Endpoint& GetMinPoint() const { return min_point_; }
  const Endpoint& GetMaxPoint() const { return max_point_; }

  void SetMinPoint(const Endpoint& p) { min_point_ = p; }
  void SetMaxPoint(const Endpoint& p) { max_point_ = p; }
  void Set(const Endpoint& min_point, const Endpoint& max_point) {
    min_point_ = min_point;
    max_point_ = max_point;
  }

  void SetMinComponent(int i, T value);
  void SetMaxComponent(int i, T value);

  void SetWithSize(const Endpoint& min_point, const Size& size) {
    min_point_ = min_point;
    max_point_ = min_point + size;
  }

  const Size GetSize() const {
    return IsEmpty() ? Size::Zero() : max_point_ - min_point_;
  }

  const Endpoint GetCenter() const {
    return IsEmpty() ? Endpoint::Zero() :
        min_point_ + ((max_point_ - min_point_) / static_cast<T>(2));
  }

  void ExtendByPoint(const Endpoint& p);

  void ExtendByRange(const Range& r);

  bool ContainsPoint(const Endpoint& p) const;

  bool ContainsRange(const Range& r) const;

  bool IntersectsRange(const Range& r) const;

  friend bool operator==(const Range& m0, const Range& m1) {
    const bool m0_empty = m0.IsEmpty();
    const bool m1_empty = m1.IsEmpty();
    if (m0_empty || m1_empty)
      return m0_empty == m1_empty;
    else
      return m0.min_point_ == m1.min_point_ && m0.max_point_ == m1.max_point_;
  }
  friend bool operator!=(const Range& m0, const Range& m1) {
    return !(m0 == m1);
  }

 private:
  void ExtendMinByPoint(const Endpoint& p);
  void ExtendMaxByPoint(const Endpoint& p);

  Endpoint min_point_;
  Endpoint max_point_;
};

template <int Dimension, typename T>
std::ostream& operator<<(std::ostream& out, const Range<Dimension, T>& r) {
  if (r.IsEmpty())
    return out << "R[EMPTY]";
  else
    return out << "R[" << r.GetMinPoint() << ", " << r.GetMaxPoint() << "]";
}

template <int Dimension, typename T>
std::istream& operator>>(std::istream& in, Range<Dimension, T>& r) {
  if (base::GetExpectedString(in, "R[")) {
    if (base::GetExpectedString(in, "EMPTY]")) {
      r = Range<Dimension, T>();
    } else {
      in.clear();
      typename Range<Dimension, T>::Endpoint min_point, max_point;
      if (in >> min_point >> base::GetExpectedChar<','> >> max_point
             >> base::GetExpectedChar<']'>)
        r.Set(min_point, max_point);
    }
  }

  return in;
}




template <int Dimension, typename T>
void Range<Dimension, T>::MakeEmpty() {
  for (int i = 0; i < Dimension; ++i) {
    min_point_[i] = static_cast<T>(1);
    max_point_[i] = static_cast<T>(0);
  }
}

template <int Dimension, typename T>
bool Range<Dimension, T>::IsEmpty() const {
  for (int i = 0; i < Dimension; ++i) {
    if (min_point_[i] > max_point_[i])
      return true;
  }
  return false;
}

template <int Dimension, typename T>
void Range<Dimension, T>::SetMinComponent(int i, T value) {
  DCHECK_LE(0, i);
  DCHECK_GT(Dimension, i);
  if (0 <= i && i < Dimension)
    min_point_[i] = value;
}

template <int Dimension, typename T>
void Range<Dimension, T>::SetMaxComponent(int i, T value) {
  DCHECK_LE(0, i);
  DCHECK_GT(Dimension, i);
  if (0 <= i && i < Dimension)
    max_point_[i] = value;
}

template <int Dimension, typename T>
void Range<Dimension, T>::ExtendByPoint(const Endpoint& p) {
  if (IsEmpty()) {
    min_point_ = max_point_ = p;
  } else {
    ExtendMinByPoint(p);
    ExtendMaxByPoint(p);
  }
}

template <int Dimension, typename T>
void Range<Dimension, T>::ExtendByRange(const Range& r) {
  if (!r.IsEmpty()) {
    if (IsEmpty()) {
      *this = r;
    } else {
      ExtendMinByPoint(r.GetMinPoint());
      ExtendMaxByPoint(r.GetMaxPoint());
    }
  }
}

template <int Dimension, typename T>
bool Range<Dimension, T>::ContainsPoint(const Endpoint& p) const {
  for (int i = 0; i < Dimension; ++i) {
    if (p[i] < min_point_[i] || p[i] > max_point_[i])
      return false;
  }
  return true;
}

template <int Dimension, typename T>
bool Range<Dimension, T>::ContainsRange(const Range& r) const {
  return ContainsPoint(r.GetMinPoint()) && ContainsPoint(r.GetMaxPoint());
}

template <int Dimension, typename T>
bool Range<Dimension, T>::IntersectsRange(const Range& r) const {
  const Endpoint& r_min_point = r.GetMinPoint();
  const Endpoint& r_max_point = r.GetMaxPoint();
  for (int i = 0; i < Dimension; ++i) {
    if (min_point_[i] > r_max_point[i]) return false;
    if (max_point_[i] < r_min_point[i]) return false;
  }
  return true;
}

template <int Dimension, typename T>
void Range<Dimension, T>::ExtendMinByPoint(const Endpoint& p) {
  for (int i = 0; i < Dimension; ++i) {
    min_point_[i] = std::min(p[i], min_point_[i]);
  }
}

template <int Dimension, typename T>
void Range<Dimension, T>::ExtendMaxByPoint(const Endpoint& p) {
  for (int i = 0; i < Dimension; ++i) {
    max_point_[i] = std::max(p[i], max_point_[i]);
  }
}




typedef Range<1, int8> Range1i8;
typedef Range<1, uint8> Range1ui8;
typedef Range<1, int16> Range1i16;
typedef Range<1, uint16> Range1ui16;
typedef Range<1, int32> Range1i;
typedef Range<1, uint32> Range1ui;
typedef Range<1, float> Range1f;
typedef Range<1, double> Range1d;
typedef Range<2, int8> Range2i8;
typedef Range<2, uint8> Range2ui8;
typedef Range<2, int16> Range2i16;
typedef Range<2, uint16> Range2ui16;
typedef Range<2, int32> Range2i;
typedef Range<2, uint32> Range2ui;
typedef Range<2, float> Range2f;
typedef Range<2, double> Range2d;
typedef Range<3, int8> Range3i8;
typedef Range<3, uint8> Range3ui8;
typedef Range<3, int16> Range3i16;
typedef Range<3, uint16> Range3ui16;
typedef Range<3, int32> Range3i;
typedef Range<3, uint32> Range3ui;
typedef Range<3, float> Range3f;
typedef Range<3, double> Range3d;
typedef Range<4, int8> Range4i8;
typedef Range<4, uint8> Range4ui8;
typedef Range<4, int16> Range4i16;
typedef Range<4, uint16> Range4ui16;
typedef Range<4, int32> Range4i;
typedef Range<4, uint32> Range4ui;
typedef Range<4, float> Range4f;
typedef Range<4, double> Range4d;




template<>
inline void Range3d::MakeEmpty() {
  min_point_[0] = 1.0;
  min_point_[1] = 1.0;
  min_point_[2] = 1.0;
  max_point_[0] = -1.0;
  max_point_[1] = -1.0;
  max_point_[2] = -1.0;
}

template<>
inline bool Range3d::IsEmpty() const {
  return
    min_point_[0] > max_point_[0] ||
    min_point_[1] > max_point_[1] ||
    min_point_[2] > max_point_[2];
}

template<>
inline bool Range3d::ContainsPoint(const Point3d& p) const {
  return
    p[0] >= min_point_[0] && p[0] <= max_point_[0] &&
    p[1] >= min_point_[1] && p[1] <= max_point_[1] &&
    p[2] >= min_point_[2] && p[2] <= max_point_[2];
}

template<>
inline void Range3d::ExtendMinByPoint(const Point3d& p) {
  min_point_[0] = std::min(p[0], min_point_[0]);
  min_point_[1] = std::min(p[1], min_point_[1]);
  min_point_[2] = std::min(p[2], min_point_[2]);
}

template<>
inline void Range3d::ExtendMaxByPoint(const Point3d& p) {
  max_point_[0] = std::max(p[0], max_point_[0]);
  max_point_[1] = std::max(p[1], max_point_[1]);
  max_point_[2] = std::max(p[2], max_point_[2]);
}

template<>
inline void Range3f::MakeEmpty() {
  min_point_[0] = 1.0f;
  min_point_[1] = 1.0f;
  min_point_[2] = 1.0f;
  max_point_[0] = -1.0f;
  max_point_[1] = -1.0f;
  max_point_[2] = -1.0f;
}

template<>
inline bool Range3f::IsEmpty() const {
  return
    min_point_[0] > max_point_[0] ||
    min_point_[1] > max_point_[1] ||
    min_point_[2] > max_point_[2];
}

template<>
inline bool Range3f::ContainsPoint(const Point3f& p) const {
  return
    p[0] >= min_point_[0] && p[0] <= max_point_[0] &&
    p[1] >= min_point_[1] && p[1] <= max_point_[1] &&
    p[2] >= min_point_[2] && p[2] <= max_point_[2];
}

template<>
inline void Range3f::ExtendMinByPoint(const Point3f& p) {
  min_point_[0] = std::min(p[0], min_point_[0]);
  min_point_[1] = std::min(p[1], min_point_[1]);
  min_point_[2] = std::min(p[2], min_point_[2]);
}

template<>
inline void Range3f::ExtendMaxByPoint(const Point3f& p) {
  max_point_[0] = std::max(p[0], max_point_[0]);
  max_point_[1] = std::max(p[1], max_point_[1]);
  max_point_[2] = std::max(p[2], max_point_[2]);
}

}  // namespace math
}  // namespace ion

#endif  // ION_MATH_RANGE_H_