Geometry.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_Geometry_h
#define viskores_Geometry_h
 
#include <viskores/VectorAnalysis.h>
 
namespace viskores
{
 
// Forward declarations of geometric types:
template <typename CoordType, int Dim, bool IsTwoSided>
struct Ray;
template <typename CoordType, int Dim>
struct LineSegment;
template <typename CoordType>
struct Plane;
template <typename CoordType, int Dim>
struct Sphere;
 
template <typename CoordType = viskores::FloatDefault, int Dim = 3, bool IsTwoSided = false>
struct Ray
{
  static constexpr int Dimension = Dim;
  using Vector = viskores::Vec<CoordType, Dim>;
  static constexpr bool TwoSided = IsTwoSided;
 
  Vector Origin;
  Vector Direction; // always stored as a unit length.
 
  template <int Dim_ = Dim, typename std::enable_if<Dim_ == 2, int>::type = 0>
  VISKORES_EXEC_CONT Ray();
 
  template <int Dim_ = Dim, typename std::enable_if<Dim_ == 3, int>::type = 0>
  VISKORES_EXEC_CONT Ray();
 
  VISKORES_EXEC_CONT
  Ray(const Vector& point, const Vector& direction);
 
  VISKORES_EXEC_CONT
  Ray(const LineSegment<CoordType, Dim>& segment);
 
  VISKORES_EXEC_CONT
  bool IsValid() const;
 
  VISKORES_EXEC_CONT
  Vector Evaluate(CoordType param) const;
 
  VISKORES_EXEC_CONT
  CoordType DistanceTo(const Vector& point) const;
 
  VISKORES_EXEC_CONT
  CoordType DistanceTo(const Vector& point, CoordType& param, Vector& projectedPoint) const;
 
  template <bool OtherTwoSided, int Dim_ = Dim, typename std::enable_if<Dim_ == 2, int>::type = 0>
  VISKORES_EXEC_CONT bool Intersect(const Ray<CoordType, Dim, OtherTwoSided>& other,
                                    Vector& point,
                                    CoordType tol = 0.f);
};
 
template <typename CoordType = viskores::FloatDefault, int Dim = 3>
struct LineSegment
{
  static constexpr int Dimension = Dim;
  using Vector = viskores::Vec<CoordType, Dim>;
  Vector Endpoints[2];
 
  template <int Dim_ = Dim, typename std::enable_if<Dim_ == 2, int>::type = 0>
  VISKORES_EXEC_CONT LineSegment();
 
  template <int Dim_ = Dim, typename std::enable_if<Dim_ == 3, int>::type = 0>
  VISKORES_EXEC_CONT LineSegment();
 
  VISKORES_EXEC_CONT
  LineSegment(const Vector& p0, const Vector& p1);
 
  VISKORES_EXEC_CONT
  bool IsSingular(CoordType tol2 = static_cast<CoordType>(1.0e-6f)) const;
 
  template <int Dim_ = Dim, typename std::enable_if<Dim_ == 3, int>::type = 0>
  VISKORES_EXEC_CONT Plane<CoordType> PerpendicularBisector() const;
 
  template <int Dim_ = Dim, typename std::enable_if<Dim_ == 2, int>::type = 0>
  VISKORES_EXEC_CONT Ray<CoordType, Dim, true> PerpendicularBisector() const;
 
  VISKORES_EXEC_CONT
  Vector Center() const { return this->Evaluate(0.5f); }
 
  VISKORES_EXEC_CONT
  Vector Direction() const { return this->Endpoints[1] - this->Endpoints[0]; }
 
  VISKORES_EXEC_CONT
  Vector Evaluate(CoordType param) const;
 
  VISKORES_EXEC_CONT
  CoordType DistanceTo(const Vector& point) const;
 
  VISKORES_EXEC_CONT
  CoordType DistanceTo(const Vector& point, CoordType& param, Vector& projectedPoint) const;
 
  template <int Dim_ = Dim, typename std::enable_if<Dim_ == 2, int>::type = 0>
  VISKORES_EXEC_CONT bool IntersectInfinite(const LineSegment<CoordType, Dim>& other,
                                            Vector& point,
                                            CoordType tol = 0.f);
};
 
template <typename CoordType = viskores::FloatDefault>
struct Plane
{
  using Vector = viskores::Vec<CoordType, 3>;
  Vector Origin;
  Vector Normal;
 
  VISKORES_EXEC_CONT
  Plane();
 
  VISKORES_EXEC_CONT
  Plane(const Vector& origin, const Vector& normal, CoordType tol2 = static_cast<CoordType>(1e-8f));
 
  VISKORES_EXEC_CONT
  bool IsValid() const { return !viskores::IsInf(this->Normal[0]); }
 
  VISKORES_EXEC_CONT
  CoordType DistanceTo(const Vector& point) const;
 
  VISKORES_EXEC_CONT
  Vector ClosestPoint(const Vector& point) const;
 
  template <bool IsTwoSided>
  VISKORES_EXEC_CONT bool Intersect(const Ray<CoordType, 3, IsTwoSided>& ray,
                                    CoordType& parameter,
                                    Vector& point,
                                    bool& lineInPlane,
                                    CoordType tol = CoordType(1e-6f)) const;
 
  VISKORES_EXEC_CONT
  bool Intersect(const LineSegment<CoordType>& segment,
                 CoordType& parameter,
                 bool& lineInPlane) const;
 
  VISKORES_EXEC_CONT
  bool Intersect(const LineSegment<CoordType>& segment,
                 CoordType& parameter,
                 Vector& point,
                 bool& lineInPlane) const;
 
  VISKORES_EXEC_CONT
  bool Intersect(const Plane<CoordType>& other,
                 Ray<CoordType, 3, true>& ray,
                 bool& coincident,
                 CoordType tol2 = static_cast<CoordType>(1e-6f)) const;
};
 
template <typename CoordType = viskores::FloatDefault, int Dim = 3>
struct Sphere
{
  static constexpr int Dimension = Dim;
  using Vector = viskores::Vec<CoordType, Dim>;
  Vector Center;
  CoordType Radius;
 
  VISKORES_EXEC_CONT Sphere();
 
  VISKORES_EXEC_CONT Sphere(const Vector& center, CoordType radius);
 
  VISKORES_EXEC_CONT
  bool IsValid() const { return this->Radius > 0.f; }
 
  VISKORES_EXEC_CONT
  bool Contains(const Vector& point, CoordType tol2 = 0.f) const;
 
  VISKORES_EXEC_CONT
  int Classify(const Vector& point, CoordType tol2 = 0.f) const;
};
 
// -----------------------------------------------------------------------------
// Synonyms
//
// These "using" statements aim to make it easier to use the templated
// structs above when working with a particular dimension and/or the
// default floating-point type.
 
template <typename CoordType, int Dim = 3>
using Line = Ray<CoordType, Dim, true>;
 
// Shortcuts for 2D and 3D rays, lines, and line segments:
template <typename CoordType>
using Ray2 = Ray<CoordType, 2>;
template <typename CoordType>
using Ray3 = Ray<CoordType, 3>;
template <typename CoordType>
using Line2 = Line<CoordType, 2>;
template <typename CoordType>
using Line3 = Line<CoordType, 3>;
template <typename CoordType>
using LineSegment2 = LineSegment<CoordType, 2>;
template <typename CoordType>
using LineSegment3 = LineSegment<CoordType, 3>;
 
template <typename T>
using Circle = Sphere<T, 2>;
 
// Aliases for d-dimensional spheres.
template <typename T>
using Sphere2 = Sphere<T, 2>;
template <typename T>
using Sphere3 = Sphere<T, 3>;
 
// Shortcuts for default floating-point types
using Ray2d = Ray2<viskores::FloatDefault>;
using Ray3d = Ray3<viskores::FloatDefault>;
using Line2d = Line2<viskores::FloatDefault>;
using Line3d = Line3<viskores::FloatDefault>;
using LineSegment2d = LineSegment2<viskores::FloatDefault>;
using LineSegment3d = LineSegment3<viskores::FloatDefault>;
using Plane3d = Plane<viskores::FloatDefault>;
using Circle2d = Circle<viskores::FloatDefault>;
using Sphere2d = Sphere2<viskores::FloatDefault>;
using Sphere3d = Sphere3<viskores::FloatDefault>;
 
// -----------------------------------------------------------------------------
// Construction techniques
//
// These are free functions that create instances of geometric structs by taking
// in data that is not identical to the state of the struct and converting it
// into state for the struct.
 
template <typename CoordType, bool IsTwoSided>
VISKORES_EXEC_CONT viskores::Plane<CoordType> make_PlaneFromPointAndLine(
  const viskores::Vec<CoordType, 3>& point,
  const viskores::Ray<CoordType, 3, IsTwoSided>& ray,
  CoordType tol2 = static_cast<CoordType>(1e-8f));
 
template <typename CoordType>
VISKORES_EXEC_CONT viskores::Plane<CoordType> make_PlaneFromPointAndLineSegment(
  const viskores::Vec<CoordType, 3>& point,
  const viskores::LineSegment3<CoordType>& segment,
  CoordType tol2 = static_cast<CoordType>(1e-8f));
 
template <typename CoordType>
VISKORES_EXEC_CONT viskores::Circle<CoordType> make_CircleFrom3Points(
  const typename viskores::Vec<CoordType, 2>& p0,
  const typename viskores::Vec<CoordType, 2>& p1,
  const typename viskores::Vec<CoordType, 2>& p2,
  CoordType tol = static_cast<CoordType>(1e-6f));
 
template <typename CoordType>
VISKORES_EXEC_CONT viskores::Sphere<CoordType, 3> make_SphereFrom4Points(
  const viskores::Vec<CoordType, 3>& a0,
  const viskores::Vec<CoordType, 3>& a1,
  const viskores::Vec<CoordType, 3>& a2,
  const viskores::Vec<CoordType, 3>& a3,
  CoordType tol = static_cast<CoordType>(1e-6f));
 
} // namespace viskores
 
#include <viskores/Geometry.hxx>
 
#endif // viskores_Geometry_h