geometry_base_types.h

Go to the documentation of this file.

#ifndef SDK_GEOMETRY_BASE_TYPES_H_
#define SDK_GEOMETRY_BASE_TYPES_H_
 
#include <base/inc/platform.h>
#include <base/inc/base_types.h>
#include <base/inc/float_util.h>
#include <cmath>
 
#ifdef SDK_OS_POSIX
#  include <stddef.h>
#endif
 
#pragma push_macro("min")
#pragma push_macro("max")
#undef min
#undef max
 
// NOTE: The SDK uses the following coordinate system:
// The Oy axis is directed from down to up,
// the Ox axis is directed from left to right (Cartesian coordinate system)
// Positive rotation angle means counterclockwise direction, negative - clockwise
 
typedef struct SDKPointF2D {
  float x; // x coordinate
  float y; // y coordinate
 
#if defined(__cplusplus)
  typedef SDKPointF2D MyType;
  typedef float coordinate_type;
  enum DimensionCount_ { dimension_count = 2 };
 
  static coordinate_type bad_coordinate() {
    return IEEE754_2008::flt_NaN();
  }
 
  template <size_t K>
  coordinate_type get() const {
    // The expression (1 / int(K < dimension_count)
    // cause a division by zero compiler error
    // in case of (K >= dimension_count) but always true
    // in the opposite case.
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->x;
      else //if (K == 1)
        return this->y;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->x = v;
      else //if (K == 1)
        this->y = v;
    }
  }
 
  template <size_t K>
  friend coordinate_type get(const MyType& p) {
    return p.get<K>();
  }
 
  template <size_t K>
  friend void set(const MyType& p, coordinate_type const v) {
    p.set<K>(v);
  }
 
  double Length(const MyType& p) const noexcept {
    return Length(p.x, p.y);
  }
 
  double Length(double x2, double y2) const noexcept {
    x2 -= x; y2 -= y;
    using std::sqrt;
    return sqrt(x2*x2 + y2*y2);
  }
#endif
} SDKPointF2D;
 
typedef struct SDKPointF3D {
  float x; // x coordinate
  float y; // y coordinate
  float z; // z coordinate
 
#if defined(__cplusplus)
  typedef SDKPointF3D MyType;
  typedef float coordinate_type;
  enum DimensionCount_ { dimension_count = 3 };
 
  static coordinate_type bad_coordinate() {
    return IEEE754_2008::flt_NaN();
  }
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->x;
      else if (K == 1)
        return this->y;
      else //if (K == 2)
        return this->z;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->x = v;
      else if (K == 1)
        this->y = v;
      else //if (K == 2)
        this->z = v;
    }
  }
 
  template <size_t K>
  friend coordinate_type get(const MyType& p) {
    return p.get<K>();
  }
 
  template <size_t K>
  friend void set(const MyType& p, coordinate_type const v) {
    p.set<K>(v);
  }
 
  double Length(const MyType& p) const noexcept {
    return Length(p.x, p.y, p.z);
  }
 
  double Length(double x2, double y2, double z2) const noexcept {
    x2 -= x; y2 -= y; z2 -= z;
    using std::sqrt;
    return sqrt(x2*x2 + y2*y2 + z2*z2);
  }
#endif
} SDKPointF3D;
 
typedef SDKPointF2D SDKVertex2D;
 
typedef SDKPointF3D SDKVertex3D;
 
typedef struct SDKPointI2D {
  SDKInt32 x; // x coordinate
  SDKInt32 y; // y coordinate
 
#if defined(__cplusplus)
  typedef SDKPointI2D MyType;
  typedef SDKInt32 coordinate_type;
  enum DimensionCount_ { dimension_count = 2 };
 
  static coordinate_type bad_coordinate() {
    return SDK_MIN_INT32;
  }
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->x;
      else //if (K == 1)
        return this->y;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->x = v;
      else //if (K == 1)
        this->y = v;
    }
  }
 
  template <size_t K>
  friend coordinate_type get(const MyType& p) {
    return p.get<K>();
  }
 
  template <size_t K>
  friend void set(const MyType& p, coordinate_type const v) {
    p.set<K>(v);
  }
 
  double Length(const MyType& p) const noexcept {
    return Length(p.x, p.y);
  }
 
  double Length(double x2, double y2) const noexcept {
    x2 -= x; y2 -= y;
    using std::sqrt;
    return sqrt(x2*x2 + y2*y2);
  }
#endif
} SDKPointI2D;
 
typedef struct SDKPointD2D {
  double x; // x coordinate
  double y; // y coordinate
 
#if defined(__cplusplus)
  typedef SDKPointD2D MyType;
  typedef double coordinate_type;
  enum DimensionCount_ { dimension_count = 2 };
 
  static coordinate_type bad_coordinate() {
    return IEEE754_2008::dbl_NaN();
  }
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->x;
      else //if (K == 1)
        return this->y;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->x = v;
      else //if (K == 1)
        this->y = v;
    }
  }
 
  template <size_t K>
  friend coordinate_type get(const MyType& p) {
    return p.get<K>();
  }
 
  template <size_t K>
  friend void set(const MyType& p, coordinate_type const v) {
    p.set<K>(v);
  }
 
  double Length(const MyType& p) const noexcept {
    return Length(p.x, p.y);
  }
 
  double Length(double x2, double y2) const noexcept {
    x2 -= x; y2 -= y;
    using std::sqrt;
    return sqrt(x2*x2 + y2*y2);
  }
#endif
} SDKPointD2D;
 
typedef struct SDKPointD3D {
  double x;
  double y;
  double z;
 
#if defined(__cplusplus)
  typedef SDKPointD3D MyType;
  typedef double coordinate_type;
  enum DimensionCount_ { dimension_count = 3 };
 
  static coordinate_type bad_coordinate() {
    return IEEE754_2008::dbl_NaN();
  }
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->x;
      else if (K == 1)
        return this->y;
      else //if (K == 2)
        return this->z;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->x = v;
      else if (K == 1)
        this->y = v;
      else //if (K == 2)
        this->z = v;
    }
  }
 
  template <size_t K>
  friend coordinate_type get(const MyType& p) {
    return p.get<K>();
  }
 
  template <size_t K>
  friend void set(const MyType& p, coordinate_type const v) {
    p.set<K>(v);
  }
 
  double Length(const MyType& p) const noexcept {
    return Length(p.x, p.y, p.z);
  }
 
  double Length(double x2, double y2, double z2) const noexcept {
    x2 -= x; y2 -= y; z2 -= z;
    using std::sqrt;
    return sqrt(x2*x2 + y2*y2 + z2*z2);
  }
#endif
} SDKPointD3D;
 
typedef struct SDKEnvelopeD2D {
  // A POD structure without ctors/dtors
  union {
    SDKPointD2D min;
    struct {
      double xmin;
      double ymin;
    };
  };
  union {
    SDKPointD2D max;
    struct {
      double xmax;
      double ymax;
    };
  };
 
#if defined(__cplusplus)
  typedef SDKPointD2D point_type;
 
#if 1
  SDKEnvelopeD2D() noexcept
    : xmin(0), ymin(0), xmax(0), ymax(0) {
  }
 
  SDKEnvelopeD2D(
    point_type const& _min_corner,
    point_type const& _max_corner) noexcept
    : xmin(_min_corner.x), ymin(_min_corner.y), xmax(_max_corner.x),
    ymax(_max_corner.y) {
  }
 
  SDKEnvelopeD2D(
    point_type::coordinate_type _xmin,
    point_type::coordinate_type _ymin,
    point_type::coordinate_type _xmax,
    point_type::coordinate_type _ymax) noexcept
    : xmin(_xmin), ymin(_ymin), xmax(_xmax), ymax(_ymax) {
  }
#endif
 
  bool IsEmpty() const noexcept {
    return xmin == 0 && ymin == 0 &&
           xmax == 0 && ymax == 0;
  }
 
  // Indexed access
  template <size_t C>
  point_type const& corner() const noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  template <size_t C>
  point_type& corner() noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  point_type const& min_corner() const noexcept {
    return min;
  }
  point_type& min_corner() noexcept {
    return min;
  }
  point_type const& max_corner() const noexcept {
    return max;
  }
  point_type& max_corner() noexcept {
    return max;
  }
#endif
} SDKEnvelopeD2D;
 
typedef struct SDKEnvelopeI2D {
  // A POD structure without ctors/dtors
  union {
    SDKPointI2D min;
    struct {
      SDKInt32 xmin;
      SDKInt32 ymin;
    };
  };
  union {
    SDKPointI2D max;
    struct {
      SDKInt32 xmax;
      SDKInt32 ymax;
    };
  };
 
#if defined(__cplusplus)
  typedef SDKPointI2D point_type;
 
#if 1
  SDKEnvelopeI2D() noexcept
    : xmin(0), ymin(0), xmax(0), ymax(0) {
  }
 
  SDKEnvelopeI2D(
    point_type const& _min_corner,
    point_type const& _max_corner) noexcept
    : xmin(_min_corner.x), ymin(_min_corner.y), xmax(_max_corner.x),
    ymax(_max_corner.y) {
  }
 
  SDKEnvelopeI2D(
    point_type::coordinate_type _xmin,
    point_type::coordinate_type _ymin,
    point_type::coordinate_type _xmax,
    point_type::coordinate_type _ymax) noexcept
    : xmin(_xmin), ymin(_ymin), xmax(_xmax), ymax(_ymax) {
  }
#endif
 
  bool IsEmpty() const noexcept {
    return xmin == 0 && ymin == 0 &&
           xmax == 0 && ymax == 0;
  }
 
  // Indexed access
  template <size_t C>
  point_type const& corner() const noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  template <size_t C>
  point_type& corner() noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  point_type const& min_corner() const noexcept {
    return min;
  }
  point_type& min_corner() noexcept {
    return min;
  }
  point_type const& max_corner() const noexcept {
    return max;
  }
  point_type& max_corner() noexcept {
    return max;
  }
#endif
} SDKEnvelopeI2D;
 
typedef struct SDKEnvelopeD3D {
  // A POD structure without ctors/dtors
  union {
    SDKPointD3D min;
    struct {
      double xmin;
      double ymin;
      double zmin;
    };
  };
  union {
    SDKPointD3D max;
    struct {
      double xmax;
      double ymax;
      double zmax;
    };
  };
 
#if defined(__cplusplus)
  typedef SDKPointD3D point_type;
 
#if 1
  SDKEnvelopeD3D() noexcept
    : xmin(0), ymin(0), zmin(0), xmax(0), ymax(0), zmax(0) {
  }
 
  SDKEnvelopeD3D(
    point_type const& _min_corner,
    point_type const& _max_corner) noexcept
    : xmin(_min_corner.x), ymin(_min_corner.y), zmin(_min_corner.z),
    xmax(_max_corner.x), ymax(_max_corner.y), zmax(_max_corner.z) {
  }
 
  SDKEnvelopeD3D(
    point_type::coordinate_type _xmin,
    point_type::coordinate_type _ymin,
    point_type::coordinate_type _zmin,
    point_type::coordinate_type _xmax,
    point_type::coordinate_type _ymax,
    point_type::coordinate_type _zmax) noexcept
    : xmin(_xmin), ymin(_ymin), zmin(_zmin), xmax(_xmax), ymax(_ymax),
    zmax(_zmax) {
  }
#endif
 
  bool IsEmpty() const noexcept {
    return xmin == 0 && ymin == 0 &&
           xmax == 0 && ymax == 0 &&
           zmin == 0 && zmax == 0;
  }
 
  // Default copy operator is enough.
  //SDKEnvelope3D& operator=(const SDKEnvelope3D& src) noexcept {
  //  xmin = src.xmin; xmax = src.xmax;
  //  ymin = src.ymin; ymax = src.ymax;
  //  zmin = src.zmin; zmax = src.zmax;
  //  return *this;
  //}
 
  // Indexed access
  template <size_t C>
  point_type const& corner() const noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  template <size_t C>
  point_type& corner() noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  point_type const& min_corner() const noexcept {
    return min;
  }
  point_type& min_corner() noexcept {
    return min;
  }
  point_type const& max_corner() const noexcept {
    return max;
  }
  point_type& max_corner() noexcept {
    return max;
  }
#endif
} SDKEnvelopeD3D;
 
typedef struct SDKEnvelopeF2D {
  // A POD structure without ctors/dtors
  union {
    SDKPointF2D min;
    struct {
      float xmin;
      float ymin;
    };
  };
  union {
    SDKPointF2D max;
    struct {
      float xmax;
      float ymax;
    };
  };
 
#if defined(__cplusplus)
  typedef SDKPointF2D point_type;
 
  bool IsEmpty() const noexcept {
    return xmin == 0 && ymin == 0
        && xmax == 0 && ymax == 0;
  }
 
  // Indexed access
  template <size_t C>
  point_type const& corner() const noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  template <size_t C>
  point_type& corner() noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  point_type const& min_corner() const noexcept {
    return min;
  }
  point_type& min_corner() noexcept {
    return min;
  }
  point_type const& max_corner() const noexcept {
    return max;
  }
  point_type& max_corner() noexcept {
    return max;
  }
#endif
} SDKEnvelopeF2D;
 
typedef struct SDKEnvelopeF3D {
  // A POD structure without ctors/dtors
  union {
    SDKPointF3D min;
    struct {
      float xmin;
      float ymin;
      float zmin;
    };
  };
  union {
    SDKPointF3D max;
    struct {
      float xmax;
      float ymax;
      float zmax;
    };
  };
 
#if defined(__cplusplus)
  typedef SDKPointF3D point_type;
 
  bool IsEmpty() const noexcept {
    return xmin == 0 && ymin == 0
        && xmax == 0 && ymax == 0
        && zmin == 0 && zmax == 0;
  }
 
  // Indexed access
  template <size_t C>
  point_type const& corner() const noexcept {
    if (!(1 / int(C < 2)))
      return min;
 
    if (C == 0)
      return min;
    else
      return max;
  }
 
  template <size_t C>
  point_type& corner() noexcept {
    if (!(1 / int(C < 2)))
      return min;
 
    if (C == 0)
      return min;
    else
      return max;
  }
 
  point_type const& min_corner() const noexcept {
    return min;
  }
  point_type& min_corner() noexcept {
    return min;
  }
  point_type const& max_corner() const noexcept {
    return max;
  }
  point_type& max_corner() noexcept {
    return max;
  }
#endif
} SDKEnvelopeF3D;
 
#if defined(__cplusplus) && 0
SDK_BEGIN_NAMESPACE
namespace geometry {
 
struct GenGeometryPointTag {};
struct GenGeometryBoxTag {};
struct GenGeometryXYWHRectTag {};
 
template <typename Geometry>
struct GenGeometryTag {
};
 
template <typename Geometry>
struct GenGeometryPointType {
  typedef typename Geometry::point_type type;
};
 
template <typename Point, size_t D = 0>
struct GenGeometryCoordinateType {
  typedef typename Point::coordinate_type type;
};
 
template <typename Point>
struct GenGeometryDimension {
  enum _Dimension { value = Point::dimension_count };
};
 
template <typename Point, size_t D,
  bool IsActualDimension = (D < size_t(GenGeometryDimension<Point>::value)) >
struct GenGeometryPointAccess;
 
template <typename Point, size_t D>
struct GenGeometryPointAccess<Point,D,true> {
  typedef typename GenGeometryCoordinateType<Point,D>::type coordinate_type;
  static void set(Point& p, coordinate_type v) {
    return p.template set<D>(v);
  }
  static coordinate_type get(const Point& p) {
    return p.template get<D>();
  }
};
 
template <class Point, size_t D>
struct GenGeometryPointAccess<Point,D,false> {
  typedef typename Point::coordinate_type coordinate_type;
 
  template <typename IgnoreIt>
  static void set(Point&, const IgnoreIt&) {
  }
  static coordinate_type get(const Point&) {
    return Point::bad_coordinate();
  }
};
 
template <class XYWHRect, size_t I, typename Enable=void>
class CornerType;
 
template <class XYWHRect, typename Enable>
class CornerType<XYWHRect,0,Enable> {
  friend XYWHRect;
  typedef CornerType<XYWHRect,0,Enable> MyType;
  typedef XYWHRect Rect;
  typedef typename GenGeometryPointType<Rect>::type point_type;
  typedef const point_type const_point_type;
  typedef typename GenGeometryCoordinateType<point_type>::type coordinate_type;
 
  Rect& m_rect;
  CornerType(const Rect& rect) noexcept
    : m_rect(const_cast<Rect&>(rect)) {
  }
 
public:
  template <size_t D>
  typename GenGeometryCoordinateType<point_type,D>::type get() const noexcept {
    if (!D)
      return m_rect.x;
    else
      return m_rect.y;
  }
  template <size_t D>
  void set(typename GenGeometryCoordinateType<point_type,D>::type v) const noexcept {
    if (!D)
      m_rect.x = v;
    else
      m_rect.y = v;
  }
  template <class Point>
  const MyType& operator=(const Point& pnt) const {
    m_rect.x = GenGeometryPointAccess<point_type,0>::get(pnt);
    m_rect.y = GenGeometryPointAccess<point_type,1>::get(pnt);
    return *this;
  }
  operator const_point_type() const {
    point_type pnt;
    GenGeometryPointAccess<point_type,0>::set(pnt, m_rect.x);
    GenGeometryPointAccess<point_type,1>::set(pnt, m_rect.y);
    return pnt;
  }
};
 
template <class XYWHRect, typename Enable>
class CornerType<XYWHRect,1,Enable> {
  friend XYWHRect;
  typedef CornerType<XYWHRect,1,Enable> MyType;
  typedef XYWHRect Rect;
  typedef typename GenGeometryPointType<Rect>::type point_type;
  typedef const point_type const_point_type;
  typedef typename GenGeometryCoordinateType<point_type>::type coordinate_type;
 
  Rect& m_rect;
  CornerType(const Rect& rect) noexcept
    : m_rect(const_cast<Rect&>(rect)) {
  }
 
public:
  template <size_t D>
  typename GenGeometryCoordinateType<point_type,D>::type get() const noexcept {
    if (!D)
      return m_rect.x + m_rect.width;
    else
      return m_rect.y + m_rect.height;
  }
  template <size_t D>
  void set(typename GenGeometryCoordinateType<point_type,D>::type v) const noexcept {
    if (!D)
      m_rect.width = v - m_rect.x;
    else
      m_rect.height = v - m_rect.y;
  }
  template <class Point>
  const MyType& operator=(const Point& pnt) const {
    m_rect.width = GenGeometryPointAccess<point_type,0>::get(pnt) - m_rect.x;
    m_rect.height = GenGeometryPointAccess<point_type,1>::get(pnt) - m_rect.y;
    return *this;
  }
  operator const_point_type() const {
    point_type pnt;
    GenGeometryPointAccess<point_type,0>::set(pnt, m_rect.x + m_rect.width);
    GenGeometryPointAccess<point_type,1>::set(pnt, m_rect.y + m_rect.height);
    return pnt;
  }
};
 
template <class Box, size_t I, size_t D,
  class GenGeometryBoxTag = typename geometry::GenGeometryTag<Box>::type,
  bool IsActualIndex = (I < 2)>
struct GenGeometryIndexedAccess;
 
template <class Box, size_t I, size_t D>
struct GenGeometryIndexedAccess<Box,I,D,geometry::GenGeometryBoxTag,true> {
  typedef typename GenGeometryPointType<Box>::type point_type;
  typedef typename GenGeometryCoordinateType<point_type,D>::type coordinate_type;
 
  static void set(Box& box, coordinate_type v) {
    return GenGeometryPointAccess<point_type,D>::set(box.template corner<I>(), v);
  }
  static coordinate_type get(const Box& box) {
    return GenGeometryPointAccess<point_type,D>::get(box.template corner<I>());
  }
};
 
template <class Box>
struct GenGeometryIndexedAccess<Box,0,0,geometry::GenGeometryXYWHRectTag,true> {
  typedef typename GenGeometryPointType<Box>::type point_type;
  typedef typename GenGeometryCoordinateType<point_type,0>::type coordinate_type;
  static void set(Box& box, coordinate_type v) { box.x = v; }
  static coordinate_type get(const Box& box) { return box.x; }
};
 
template <class Box>
struct GenGeometryIndexedAccess<Box,0,1,geometry::GenGeometryXYWHRectTag,true> {
  typedef typename GenGeometryPointType<Box>::type point_type;
  typedef typename GenGeometryCoordinateType<point_type,1>::type coordinate_type;
  static void set(Box& box, coordinate_type v) { box.y = v; }
  static coordinate_type get(const Box& box) { return box.y; }
};
 
template <class Box>
struct GenGeometryIndexedAccess<Box,1,0,geometry::GenGeometryXYWHRectTag,true> {
  typedef typename GenGeometryPointType<Box>::type point_type;
  typedef typename GenGeometryCoordinateType<point_type,0>::type coordinate_type;
  static void set(Box& box, coordinate_type v) { box.width = v - box.x; }
  static coordinate_type get(const Box& box) { return box.x + box.width; }
};
 
template <class Box>
struct GenGeometryIndexedAccess<Box,1,1,geometry::GenGeometryXYWHRectTag,true> {
  typedef typename GenGeometryPointType<Box>::type point_type;
  typedef typename GenGeometryCoordinateType<point_type,1>::type coordinate_type;
  static void set(Box& box, coordinate_type v) { box.height = v - box.y; }
  static coordinate_type get(const Box& box) { return box.y + box.height; }
};
 
template <class Box, size_t I, size_t D, class GenGeometryBoxTag>
struct GenGeometryIndexedAccess<Box,I,D,GenGeometryBoxTag,false> {
  typedef typename GenGeometryPointType<Box>::type point_type;
  typedef typename GenGeometryCoordinateType<point_type,D>::type coordinate_type;
 
  static void set(Box& box, coordinate_type v) {
  }
  static coordinate_type get(const Box& box) {
    return point_type::bad_coordinate();
  }
};
 
template <typename _PODEnvelope>
struct EnvelopeT : public _PODEnvelope {
private:
  typedef _PODEnvelope MyBase;
  typedef EnvelopeT<_PODEnvelope> MyType;
 
public:
  typedef typename GenGeometryPointType<MyBase>::type point_type;
  typedef typename GenGeometryCoordinateType<point_type>::type coordinate_type;
  enum Dimension_ { dimension_count = GenGeometryDimension<point_type>::value };
 
  EnvelopeT() noexcept
    : MyBase() {
    // According to the standard direct call on the default ctor
    // has to zeroing the object.
  }
 
  explicit EnvelopeT(const MyBase& _rhs) noexcept
    : MyBase(_rhs) {
  }
 
  MyType& operator=(const MyBase& _rhs) noexcept {
    static_cast<MyBase&>(*this) = _rhs;
    return *this;
  }
 
  template <size_t I, size_t D>
  void set(coordinate_type v) {
    return geometry::GenGeometryIndexedAccess<_PODEnvelope,I,D>::set(*this,v);
  }
 
  template <size_t I, size_t D>
  coordinate_type get() const {
    return geometry::GenGeometryIndexedAccess<_PODEnvelope,I,D>::get(*this);
  }
 
  template <size_t I, size_t D, typename _E>
  void _assign(const EnvelopeT<_E>& _rhs) {
    return this->set<I,D>(coordinate_type(_rhs.template get<I,D>()));
  }
 
  template <class _E>
  void assign(const EnvelopeT<_E>& _rhs) {
    _assign<0,0>(_rhs);
    _assign<0,1>(_rhs);
    _assign<0,2>(_rhs);
    _assign<1,0>(_rhs);
    _assign<1,1>(_rhs);
    _assign<1,2>(_rhs);
  }
 
  template <class _E>
  explicit EnvelopeT(const EnvelopeT<_E>& _rhs) noexcept
    : MyBase() {
    assign(_rhs);
  }
 
  template <class _E>
  MyType& operator=(const EnvelopeT<_E>& _rhs) noexcept {
    assign(_rhs);
    return *this;
  }
 
  template <class _E>
  explicit EnvelopeT(const _E& _rhs) noexcept
    : MyBase() {
    assign(static_cast<const EnvelopeT<_E>&>(_rhs));
  }
 
  template <class _E>
  MyType& operator=(const _E& _rhs) noexcept {
    assign(static_cast<const EnvelopeT<_E>&>(_rhs));
    return *this;
  }
 
  EnvelopeT(
    point_type const& _min_corner,
    point_type const& _max_corner) noexcept {
    this->template corner<0>() = _min_corner;
    this->template corner<1>() = _max_corner;
  }
 
  EnvelopeT(
    coordinate_type _xmin,
    coordinate_type _ymin,
    coordinate_type _xmax,
    coordinate_type _ymax) noexcept
    : MyBase() {
    set<0,0>(_xmin);
    set<0,1>(_ymin);
    set<1,0>(_xmax);
    set<1,1>(_ymax);
  }
 
  EnvelopeT(
    coordinate_type _xmin,
    coordinate_type _ymin,
    coordinate_type _zmin,
    coordinate_type _xmax,
    coordinate_type _ymax,
    coordinate_type _zmax) noexcept
    : MyBase() {
    set<0,0>(_xmin);
    set<0,1>(_ymin);
    set<0,2>(_zmin);
    set<1,0>(_xmax);
    set<1,1>(_ymax);
    set<1,2>(_zmax);
  }
};
 
} // namespace geometry 
 
typedef geometry::EnvelopeT<SDKEnvelopeF2D> EnvelopeF2D;
typedef geometry::EnvelopeT<SDKEnvelopeF3D> EnvelopeF3D;
typedef geometry::EnvelopeT<SDKEnvelopeD2D> EnvelopeD2D;
typedef geometry::EnvelopeT<SDKEnvelopeD3D> EnvelopeD3D;
typedef geometry::EnvelopeT<SDKEnvelopeI2D> EnvelopeI2D;
 
SDK_END_NAMESPACE
 
typedef SDK_NAMESPACE::EnvelopeF2D SDKEnvelope2DF;
typedef SDK_NAMESPACE::EnvelopeD2D SDKEnvelope2D;
typedef SDK_NAMESPACE::EnvelopeI2D SDKEnvelope2DI;
typedef SDK_NAMESPACE::EnvelopeF3D SDKEnvelope3DF;
typedef SDK_NAMESPACE::EnvelopeD3D SDKEnvelope3D;
#else
typedef struct SDKEnvelopeF2D SDKEnvelope2DF;
typedef struct SDKEnvelopeD2D SDKEnvelope2D;
typedef struct SDKEnvelopeI2D SDKEnvelope2DI;
typedef struct SDKEnvelopeF3D SDKEnvelope3DF;
typedef struct SDKEnvelopeD3D SDKEnvelope3D;
#endif
 
typedef struct SDKSizeF {
  float width;
  float height;
 
#if defined(__cplusplus)
  typedef SDKSizeF MyType;
  typedef float coordinate_type;
  enum DimensionCount_ { dimension_count = 2 };
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->width;
      else //if (K == 1)
        return this->height;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->width = v;
      else //if (K == 1)
        this->height = v;
    }
  }
 
  template <size_t K>
  friend coordinate_type get(const MyType& p) {
    return p.get<K>();
  }
 
  template <size_t K>
  friend void set(const MyType& p, coordinate_type const v) {
    p.set<K>(v);
  }
 
  // Returns true if size width and height are 0
  bool IsNull() const noexcept {
    return width == 0 && height == 0;
  }
 
  // Returns true if size is equal to another size
  bool IsEqual(const MyType& s) const noexcept {
    return true && 
      fabsf(width - s.width) <= FLT_EPSILON && 
      fabsf(height - s.height) <= FLT_EPSILON;
  }
#endif
} SDKSizeF;
 
typedef struct SDKSizeD {
  double width;
  double height;
 
#if defined(__cplusplus)
  typedef SDKSizeD MyType;
  typedef double coordinate_type;
  enum DimensionCount_ { dimension_count = 2 };
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->width;
      else //if (K == 1)
        return this->height;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->width = v;
      else //if (K == 1)
        this->height = v;
    }
  }
 
  template <size_t K>
  friend coordinate_type get(const MyType& p) {
    return p.get<K>();
  }
 
  template <size_t K>
  friend void set(const MyType& p, coordinate_type const v) {
    p.set<K>(v);
  }
 
  // Returns true if size width and height are 0
  bool IsNull() const noexcept {
    return width == 0 && height == 0;
  }
 
  // Returns true if size is equal to another size
  bool IsEqual(const MyType& s) const noexcept {
    return true && 
      fabs(width - s.width) <= DBL_EPSILON && 
      fabs(height - s.height) <= DBL_EPSILON;
  }
#endif
} SDKSizeD;
 
typedef struct SDKSize {
  SDKUInt32 width;
  SDKUInt32 height;
 
#if defined(__cplusplus)
  typedef SDKSize MyType;
  typedef SDKUInt32 coordinate_type;
  enum DimensionCount_ { dimension_count = 2 };
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->width;
      else //if (K == 1)
        return this->height;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->width = v;
      else //if (K == 1)
        this->height = v;
    }
  }
 
  template <size_t K>
  friend coordinate_type get(const MyType& p) {
    return p.get<K>();
  }
 
  template <size_t K>
  friend void set(const MyType& p, coordinate_type const v) {
    p.set<K>(v);
  }
 
  // Returns true if size width and height are 0
  bool IsNull() const noexcept {
    return width == 0 && height == 0;
  }
 
  // Returns true if size is equal to another size
  bool IsEqual(const MyType& s) const noexcept {
    return width == s.width && height == s.height;
  }
#endif
} SDKSize;
 
typedef struct SDKRectF2D {
  float x;      // X left
  float y;      // Y bottom
  float width;  // Width
  float height; // Height
 
#if defined(__cplusplus)
  typedef SDKRectF2D  MyType;
  typedef SDKPointF2D point_type;
  typedef SDKSizeF    size_type;
  #if 0
  typedef sdk::geometry::CornerType<MyType,0> min_corner_type;
  typedef sdk::geometry::CornerType<MyType,1> max_corner_type;
 
  template <size_t I>
  const sdk::geometry::CornerType<MyType,I> corner() const noexcept {
    return sdk::geometry::CornerType<MyType,I>(*this);
  }
 
  const min_corner_type min_corner() const noexcept {
    return min_corner_type(*this);
  }
 
  const max_corner_type max_corner() const noexcept {
    return max_corner_type(*this);
  }
  #else
  point_type min_corner() const noexcept {
    point_type ret = {x, y};
    return ret;
  }
  point_type max_corner() const noexcept {
    point_type ret = {x + width, y + height};
    return ret;
  }
  #endif
 
  // Returns true if rectangle has no area
  bool IsEmpty() const noexcept {
    return width == 0 && height == 0;
  }
 
  // Returns true if rectangle is at (0,0) and has no area
  bool IsNull() const noexcept {
    return x == 0 && y == 0 && width == 0 && height == 0;
  }
 
  // Returns true if rectangle is equal to another rectangle
  bool IsEqual(const MyType& r) const noexcept {
    return x == r.x && y == r.y && width == r.width && height == r.height;
  }
 
  const point_type Center() const noexcept {
    point_type ret = {x + width / 2, y + height / 2};
    return ret;
  }
#endif
} SDKRectF2D;
 
typedef struct SDKRectD2D {
  double x;      // X left
  double y;      // Y bottom
  double width;  // Width
  double height; // Height
 
#if defined(__cplusplus)
  typedef SDKRectD2D  MyType;
  typedef SDKPointD2D point_type;
  typedef SDKSizeD    size_type;
  #if 0
  typedef sdk::geometry::CornerType<MyType,0> min_corner_type;
  typedef sdk::geometry::CornerType<MyType,1> max_corner_type;
 
  template <size_t I>
  const sdk::geometry::CornerType<MyType,I> corner() const noexcept {
    return sdk::geometry::CornerType<MyType,I>(*this);
  }
 
  const min_corner_type min_corner() const noexcept {
    return min_corner_type(*this);
  }
 
  const max_corner_type max_corner() const noexcept {
    return max_corner_type(*this);
  }
  #else
  point_type min_corner() const noexcept {
    point_type ret = {x, y};
    return ret;
  }
  point_type max_corner() const noexcept {
    point_type ret = {x + width, y + height};
    return ret;
  }
  #endif
 
  // Returns true if rectangle has no area
  bool IsEmpty() const noexcept {
    return width == 0 && height == 0;
  }
 
  // Returns true if rectangle is at (0,0) and has no area
  bool IsNull() const noexcept {
    return x == 0 && y == 0 && width == 0 && height == 0;
  }
 
  // Returns true if rectangle is equal to another rectangle
  bool IsEqual(const MyType& r) const noexcept {
    return x == r.x && y == r.y && width == r.width && height == r.height;
  }
 
  const point_type Center() const noexcept {
    point_type ret = {x + width / 2, y + height / 2};
    return ret;
  }
#endif
} SDKRectD2D;
 
typedef struct SDKRectI2D {
  SDKInt32 x;        // X left
  SDKInt32 y;        // Y bottom
  SDKUInt32 width;   // Width
  SDKUInt32 height;  // Height
 
#if defined(__cplusplus)
  typedef SDKRectI2D  MyType;
  typedef SDKPointI2D point_type;
  typedef SDKSize     size_type;
  #if 0
  typedef sdk::geometry::CornerType<MyType,0> min_corner_type;
  typedef sdk::geometry::CornerType<MyType,1> max_corner_type;
 
  template <size_t I>
  const sdk::geometry::CornerType<MyType,I> corner() const noexcept {
    return sdk::geometry::CornerType<MyType,I>(*this);
  }
 
  const min_corner_type min_corner() const noexcept {
    return min_corner_type(*this);
  }
 
  const max_corner_type max_corner() const noexcept {
    return max_corner_type(*this);
  }
  #else
  point_type min_corner() const noexcept {
    point_type ret = {x, y};
    return ret;
  }
  point_type max_corner() const noexcept {
  point_type ret = {static_cast<SDKInt32>(x + width),
                    static_cast<SDKInt32>(y + height)};
    return ret;
  }
  #endif
 
  // Returns true if rectangle has no area
  bool IsEmpty() const noexcept {
    return width == 0 && height == 0;
  }
 
  // Returns true if rectangle is at (0,0) and has no area
  bool IsNull() const noexcept {
    return x == 0 && y == 0 && width == 0 && height == 0;
  }
 
  // Returns true if rectangle is equal to another rectangle
  bool IsEqual(const MyType& r) const noexcept {
    return x == r.x && y == r.y && width == r.width && height == r.height;
  }
 
  const point_type Center() const noexcept {
    point_type ret = {SDKInt32(x + width / 2), SDKInt32(y + height / 2)};
    return ret;
  }
#endif
} SDKRectI2D, SDKRect2D;
 
typedef struct SDKRoundRectF2D {
  SDKRectF2D rect;    // Rectangle
  float   rad_x;   // Rounding radius by Ox
  float   rad_y;   // Rounding radius by Oy
} SDKRoundRectF2D;
 
typedef struct SDKEllipseF2D {
  SDKPointF2D center;  // Ellipse center point
  float    rad_x;   // Ellipse radius by Ox
  float    rad_y;   // Ellipse radius by Oy
} SDKEllipseF2D;
 
typedef struct SDKQBezierSegment {
  SDKPointF2D pt1;
  SDKPointF2D pt2;
} SDKQBezierSegment;
 
typedef struct SDKCuBezierSegment {
  SDKPointF2D pt1;
  SDKPointF2D pt2;
  SDKPointF2D pt3;
} SDKCuBezierSegment;
 
typedef SDKInt32 SDKGeoInt;
typedef SDKInt32 GeoInt;
typedef SDKUInt32 SDKGeoIntDistance;
typedef SDKUInt32 GeoIntDistance;
 
static const GeoIntDistance kGeoIntLonFull = SDK_MAX_UINT32;
static const GeoIntDistance kGeoIntLatFull = SDK_MAX_UINT32/2;
static const GeoInt kGeoIntLonMax = SDK_MAX_INT32;
static const GeoInt kGeoIntMaxX   = kGeoIntLonMax;
static const GeoInt kGeoIntLonMin = SDK_MIN_INT32;
static const GeoInt kGeoIntMinX   = kGeoIntLonMin;
static const GeoInt kGeoIntLatMax = SDK_MAX_INT32/2;
static const GeoInt kGeoIntMaxY   = kGeoIntLatMax;
static const GeoInt kGeoIntLatMin = SDK_MIN_INT32/2;
static const GeoInt kGeoIntMinY   = kGeoIntLatMin;
static const double kDegLonFull = 360.0;
static const double kDegLatFull = 180.0;
static const double kDegLonMax =  180.0;
static const double kDegLonMin = -180.0;
static const double kDegLatMax =  90.0;
static const double kDegLatMin = -90.0;
static const double kDegLatInvalidValue = 91.0;
static const double kDegInvalidValueY = kDegLatInvalidValue;
static const double kDegLonInvalidValue = 181.0;
static const double kDegInvalidValueX = kDegLonInvalidValue;
 
typedef struct SDKGeoIntPoint {
  union {
    SDKGeoInt x;
    SDKGeoInt lon;
  };
  union {
    SDKGeoInt y;
    SDKGeoInt lat;
  };
 
#ifdef __cplusplus
  typedef SDKGeoInt coordinate_type;
  enum DimensionCount_ { dimension_count = 2 };
 
  static coordinate_type bad_coordinate() {
    return SDK_MIN_INT32;
  }
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->x;
      else //if (K == 1)
        return this->y;
    }
    return SDK_MIN_INT32;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->x = v;
      else //if (K == 1)
        this->y = v;
    }
  }
 
  bool IsValid() const {
    return (x != bad_coordinate() && y != bad_coordinate()) ? true : false;
  }
 
#endif
} SDKGeoIntPoint;
 
typedef struct SDKGeoIntPoint3D {
  union {
  SDKGeoInt x;
  SDKGeoInt lon;
  };
  union {
    SDKGeoInt y;
    SDKGeoInt lat;
  };
  double z; 
 
#ifdef __cplusplus
  typedef SDKGeoInt coordinate_type;
  enum DimensionCount_ { dimension_count = 3 };
 
  class _RetType {
    friend struct SDKGeoIntPoint3D;
    _RetType(const void *p) : m_p(p) {}
    const void *m_p;
  public:
    operator const coordinate_type&() const {
      return *(const coordinate_type*)m_p;
    }
    operator const double&() const {
      return *(const double*)m_p;
    }
  };
  template <size_t K>
  _RetType get() const {
    if (1 / int(K < 3)) {
      if (K == 0)
        return _RetType(&this->x);
      else if (K == 1)
        return _RetType(&this->y);
      else
        return _RetType(&this->z);
    }
    return _RetType(NULL);
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < 2)) {
      if (K == 0)
        this->x = v;
      else //if (K == 1)
        this->y = v;
    }
  }
  template <size_t K>
  void set(double const v) {
    if (1 / int(K == 2))
      this->z = v;
  }
#endif
} SDKGeoIntPoint3D;
 
typedef struct SDKGeoIntRect {
  union {
    SDKGeoIntPoint sw;
    SDKGeoIntPoint min;
  };
  union {
    SDKGeoIntPoint ne;
    SDKGeoIntPoint max;
  };
 
#ifdef __cplusplus
  typedef SDKGeoIntPoint point_type;
 
  // Indexed access
  template <size_t C>
  point_type const& corner() const noexcept {
    if (!(1 / int(C < 2)))
      return min;
 
    if (C == 0)
      return min;
    else
      return max;
  }
 
  template <size_t C>
  point_type& corner() noexcept {
    if (!(1 / int(C < 2)))
      return min;
 
    if (C == 0)
      return min;
    else
      return max;
  }
 
  point_type const& min_corner() const noexcept {
    return min;
  }
  point_type& min_corner() noexcept {
    return min;
  }
  point_type const& max_corner() const noexcept {
    return max;
  }
  point_type& max_corner() noexcept {
    return max;
  }
#endif
} SDKGeoIntRect;
 
typedef struct SDKGeoPoint {
  union {
    double x;
    double lon;
  };
  union {
    double y;
    double lat;
  };
 
#ifdef __cplusplus
  typedef double coordinate_type;
  enum DimensionCount_ { dimension_count = 2 };
 
  static coordinate_type bad_coordinate() {
    return IEEE754_2008::dbl_NaN();
  }
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->x;
      else //if (K == 1)
        return this->y;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->x = v;
      else //if (K == 1)
        this->y = v;
    }
  }
 
  bool IsValid() const {
    // Check if NaN to prevent unpredictable compare
    // operators behavior on different platforms and standards
    if (IEEE754_2008::is_NaN(x) || IEEE754_2008::is_NaN(y))
      return false;
 
    return (x > kDegLonMax || x < kDegLonMin || 
      y > kDegLatMax || y < kDegLatMin) ? false : true;
  }
 
  // Returns true if geo point is equal to another geo point
  bool IsEqual(const SDKGeoPoint& pt) const noexcept {
    if (IsValid() != pt.IsValid())
      return false;
    if (!IsValid())
      return true; // Both of points are not valid
    // Both of points are valid
    if (fabs(x - pt.x) >= 90.0/0x40000000) // 0.00000008381903171539306640625
      return false;
    if (fabs(y - pt.y) >= 90.0/0x40000000)
      return false;
    return true;
  }
 
#endif
} SDKGeoPoint;
 
typedef struct SDKGeoPointRect {
  union {
    SDKGeoPoint sw;
    SDKGeoPoint min;
  };
  union {
    SDKGeoPoint ne;
    SDKGeoPoint max;
  };
 
#ifdef __cplusplus
  typedef SDKGeoPoint point_type;
 
  // Indexed access
  template <size_t C>
  point_type const& corner() const noexcept {
    if (!(1 / int(C < 2)))
      return min;
    if (C == 0)
      return min;
    else
      return max;
  }
 
  template <size_t C>
  point_type& corner() noexcept {
    if (!(1 / int(C < 2)))
      return min;
 
    if (C == 0)
      return min;
    else
      return max;
  }
  point_type const& min_corner() const noexcept {
    return min;
  }
  point_type& min_corner() noexcept {
    return min;
  }
  point_type const& max_corner() const noexcept {
    return max;
  }
  point_type& max_corner() noexcept {
    return max;
  }
#endif
} SDKGeoPointRect;
 
typedef struct SDKGeoPoint3D {
  union {
    double x;
    double lon;
  };
  union {
    double y;
    double lat;
  };
  double z; 
 
#ifdef __cplusplus
  typedef double coordinate_type;
  enum DimensionCount_ { dimension_count = 3 };
 
  static coordinate_type bad_coordinate() {
    return IEEE754_2008::dbl_NaN();
  }
 
  template <size_t K>
  coordinate_type get() const {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        return this->x;
      else if (K == 1)
        return this->y;
      else //if (K == 2)
        return this->z;
    }
    return 0;
  }
 
  template <size_t K>
  void set(coordinate_type const v) {
    if (1 / int(K < dimension_count)) {
      if (K == 0)
        this->x = v;
      else if (K == 1)
        this->y = v;
      else //if (K == 2)
        this->z = v;
    }
  }
#endif
} SDKGeoPoint3D;
 
#ifdef __cplusplus
inline bool operator==(const SDKPointI2D& lhs, const SDKPointI2D& rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y;
}
 
inline bool operator!=(const SDKPointI2D& lhs, const SDKPointI2D& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKPointF2D& lhs, const SDKPointF2D& rhs) {
  return true && 
    fabsf(lhs.x - rhs.x) < FLT_EPSILON && 
    fabsf(lhs.y - rhs.y) < FLT_EPSILON;
}
 
inline bool operator!=(const SDKPointF2D& lhs, const SDKPointF2D& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKPointF3D& lhs, const SDKPointF3D& rhs) {
  return true && 
    fabsf(lhs.x - rhs.x) < FLT_EPSILON && 
    fabsf(lhs.y - rhs.y) < FLT_EPSILON && 
    fabsf(lhs.z - rhs.z) < FLT_EPSILON;
}
 
inline bool operator==(const SDKPointD2D& lhs, const SDKPointD2D& rhs) {
  //return true
  //  && fabs(lhs.x - rhs.x) < FLT_EPSILON
  //  && fabs(lhs.y - rhs.y) < FLT_EPSILON;
  return lhs.x == rhs.x && lhs.y == rhs.y;
}
 
inline bool operator!=(const SDKPointD2D& lhs, const SDKPointD2D& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKPointD3D& lhs, const SDKPointD3D& rhs) {
  //return true
  //  && fabs(lhs.x - rhs.x) < FLT_EPSILON
  //  && fabs(lhs.y - rhs.y) < FLT_EPSILON
  //  && fabs(lhs.z - rhs.z) < FLT_EPSILON;
  return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z;
}
 
inline bool operator!=(const SDKPointD3D& lhs, const SDKPointD3D& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKGeoIntPoint& lhs, const SDKGeoIntPoint& rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y;
}
 
inline bool operator!=(const SDKGeoIntPoint& lhs, const SDKGeoIntPoint& rhs) {
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKGeoPoint& lhs, const SDKGeoPoint& rhs) {
  return lhs.IsEqual(rhs);
}
 
inline bool operator!=(const SDKGeoPoint& lhs, const SDKGeoPoint& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKGeoPoint3D& lhs, const SDKGeoPoint3D& rhs) {
  return true && 
    fabs(lhs.x - rhs.x) < 90.0/0x40000000 && 
    fabs(lhs.y - rhs.y) < 90.0/0x40000000 && 
    fabs(lhs.z - rhs.z) < FLT_EPSILON;
}
 
inline bool operator!=(const SDKGeoPoint3D& lhs, const SDKGeoPoint3D& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKGeoIntPoint3D& lhs, 
  const SDKGeoIntPoint3D& rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y && fabs(lhs.z - rhs.z) < FLT_EPSILON;
}
 
inline bool operator!=(const SDKGeoIntPoint3D& lhs, 
  const SDKGeoIntPoint3D& rhs) {
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKEnvelopeF2D& lhs, const SDKEnvelopeF2D& rhs) {
  return (lhs.min) == (rhs.min) && (lhs.max) == (rhs.max);
}
 
inline bool operator!=(const SDKEnvelopeF2D& lhs, const SDKEnvelopeF2D& rhs) {
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKEnvelopeF3D& lhs, const SDKEnvelopeF3D& rhs) {
  return (lhs.min) == (rhs.min) && (lhs.max) == (rhs.max);
}
 
inline bool operator!=(const SDKEnvelopeF3D& lhs, const SDKEnvelopeF3D& rhs) {
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKEnvelopeD2D& lhs, const SDKEnvelopeD2D& rhs) {
  return (lhs.min) == (rhs.min) && (lhs.max) == (rhs.max);
}
 
inline bool operator!=(const SDKEnvelopeD2D& lhs, const SDKEnvelopeD2D& rhs) {
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKEnvelopeD3D& lhs, const SDKEnvelopeD3D& rhs) {
  return (lhs.min) == (rhs.min) && (lhs.max) == (rhs.max);
}
 
inline bool operator!=(const SDKEnvelopeD3D& lhs, const SDKEnvelopeD3D& rhs) {
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKRectI2D& lhs, const SDKRectI2D& rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y && lhs.width == rhs.width && 
    lhs.height == rhs.height;
}
 
inline bool operator!=(const SDKRectI2D& lhs, const SDKRectI2D& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKRectF2D& lhs, const SDKRectF2D& rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y && lhs.width == rhs.width && 
    lhs.height == rhs.height;
}
 
inline bool operator!=(const SDKRectF2D& lhs, const SDKRectF2D& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKRectD2D& lhs, const SDKRectD2D& rhs) {
  return lhs.x == rhs.x && lhs.y == rhs.y && 
    lhs.width == rhs.width && lhs.height == rhs.height;
}
 
inline bool operator!=(const SDKRectD2D& lhs, const SDKRectD2D& rhs) { 
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKSizeF& lhs, const SDKSizeF& rhs) {
  return lhs.IsEqual(rhs);
}
 
inline bool operator!=(const SDKSizeF& lhs, const SDKSizeF& rhs) {
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKSizeD& lhs, const SDKSizeD& rhs) {
  return lhs.IsEqual(rhs);
}
 
inline bool operator!=(const SDKSizeD& lhs, const SDKSizeD& rhs) {
  return !(lhs == rhs); 
}
 
inline bool operator==(const SDKSize& lhs, const SDKSize& rhs) {
  return lhs.IsEqual(rhs);
}
 
inline bool operator!=(const SDKSize& lhs, const SDKSize& rhs) {
  return !(lhs == rhs); 
}
 
inline bool IsEqualGeoIntPoint(const SDKGeoIntPoint& p1,
  const SDKGeoIntPoint& p2) {
  return ((p1.x == p2.x) && (p1.y == p2.y));
}
 
inline bool IsValidGeoPoint(const SDKGeoPoint& p) {
  return ((p.x >= kDegLonMin) && (p.x <= kDegLonMax) &&
    (p.y >= kDegLatMin) && (p.y <= kDegLatMax));
}
 
inline bool IsValidLat(double lat) {
  return ((lat >= kDegLatMin) && (lat <= kDegLatMax));
}
 
inline bool IsValidLon(double lon) {
  return ((lon >= kDegLonMin) && (lon <= kDegLonMax));
}
 
inline void NormalizeLat(double& lat) {
  if (lat < kDegLatMin)
    lat = kDegLatMin;
  else if (lat > kDegLatMax)
    lat = kDegLatMax;
}
 
#if 0
SDK_BEGIN_NAMESPACE
namespace geometry {
 
template <>
struct GenGeometryTag<SDKPointI2D> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKPointF2D> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKPointF3D> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKPointD2D> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKPointD3D> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKGeoIntPoint> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKGeoPoint> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKGeoPoint3D> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKGeoIntPoint3D> { typedef GenGeometryPointTag type; };
template <>
struct GenGeometryTag<SDKEnvelopeF2D> { typedef GenGeometryBoxTag type; };
template <>
struct GenGeometryTag<SDKEnvelopeF3D> { typedef GenGeometryBoxTag type; };
template <>
struct GenGeometryTag<SDKEnvelopeD2D> { typedef GenGeometryBoxTag type; };
template <>
struct GenGeometryTag<SDKEnvelopeD3D> { typedef GenGeometryBoxTag type; };
template <>
struct GenGeometryTag<SDKRectF2D> { typedef GenGeometryXYWHRectTag type; };
template <>
struct GenGeometryTag<SDKRectD2D> { typedef GenGeometryXYWHRectTag type; };
 
// Special case for 3D point with integer latitude and longitude
// coordinates and double zed coordinate
template <>
struct GenGeometryPointAccess<SDKGeoIntPoint3D,2,true>
{
  typedef double coordinate_type;
  static void set(SDKGeoIntPoint3D& p, coordinate_type v)
  {
    p.z = v;
  }
  static coordinate_type get(const SDKGeoIntPoint3D& p)
  {
    return p.z;
  }
};
 
//***********************
//* Quadrants Numbering *
//***********************
//*                     *
//*          |          *
//*      1   2   2      *
//*          |          *
//*   ---0---N---2---   *
//*          |          *
//*      0   0   3      *
//*          |          *
//*                     *
//***********************
 
template <
  typename x1_type, typename y1_type,
  typename x0_type, typename y0_type>
static inline int quadrantNum(
  const x1_type x1,           const y1_type y1,
  const x0_type x0=x0_type(), const y0_type y0=y0_type())
{
  enum
  {
    codes = 0
    | (1 <<  0) | (1 <<  3) | (4 <<  6)
    | (1 <<  9) | (0 << 12) | (3 << 15)
    | (2 << 18) | (3 << 21) | (3 << 24)
  };
  return ((codes >> 3 * (3 * ((y0 < y1) - (y1 < y0) + 1) + ((x0 < x1) - (x1 < x0) + 1))) & 7) - 1;
}
 
#if 1
// The lower 4 bits of the result are contained the octant code;
// the higher bits are contained the octant index.
 
// *************************************
// *      Octant codes and indexes     *
// *            |          |           *
// *   1001 = 9 | 1000 = 8 | 1010 = A  *
// *       2    |     3    |     4     *
// *  ----------+----------+---------- *
// *            |          |           *
// *   0001 = 1 | 0000 = 0 | 0010 = 2  *
// *       1    |    -1    |     5     *
// *  ----------+----------+---------- *
// *            |          |           *
// *   0101 = 5 | 0100 = 4 | 0110 = 6  *
// *       0    |     7    |     6     *
// *            |          |           *
// *************************************
 
enum OctantCodes
{
  kOC_Xmin = 1,
  kOC_Xmax = 2,
  kOC_Ymin = 4,
  kOC_Ymax = 8,
  kOC_Ishf = 4,   // Shift the code right to get octant index
  kOC_Cmsk = 0xF, // Mask the code to get octant Cohen-Sutherland code
};
 
template <
  typename wnd_x_type, typename wnd_y_type,
  typename pnt_x_type, typename pnt_y_type>
static int getOctantCodeAndIndex(
  const wnd_x_type /*wnd_*/x1,
  const wnd_y_type /*wnd_*/y1,
  const wnd_x_type /*wnd_*/x2,
  const wnd_y_type /*wnd_*/y2,
  const pnt_x_type /*pnt_*/x,
  const pnt_y_type /*pnt_*/y)
{
  int c = 0;
  if (!(x1 < x))
  {
    if ((x < x1))
      c = kOC_Xmin;
    if (!(y1 < y))
    {
      if ((y < y1))
        c |= kOC_Ymin;
      c |= (0 << kOC_Ishf);
    }
    else if (!(y < y2))
    {
      if ((y2 < y))
        c |= kOC_Ymax;
      c |= (2 << kOC_Ishf);
    }
    else
    {
      c |= (1 << kOC_Ishf);
    }
  }
  else if (!(x < x2))
  {
    if ((x2 < x))
      c = kOC_Xmax;
    if (!(y1 < y))
    {
      if ((y < y1))
        c |= kOC_Ymin;
      c |= (6 << kOC_Ishf);
    }
    else if (!(y < y2))
    {
      if ((y2 < y))
        c |= kOC_Ymax;
      c |= (4 << kOC_Ishf);
    }
    else
    {
      c |= (5 << kOC_Ishf);
    }
  }
  else // if (x1 < x && x < x2)
  {
    if (!(y1 < y))
    {
      if ((y < y1))
        c |= kOC_Ymin;
      c |= (7 << kOC_Ishf);
    }
    else if (!(y < y2))
    {
      if ((y2 < y))
        c |= kOC_Ymax;
      c |= (3 << kOC_Ishf);
    }
    else
    {
      c = (-1 << kOC_Ishf);
    }
  }
  return c;
}
 
#endif
} // namespace geometry
SDK_END_NAMESPACE
#endif
 
#endif // __cplusplus
 
#pragma pop_macro("min")
#pragma pop_macro("max")
#endif // SDK_GEOMETRY_BASE_TYPES_H_