gz/math/Region3.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2022 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef GZ_MATH_REGION3_HH_
#define GZ_MATH_REGION3_HH_
 
#include <cmath>
#include <limits>
#include <ostream>
#include <utility>
 
#include <gz/math/Interval.hh>
#include <gz/math/Vector3.hh>
#include <gz/math/config.hh>
 
namespace ignition
{
  namespace math
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_MATH_VERSION_NAMESPACE {
    //
    template <typename T>
    class Region3
    {
      public: static const Region3<T> &Unbounded;
 
      public: Region3() = default;
 
      public: constexpr Region3(
          Interval<T> _ix, Interval<T> _iy, Interval<T> _iz)
      : ix(std::move(_ix)), iy(std::move(_iy)), iz(std::move(_iz))
      {
      }
 
      public: static constexpr Region3<T> Open(
          T _xLeft, T _yLeft, T _zLeft,
          T _xRight, T _yRight, T _zRight)
      {
        return Region3<T>(Interval<T>::Open(_xLeft, _xRight),
                          Interval<T>::Open(_yLeft, _yRight),
                          Interval<T>::Open(_zLeft, _zRight));
      }
 
      public: static constexpr Region3<T> Closed(
          T _xLeft, T _yLeft, T _zLeft,
          T _xRight, T _yRight, T _zRight)
      {
        return Region3<T>(Interval<T>::Closed(_xLeft, _xRight),
                          Interval<T>::Closed(_yLeft, _yRight),
                          Interval<T>::Closed(_zLeft, _zRight));
      }
 
      public: const Interval<T> &Ix() const { return this->ix; }
 
      public: const Interval<T> &Iy() const { return this->iy; }
 
      public: const Interval<T> &Iz() const { return this->iz; }
 
      public: bool Empty() const
      {
        return this->ix.Empty() || this->iy.Empty() || this->iz.Empty();
      }
 
      public: bool Contains(const Vector3<T> &_point) const
      {
        return (this->ix.Contains(_point.X()) &&
                this->iy.Contains(_point.Y()) &&
                this->iz.Contains(_point.Z()));
      }
 
      public: bool Contains(const Region3<T> &_other) const
      {
        return (this->ix.Contains(_other.ix) &&
                this->iy.Contains(_other.iy) &&
                this->iz.Contains(_other.iz));
      }
 
      public: bool Intersects(const Region3<T>& _other) const
      {
        return (this->ix.Intersects(_other.ix) &&
                this->iy.Intersects(_other.iy) &&
                this->iz.Intersects(_other.iz));
      }
 
      public: bool operator==(const Region3<T> &_other) const
      {
        return this->Contains(_other) && _other.Contains(*this);
      }
 
      public: bool operator!=(const Region3<T> &_other) const
      {
        return !this->Contains(_other) || !_other.Contains(*this);
      }
 
      public: friend std::ostream &operator<<(
        std::ostream &_out, const gz::math::Region3<T> &_r)
      {
        return _out <<_r.ix << " x " << _r.iy << " x " << _r.iz;
      }
 
      private: Interval<T> ix;
      private: Interval<T> iy;
      private: Interval<T> iz;
    };
 
    namespace detail {
       template<typename T>
       constexpr Region3<T> gUnboundedRegion3(
           Interval<T>::Open(-std::numeric_limits<T>::infinity(),
                             std::numeric_limits<T>::infinity()),
           Interval<T>::Open(-std::numeric_limits<T>::infinity(),
                             std::numeric_limits<T>::infinity()),
           Interval<T>::Open(-std::numeric_limits<T>::infinity(),
                             std::numeric_limits<T>::infinity()));
    }
    template<typename T>
    const Region3<T> &Region3<T>::Unbounded = detail::gUnboundedRegion3<T>;
 
    using Region3f = Region3<float>;
    using Region3d = Region3<double>;
    }
  }
}
 
#endif