RangeId3.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  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 viskores_RangeId3_h
#define viskores_RangeId3_h
 
#include <viskores/RangeId.h>
 
namespace viskores
{
 
struct RangeId3
{
  viskores::RangeId X;
  viskores::RangeId Y;
  viskores::RangeId Z;
 
  RangeId3() = default;
 
  VISKORES_EXEC_CONT
  RangeId3(const viskores::RangeId& xrange,
           const viskores::RangeId& yrange,
           const viskores::RangeId& zrange)
    : X(xrange)
    , Y(yrange)
    , Z(zrange)
  {
  }
 
  VISKORES_EXEC_CONT
  RangeId3(viskores::Id minX,
           viskores::Id maxX,
           viskores::Id minY,
           viskores::Id maxY,
           viskores::Id minZ,
           viskores::Id maxZ)
    : X(viskores::RangeId(minX, maxX))
    , Y(viskores::RangeId(minY, maxY))
    , Z(viskores::RangeId(minZ, maxZ))
  {
  }
 
  VISKORES_EXEC_CONT
  explicit RangeId3(const viskores::Id range[6])
    : X(viskores::RangeId(range[0], range[1]))
    , Y(viskores::RangeId(range[2], range[3]))
    , Z(viskores::RangeId(range[4], range[5]))
  {
  }
 
  VISKORES_EXEC_CONT
  RangeId3(const viskores::Id3& min, const viskores::Id3& max)
    : X(viskores::RangeId(min[0], max[0]))
    , Y(viskores::RangeId(min[1], max[1]))
    , Z(viskores::RangeId(min[2], max[2]))
  {
  }
 
  VISKORES_EXEC_CONT
  bool IsNonEmpty() const
  {
    return (this->X.IsNonEmpty() && this->Y.IsNonEmpty() && this->Z.IsNonEmpty());
  }
 
  VISKORES_EXEC_CONT
  bool Contains(const viskores::Id3& val) const
  {
    return (this->X.Contains(val[0]) && this->Y.Contains(val[1]) && this->Z.Contains(val[2]));
  }
 
  VISKORES_EXEC_CONT
  viskores::Id3 Center() const
  {
    return viskores::Id3(this->X.Center(), this->Y.Center(), this->Z.Center());
  }
 
  VISKORES_EXEC_CONT
  viskores::Id3 Dimensions() const
  {
    return viskores::Id3(this->X.Length(), this->Y.Length(), this->Z.Length());
  }
 
  template <typename T>
  VISKORES_EXEC_CONT void Include(const viskores::Vec<T, 3>& point)
  {
    this->X.Include(point[0]);
    this->Y.Include(point[1]);
    this->Z.Include(point[2]);
  }
 
  VISKORES_EXEC_CONT
  void Include(const viskores::RangeId3& range)
  {
    this->X.Include(range.X);
    this->Y.Include(range.Y);
    this->Z.Include(range.Z);
  }
 
  VISKORES_EXEC_CONT
  viskores::RangeId3 Union(const viskores::RangeId3& other) const
  {
    viskores::RangeId3 unionRangeId3(*this);
    unionRangeId3.Include(other);
    return unionRangeId3;
  }
 
  VISKORES_EXEC_CONT
  viskores::RangeId3 operator+(const viskores::RangeId3& other) const { return this->Union(other); }
 
  VISKORES_EXEC_CONT
  bool operator==(const viskores::RangeId3& range) const
  {
    return ((this->X == range.X) && (this->Y == range.Y) && (this->Z == range.Z));
  }
 
  VISKORES_EXEC_CONT
  bool operator!=(const viskores::RangeId3& range) const
  {
    return ((this->X != range.X) || (this->Y != range.Y) || (this->Z != range.Z));
  }
  VISKORES_EXEC_CONT
  viskores::RangeId& operator[](IdComponent c) noexcept
  {
    if (c <= 0)
    {
      return this->X;
    }
    else if (c == 1)
    {
      return this->Y;
    }
    else
    {
      return this->Z;
    }
  }
 
  VISKORES_EXEC_CONT
  const viskores::RangeId& operator[](IdComponent c) const noexcept
  {
    if (c <= 0)
    {
      return this->X;
    }
    else if (c == 1)
    {
      return this->Y;
    }
    else
    {
      return this->Z;
    }
  }
};
 
inline VISKORES_CONT std::ostream& operator<<(std::ostream& stream, const viskores::RangeId3& range)
{
  return stream << "{ X:" << range.X << ", Y:" << range.Y << ", Z:" << range.Z << " }";
} // Declared inside of viskores namespace so that the operator work with ADL lookup
} // namespace viskores
 
#endif //viskores_RangeId3_h