Bounds.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
 
#ifndef vtk_m_Bounds_h
#define vtk_m_Bounds_h
 
#include <vtkm/Range.h>
 
namespace vtkm
{
 
struct Bounds
{
  vtkm::Range X;
  vtkm::Range Y;
  vtkm::Range Z;
 
  VTKM_EXEC_CONT
  Bounds() {}
 
  Bounds(const Bounds&) = default;
 
  VTKM_EXEC_CONT
  Bounds(const vtkm::Range& xRange, const vtkm::Range& yRange, const vtkm::Range& zRange)
    : X(xRange)
    , Y(yRange)
    , Z(zRange)
  {
  }
 
  template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  VTKM_EXEC_CONT Bounds(const T1& minX,
                        const T2& maxX,
                        const T3& minY,
                        const T4& maxY,
                        const T5& minZ,
                        const T6& maxZ)
    : X(vtkm::Range(minX, maxX))
    , Y(vtkm::Range(minY, maxY))
    , Z(vtkm::Range(minZ, maxZ))
  {
  }
 
  template <typename T>
  VTKM_EXEC_CONT explicit Bounds(const T bounds[6])
    : X(vtkm::Range(bounds[0], bounds[1]))
    , Y(vtkm::Range(bounds[2], bounds[3]))
    , Z(vtkm::Range(bounds[4], bounds[5]))
  {
  }
 
  template <typename T>
  VTKM_EXEC_CONT Bounds(const vtkm::Vec<T, 3>& minPoint, const vtkm::Vec<T, 3>& maxPoint)
    : X(vtkm::Range(minPoint[0], maxPoint[0]))
    , Y(vtkm::Range(minPoint[1], maxPoint[1]))
    , Z(vtkm::Range(minPoint[2], maxPoint[2]))
  {
  }
 
  vtkm::Bounds& operator=(const vtkm::Bounds& src) = default;
 
  VTKM_EXEC_CONT
  bool IsNonEmpty() const
  {
    return (this->X.IsNonEmpty() && this->Y.IsNonEmpty() && this->Z.IsNonEmpty());
  }
 
  template <typename T>
  VTKM_EXEC_CONT bool Contains(const vtkm::Vec<T, 3>& point) const
  {
    return (this->X.Contains(point[0]) && this->Y.Contains(point[1]) && this->Z.Contains(point[2]));
  }
 
  VTKM_EXEC_CONT
  vtkm::Float64 Volume() const
  {
    if (this->IsNonEmpty())
    {
      return (this->X.Length() * this->Y.Length() * this->Z.Length());
    }
    else
    {
      return 0.0;
    }
  }
 
  VTKM_EXEC_CONT
  vtkm::Float64 Area() const
  {
    if (this->IsNonEmpty())
    {
      return (this->X.Length() * this->Y.Length());
    }
    else
    {
      return 0.0;
    }
  }
 
  VTKM_EXEC_CONT
  vtkm::Vec3f_64 Center() const
  {
    return vtkm::Vec3f_64(this->X.Center(), this->Y.Center(), this->Z.Center());
  }
 
  VTKM_EXEC_CONT
  vtkm::Vec3f_64 MinCorner() const { return vtkm::Vec3f_64(this->X.Min, this->Y.Min, this->Z.Min); }
 
  VTKM_EXEC_CONT
  vtkm::Vec3f_64 MaxCorner() const { return vtkm::Vec3f_64(this->X.Max, this->Y.Max, this->Z.Max); }
 
  template <typename T>
  VTKM_EXEC_CONT void Include(const vtkm::Vec<T, 3>& point)
  {
    this->X.Include(point[0]);
    this->Y.Include(point[1]);
    this->Z.Include(point[2]);
  }
 
  VTKM_EXEC_CONT
  void Include(const vtkm::Bounds& bounds)
  {
    this->X.Include(bounds.X);
    this->Y.Include(bounds.Y);
    this->Z.Include(bounds.Z);
  }
 
  VTKM_EXEC_CONT
  vtkm::Bounds Union(const vtkm::Bounds& otherBounds) const
  {
    vtkm::Bounds unionBounds(*this);
    unionBounds.Include(otherBounds);
    return unionBounds;
  }
 
  VTKM_EXEC_CONT
  vtkm::Bounds Intersection(const vtkm::Bounds& otherBounds) const
  {
    return vtkm::Bounds(this->X.Intersection(otherBounds.X),
                        this->Y.Intersection(otherBounds.Y),
                        this->Z.Intersection(otherBounds.Z));
  }
 
  VTKM_EXEC_CONT
  vtkm::Bounds operator+(const vtkm::Bounds& otherBounds) const { return this->Union(otherBounds); }
 
  VTKM_EXEC_CONT
  bool operator==(const vtkm::Bounds& bounds) const
  {
    return ((this->X == bounds.X) && (this->Y == bounds.Y) && (this->Z == bounds.Z));
  }
 
  VTKM_EXEC_CONT
  bool operator!=(const vtkm::Bounds& bounds) const
  {
    return ((this->X != bounds.X) || (this->Y != bounds.Y) || (this->Z != bounds.Z));
  }
};
 
inline VTKM_CONT std::ostream& operator<<(std::ostream& stream, const vtkm::Bounds& bounds)
{
  return stream << "{ X:" << bounds.X << ", Y:" << bounds.Y << ", Z:" << bounds.Z << " }";
}
 
template <>
struct VTKM_NEVER_EXPORT VecTraits<vtkm::Bounds>
{
  using ComponentType = vtkm::Range;
  using BaseComponentType = vtkm::VecTraits<vtkm::Range>::BaseComponentType;
 
  static constexpr vtkm::IdComponent NUM_COMPONENTS = 3;
  static constexpr vtkm::IdComponent GetNumberOfComponents(const vtkm::Bounds&)
  {
    return NUM_COMPONENTS;
  }
  using HasMultipleComponents = vtkm::VecTraitsTagMultipleComponents;
  using IsSizeStatic = vtkm::VecTraitsTagSizeStatic;
 
  VTKM_EXEC_CONT
  static const ComponentType& GetComponent(const vtkm::Bounds& bounds, vtkm::IdComponent component)
  {
    VTKM_ASSERT((component >= 0) || (component < 3));
    switch (component)
    {
      case 0:
        return bounds.X;
      case 1:
        return bounds.Y;
      case 2:
        return bounds.Z;
      default:
        // Should never reach here
        return bounds.X;
    }
  }
  VTKM_EXEC_CONT
  static ComponentType& GetComponent(vtkm::Bounds& bounds, vtkm::IdComponent component)
  {
    VTKM_ASSERT((component >= 0) || (component < 3));
    switch (component)
    {
      case 0:
        return bounds.X;
      case 1:
        return bounds.Y;
      case 2:
        return bounds.Z;
      default:
        // Should never reach here
        return bounds.X;
    }
  }
 
  VTKM_EXEC_CONT
  static void SetComponent(vtkm::Bounds& bounds,
                           vtkm::IdComponent component,
                           const ComponentType& value)
  {
    VTKM_ASSERT((component >= 0) || (component < 3));
    switch (component)
    {
      case 0:
        bounds.X = value;
        break;
      case 1:
        bounds.Y = value;
        break;
      case 2:
        bounds.Z = value;
        break;
    }
  }
 
  template <typename NewComponentType>
  using ReplaceComponentType = vtkm::Vec<NewComponentType, NUM_COMPONENTS>;
  template <typename NewComponentType>
  using ReplaceBaseComponentType =
    vtkm::Vec<NewComponentType, NUM_COMPONENTS * vtkm::VecTraits<vtkm::Range>::NUM_COMPONENTS>;
 
  template <vtkm::IdComponent destSize>
  VTKM_EXEC_CONT static void CopyInto(const vtkm::Bounds& src,
                                      vtkm::Vec<ComponentType, destSize>& dest)
  {
    const vtkm::IdComponent maxComponent = (destSize < NUM_COMPONENTS) ? destSize : NUM_COMPONENTS;
    for (vtkm::IdComponent component = 0; component < maxComponent; ++component)
    {
      dest[component] = GetComponent(src, component);
    }
  }
};
 
} // namespace vtkm
 
#endif //vtk_m_Bounds_h