geometry_base_types_helpers.h

Go to the documentation of this file.

#ifndef SDK_GEOMETRY_TYPES_HELPERS_H_
#define SDK_GEOMETRY_TYPES_HELPERS_H_
 
#include <iostream>
#include <vector>
#include <math.h>
#include <base/inc/platform.h>
#include <base/inc/base_types.h>
#include <base/inc/float_util.h>
#include <geometry/inc/coordinate_systems/crs_basic_transformation.inl>
 
#include "geometry_base_types.h"
 
namespace sdk {
 
// Classes declared in this file
class PointF2D;
class PointD2D;
class PointI2D;
class GeoPoint;
class SizeF;
class SizeD;
class Size;
class RectF2D;
class RectD2D;
class RectI2D;
typedef RectI2D Rect2D;
class RoundRectF2D;
class QBezierSegment;
class CuBezierSegment;
 
typedef std::vector< PointF2D > PointF2DVec;
typedef std::vector< PointD2D > PointD2DVec;
typedef std::vector< PointI2D > PointI2DVec;
typedef std::vector< SizeF > SizeFVec;
typedef std::vector< SizeD > SizeDVec;
typedef std::vector< Size > SizeVec;
typedef std::vector< RectF2D > RectF2DVec;
typedef std::vector< RectD2D > RectD2DVec;
typedef std::vector< RectI2D > RectI2DVec, Rect2DVec;
typedef std::vector< RoundRectF2D > RoundRectF2DVec;
typedef std::vector< QBezierSegment > QBezierSegmentVec;
typedef std::vector< CuBezierSegment > CuBezierSegmentVec;
typedef std::vector< SDKGeoPoint > SDKGeoPointVec;
typedef std::vector< SDKGeoIntPoint > SDKGeoIntPointVec;
 
class PointF2D : public SDKPointF2D {
public:
  // Constructors
  // Uninitialized PointF2D
  PointF2D() noexcept { x = y = 0.0; }
  // Copy constructor
  PointF2D(const SDKPointF2D& src_pt) noexcept : SDKPointF2D(src_pt) {}
  PointF2D(const SDKPointD2D& src_pt) noexcept {
    x = coordinate_type(src_pt.x);
    y = coordinate_type(src_pt.y);
  }
 
  // From x and y
  PointF2D(float init_x, float init_y) noexcept { x = init_x, y = init_y; }
  // Operations
  PointF2D& operator=(const SDKPointF2D& src_pt) noexcept {
    x = src_pt.x, y = src_pt.y;
    return *this;
  }
 
  PointF2D& operator=(const SDKPointD2D& src_pt) noexcept {
    x = coordinate_type(src_pt.x);
    y = coordinate_type(src_pt.y);
    return *this;
  }
 
  PointF2D& operator+=(const SDKPointF2D& src_pt) noexcept {
    x += src_pt.x, y += src_pt.y;
    return *this;
  }
 
  PointF2D& operator-=(const SDKPointF2D& src_pt) noexcept {
    x -= src_pt.x, y -= src_pt.y;
    return *this;
  }
 
  #if 0
  bool operator!=(const PointF2D& pt) const noexcept {return !operator==(pt);}
  bool operator==(const PointF2D& pt) const noexcept
  {
    if (fabs(x - pt.x) <= FLT_EPSILON && fabs(y - pt.y) <= FLT_EPSILON)
      return true;
 
    return false;
  }
  #endif
  typedef std::vector<PointF2D> container;
};
 
class PointD2D : public SDKPointD2D {
public:
  // Constructors
  // Uninitialized PointD2D
  PointD2D() noexcept { x = y = 0.0; }
  // Copy constructor
  PointD2D(const SDKPointD2D& src_pt) noexcept : SDKPointD2D(src_pt) {}
  // Copy constructor
  PointD2D(const SDKPointF2D& src_pt) noexcept { x = src_pt.x, y = src_pt.y; }
  // Copy constructor
  PointD2D(const SDKGeoPoint& src) noexcept { x = src.x, y = src.y; }
  // From x and y
  PointD2D(double init_x, double init_y) noexcept { x = init_x, y = init_y; }
  // Operations
  PointD2D& operator=(const SDKPointF2D& src_pt) noexcept {
    x = src_pt.x, y = src_pt.y;
    return *this;
  }
 
  PointD2D& operator=(const SDKPointD2D& src_pt) noexcept {
    *static_cast<SDKPointD2D*>(this) = src_pt;
    return *this;
  }
 
  PointD2D& operator+=(const SDKPointD2D& src_pt) noexcept
  {
    x += src_pt.x, y += src_pt.y;
    return *this;
  }
 
  PointD2D& operator-=(const SDKPointD2D& src_pt) noexcept
  {
    x -= src_pt.x, y -= src_pt.y;
    return *this;
  }
  #if 0
  bool operator!=(const PointD2D& pt) const noexcept {return !operator==(pt);}
  bool operator==(const PointD2D& pt) const noexcept
  {
    if (fabs(x - pt.x) <= FLT_EPSILON && fabs(y - pt.y) <= FLT_EPSILON)
      return true;
 
    return false;
  }
  double Length(const PointD2D& p) const noexcept {
    double dx = x - p.x;
    double dy = y - p.y;
    return sqrt(dx*dx + dy*dy);
  }
  #endif
 
  typedef std::vector<PointD2D> container;
};
 
class PointI2D : public SDKPointI2D {
public:
  // Constructors
  // Uninitialized Point2D
  PointI2D() noexcept { x = y = 0; }
  // Copy constructor
  PointI2D(const SDKPointI2D& src_pt) noexcept : SDKPointI2D(src_pt) {}
  // From x and y
  PointI2D(SDKInt32 init_x, SDKInt32 init_y) noexcept { x = init_x, y = init_y; }
  // Operations
  PointI2D& operator=(const SDKPointI2D& src_pt) noexcept {
    *static_cast<SDKPointI2D*>(this) = src_pt;
    return *this;
  }
 
  typedef std::vector<PointI2D> container;
  #if 0
  bool operator!=(const PointI2D& pt) const noexcept { return !operator==(pt); }
  bool operator==(const PointI2D& pt) const noexcept
  {
    if ((x == pt.x) && (y == pt.y))
      return true;
    return false;
  }
  #endif
};
 
class PointF3D : public SDKPointF3D {
public:
  PointF3D() noexcept { x = 0.f; y = 0.f; z = 0.f; }
 
  PointF3D(float _x, float _y, float _z) noexcept { x = _x; y = _y; z = _z; }
  PointF3D(const SDKPointF3D& src) noexcept : SDKPointF3D(src) {}
  PointF3D(const SDKPointD3D& src) noexcept {
    x = coordinate_type(src.x);
    y = coordinate_type(src.y);
    z = coordinate_type(src.z);
  }
 
  PointF3D& operator=(const SDKPointF3D& src) noexcept {
    *static_cast<SDKPointF3D*>(this) = src;
    return *this;
  }
 
  PointF3D& operator=(const SDKPointD3D& src) noexcept {
    x = coordinate_type(src.x);
    y = coordinate_type(src.y);
    z = coordinate_type(src.z);
    return *this;
  }
};
 
class PointD3D : public SDKPointD3D {
public:
  PointD3D() noexcept { x = 0.f; y = 0.f; z = 0.f; }
  PointD3D(double _x, double _y, double _z) noexcept { x = _x; y = _y; z = _z; }
  PointD3D(const SDKPointD3D& src) noexcept : SDKPointD3D(src) {}
  PointD3D(const SDKPointF3D& src) noexcept { x = src.x; y = src.y; z = src.z; }
  PointD3D& operator=(const SDKPointD3D& src) noexcept {
    *static_cast<SDKPointD3D*>(this) = src;
    return *this;
  }
 
  PointD3D& operator=(const SDKPointF3D& src) noexcept {
    x = coordinate_type(src.x);
    y = coordinate_type(src.y);
    z = coordinate_type(src.z);
    return *this;
  }
};
 
class SizeF : public SDKSizeF {
public:
  // Constructors
  // Uninitialized SizeF
  SizeF() noexcept { width = height = 0.0f; }
  // Copy constructor
  SizeF(const SDKSizeF& src_size) noexcept : SDKSizeF(src_size) {}
  SizeF(const SDKSizeD& src_size) noexcept {
    width = static_cast<float>(src_size.width);
    height = static_cast<float>(src_size.height);
  }
 
  SizeF(const SDKSize& src_size) noexcept {
    width = static_cast<float>(src_size.width);
    height = static_cast<float>(src_size.height);
  }
 
  // From width and height
  SizeF(float init_width, float init_height) noexcept {
    width = init_width, height = init_height;
  }
  #if 0
  // returns true if size width and height are 0
  bool IsNull() const noexcept {
    return (width == 0.0f && height == 0.0f);
  }
 
  // Returns true if size is equal to another size
  bool IsEqual(const SDKSizeF& s) const noexcept {
    return (fabs(width - s.width) <= FLT_EPSILON && fabs(height - s.height) <= FLT_EPSILON);
  }
 
  // Operations
  void operator=(const SDKSizeF& src_size) noexcept {
    width = src_size.width, height = src_size.height;
  }
  bool operator==(const SDKSizeF& s) const noexcept { return  IsEqual(s); }
  bool operator!=(const SDKSizeF& s) const noexcept { return !IsEqual(s); }
  #endif
  // Operations
  SizeF& operator=(const SDKSizeF& src_size) noexcept {
    *static_cast<SDKSizeF*>(this) = src_size;
    return *this;
  }
 
  SizeF& operator=(const SDKSizeD& src_size) noexcept {
    width = static_cast<coordinate_type>(src_size.width);
    height = static_cast<coordinate_type>(src_size.height);
    return *this;
  }
 
  SizeF& operator=(const SDKSize& src_size) noexcept {
    width = static_cast<coordinate_type>(src_size.width);
    height = static_cast<coordinate_type>(src_size.height);
    return *this;
  }
 
  typedef std::vector<SizeF> container;
};
 
class SizeD : public SDKSizeD {
public:
  // Constructors
  // Uninitialized SizeF
  SizeD() noexcept { width = height = 0.0f; }
  // Copy constructor
  SizeD(const SDKSizeD& src_size) noexcept : SDKSizeD(src_size) {}
  SizeD(const SDKSizeF& src_size) noexcept {
    width = src_size.width, height = src_size.height;
  }
 
  SizeD(const SDKSize& src_size) noexcept {
    width = static_cast<double>(src_size.width);
    height = static_cast<double>(src_size.height);
  }
 
  // From width and height
  SizeD(double init_width, double init_height) noexcept {
    width = init_width, height = init_height;
  }
  #if 0
  // returns true if size width and height are 0
  bool IsNull() const noexcept {
    return (width == 0.0f && height == 0.0f);
  }
 
  // Returns true if size is equal to another size
  bool IsEqual(const SDKSizeD& s) const noexcept {
    return (fabs(width - s.width) <= DBL_EPSILON && fabs(height - s.height) <= DBL_EPSILON);
  }
 
  // Operations
  void operator=(const SDKSizeD& src_size) noexcept {
    width = src_size.width, height = src_size.height;
  }
  bool operator==(const SDKSizeD& s) const noexcept { return  IsEqual(s); }
  bool operator!=(const SDKSizeD& s) const noexcept { return !IsEqual(s); }
  #endif
  // Operations
  SizeD& operator=(const SDKSizeD& src_size) noexcept {
    *static_cast<SDKSizeD*>(this) = src_size;
    return *this;
  }
 
  SizeD& operator=(const SDKSizeF& src_size) noexcept {
    width = static_cast<coordinate_type>(src_size.width);
    height = static_cast<coordinate_type>(src_size.height);
    return *this;
  }
 
  SizeD& operator=(const SDKSize& src_size) noexcept {
    width = static_cast<coordinate_type>(src_size.width);
    height = static_cast<coordinate_type>(src_size.height);
    return *this;
  }
 
  typedef std::vector<SizeD> container;
};
 
class Size : public SDKSize {
public:
  // Constructors
  // Uninitialized Size
  Size() { width = height = 0; }
  // Copy constructor
  Size(const SDKSize& src_size) noexcept : SDKSize(src_size) {}
  Size(const SDKSizeF& src_size) noexcept {
    width = static_cast<SDKUInt32>(src_size.width);
    height = static_cast<SDKUInt32>(src_size.height);
  }
 
  Size(const SDKSizeD& src_size) noexcept {
    width = static_cast<SDKUInt32>(src_size.width);
    height = static_cast<SDKUInt32>(src_size.height);
  }
 
  // From width and height
  Size(SDKUInt32 init_width, SDKUInt32 init_height) noexcept {
    width = init_width, height = init_height;
  }
 
  #if 0
  // 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 SDKSize& s) const noexcept {
    return (width == s.width && height == s.height);
  }
 
  // Operations
  void operator=(const SDKSize& src_size) noexcept {
    width = src_size.width, height = src_size.height;
  }
  bool operator==(const SDKSize& s) const noexcept { return  IsEqual(s); }
  bool operator!=(const SDKSize& s) const noexcept { return !IsEqual(s); }
  #endif
  // Operations
  Size& operator=(const SDKSize& src_size) noexcept {
    *static_cast<SDKSize*>(this) = src_size;
    return *this;
  }
 
  Size& operator=(const SDKSizeF& src_size) noexcept {
    width = static_cast<coordinate_type>(src_size.width);
    height = static_cast<coordinate_type>(src_size.height);
    return *this;
  }
 
  Size& operator=(const SDKSizeD& src_size) noexcept {
    width = static_cast<coordinate_type>(src_size.width);
    height = static_cast<coordinate_type>(src_size.height);
    return *this;
  }
 
  typedef std::vector<Size> container;
};
 
class RectF2D : public SDKRectF2D {
public:
  // Constructors
  // Uninitialized rectangle
  RectF2D() noexcept { x = y = width = height = 0.0f; }
  // Copy constructor
  RectF2D(const SDKRectF2D& src_r) noexcept : SDKRectF2D(src_r) {}
  // From x, y, width, height
  RectF2D(float init_x, float init_y, float init_w, float init_h) noexcept {
    x = init_x, y = init_y, width = init_w, height = init_h;
  }
 
  // From point and size
  RectF2D(const SDKPointF2D& pt, const SDKSizeF& size) noexcept {
    x = pt.x, y = pt.y, width = size.width, height = size.height;
  }
 
  // From size and offset to origin
  RectF2D(const SDKSizeF& size, const SDKPointF2D& org) noexcept {
    x = -org.x, y = -org.y, width = size.width, height = size.height;
  }
  #if 0
  // returns true if rectangle has no area
  bool IsEmpty() const noexcept { return (width == 0.0f && height == 0.0f); }
  // returns true if rectangle is at (0,0) and has no area
  bool IsNull() const noexcept {
    return (x == 0.0f && y == 0.0f && width == 0.0f && height == 0.0f);
  }
 
  // Returns true if rectangle is equal to another rectangle
  bool IsEqual(const SDKRectF2D& r) const noexcept {
    return (x == r.x && y == r.y && width == r.width && height == r.height);
  }
 
  PointF2D Center() {
    return PointF2D(x + width / 2.0f, y + height / 2.0f);
  }
  #endif
 
  RectF2D& Union(const SDKRectF2D& rc) {
    if (IsNull()) {
      *this = rc;
      return *this;
    }
    SDKPointF2D pts[2];
    pts[0].x = rc.x < x ? rc.x : x;
    pts[0].y = rc.y < y ? rc.y : y;
    pts[1].x = ((rc.x  + rc.width) > (x + width)) ?
      (rc.x  + rc.width) : (x + width);
    pts[1].y = ((rc.y  + rc.height) > (y + height)) ?
      (rc.y  + rc.height) : (y + height);
    x = pts[0].x;
    y = pts[0].y;
    width = pts[1].x - pts[0].x;
    height = pts[1].y - pts[0].y;
    return *this;
  }
 
  RectF2D& Intersect(const SDKRectF2D& rc) {
    RectF2D res; // Empty rectangle by default
    if (!IsEmpty() && !rc.IsEmpty() && x < rc.x + rc.width &&
      rc.x < x + width && y + height > rc.y && rc.y + rc.height > y) {
      // Two rectangles intersects
      res.x = (x > rc.x) ? x : rc.x;
      res.y = (y > rc.y) ? y : rc.y;
      res.width = (x + width < rc.x + rc.width) ?
        x + width - res.x : rc.x + rc.width - res.x;
      res.height = (y + height < rc.y + rc.height) ?
        y + height - res.y : rc.y + rc.height - res.y;
    }
 
    return *this = res;
  }
 
  // Operations
  RectF2D& operator=(const SDKRectF2D& src_r) noexcept {
    *static_cast<SDKRectF2D*>(this) = src_r;
    return *this;
  }
  #if 0
  bool operator==(const SDKRectF2D& r) const noexcept { return  IsEqual(r); }
  bool operator!=(const SDKRectF2D& r) const noexcept { return !IsEqual(r); }
  #endif
  RectF2D& operator |= (const SDKRectF2D& rc) {
    Union(rc);
    return *this;
  }
 
  // Old version
  bool IsIntersected(const SDKRectF2D& src) const noexcept {
     return !(IsEmpty() || (src.width == 0) || (src.height == 0) ||
            (x >= (src.x + src.width)) || (src.x >= (x + width)) ||
            (y >= (src.y + src.height)) || (src.y >= y + height));
  }
 
  // Returns false for empty operands, does not include right and top border
  bool IsIntersected_Geometrical(const SDKRectF2D& src) const noexcept {
     return !((width == 0) || (height == 0) || 
              (src.width == 0) || (src.height == 0) ||
              (x >= (src.x + src.width)) || (src.x >= (x + width)) ||
              (y >= (src.y + src.height)) || (src.y >= y + height));
  }
 
  // Intersects zero width/height rectangles, includes right and top border
  bool IsIntersected_Graphical(const SDKRectF2D& src) const noexcept {
     return !((x > (src.x + src.width)) || (src.x > (x + width)) ||
              (y > (src.y + src.height)) || (src.y > y + height));
  }
 
  bool IsIncludes(const SDKRectF2D& src) const noexcept {
    return (IsPointInRect(src.x, src.y) &&
            IsPointInRect(src.x + src.width, src.y + src.height));
  }
 
  bool IsPointInRect(float p_x, float p_y) const noexcept {
    if (IsNull())
      return false;
    return (p_x >= x && p_x <= (x + width) &&
            p_y >= y && p_y <= (y + height));
  }
 
  bool IsPointInRect(const SDKPointF2D& p) const noexcept {
      return IsPointInRect(p.x, p.y);
  }
 
  RectF2D& Expand(float factor) {
    float expand_x = width * factor;
    float expand_y = height * factor;
    x -= expand_x;
    y -= expand_y;
    width  += 2 * expand_x;
    height += 2 * expand_y;
    return *this;
  }
 
  typedef std::vector<RectF2D> container;
};
 
class RectD2D : public SDKRectD2D {
public:
  // Constructors
  // Uninitialized rectangle
  RectD2D() noexcept { x = y = width = height = 0.0f; }
 
  // Copy constructor
  RectD2D(const SDKRectD2D& src_r) noexcept
   : SDKRectD2D(src_r) {
  }
 
  // Copy constructor
  RectD2D(const SDKRectF2D& src_r) noexcept {
    x = src_r.x, y = src_r.y, width = src_r.width, height = src_r.height;
  }
  // From x, y, width, height
  RectD2D(double init_x, double init_y, double init_w, double init_h) noexcept {
    x = init_x, y = init_y, width = init_w, height = init_h;
  }
 
  // From point and size
  RectD2D(const SDKPointD2D& pt, const SDKSizeD& size) noexcept
  {
    x = pt.x, y = pt.y, width = size.width, height = size.height;
  }
 
  // From size and offset to origin
  RectD2D(const SDKSizeD& size, const SDKPointD2D& org) noexcept
  {
    x = -org.x, y = -org.y, width = size.width, height = size.height;
  }
 
  #if 0
  // returns true if rectangle has no area
  bool IsEmpty() const noexcept { return (width == 0.0f && height == 0.0f); }
  // returns true if rectangle is at (0,0) and has no area
  bool IsNull() const noexcept {
    return (x == 0.0f && y == 0.0f && width == 0.0f && height == 0.0f);
  }
  // Returns true if rectangle is equal to another rectangle
  bool IsEqual(const SDKRectD2D& r) const noexcept {
    return (x == r.x && y == r.y && width == r.width && height == r.height);
  }
  PointD2D Center()
  {
    return PointD2D(x + width / 2.0, y + height / 2.0);
  }
  #endif
  RectD2D& Union(const SDKRectD2D& rc)
  {
    if (IsNull()) {
      *this = rc;
      return *this;
    }
    point_type pts[2];
    pts[0].x = rc.x < x ? rc.x : x;
    pts[0].y = rc.y < y ? rc.y : y;
    pts[1].x = ((rc.x  + rc.width) > (x + width)) ? (rc.x  + rc.width) : (x + width);
    pts[1].y = ((rc.y  + rc.height) > (y + height)) ? (rc.y  + rc.height) : (y + height);
    x = pts[0].x;
    y = pts[0].y;
    width = pts[1].x - pts[0].x;
    height = pts[1].y - pts[0].y;
    return *this;
  }
 
  RectD2D& Intersect(const SDKRectD2D& rc)
  {
    RectD2D res; // Empty rectangle by default
    if (!IsEmpty() && !rc.IsEmpty()
      && x < rc.x + rc.width && rc.x < x + width
      && y + height > rc.y && rc.y + rc.height > y)
    {
      // Two rectangles intersects
      res.x = (x > rc.x) ? x : rc.x;
      res.y = (y > rc.y) ? y : rc.y;
      res.width = (x + width < rc.x + rc.width) ?
        x + width - res.x : rc.x + rc.width - res.x;
      res.height = (y + height < rc.y + rc.height) ?
        y + height - res.y : rc.y + rc.height - res.y;
    }
 
    return *this = res;
  }
 
  // Operations
  RectD2D& operator=(const SDKRectD2D& src_r) noexcept {
    *static_cast<SDKRectD2D*>(this) = src_r;
    return *this;
  }
 
  RectD2D& operator=(const SDKRectF2D& src_r) noexcept {
    x = src_r.x, y = src_r.y, width = src_r.width, height = src_r.height;
    return *this;
  }
 
  #if 0
  bool operator==(const SDKRectD2D& r) const noexcept { return  IsEqual(r); }
  bool operator!=(const SDKRectD2D& r) const noexcept { return !IsEqual(r); }
  #endif
  RectD2D& operator |= (const SDKRectD2D& rc)
  {
    Union(rc);
    return *this;
  }
 
  // Old version
  bool IsIntersected(const SDKRectD2D& src) const noexcept {
     return !(IsEmpty() || (src.width == 0) || (src.height == 0) ||
            (x >= (src.x + src.width)) || (src.x >= (x + width)) ||
            (y >= (src.y + src.height)) || (src.y >= y + height));
  }
 
  // Returns false for empty operands, does not include right and top border
  bool IsIntersected_Geometrical(const SDKRectD2D& src) const noexcept {
     return !((width == 0) || (height == 0) || 
              (src.width == 0) || (src.height == 0) ||
              (x >= (src.x + src.width)) || (src.x >= (x + width)) ||
              (y >= (src.y + src.height)) || (src.y >= y + height));
  }
 
  // Intersects zero width/height rectangles, includes right and top border
  bool IsIntersected_Graphical(const SDKRectD2D& src) const noexcept {
     return !((x > (src.x + src.width)) || (src.x > (x + width)) ||
              (y > (src.y + src.height)) || (src.y > y + height));
  }
 
  bool IsIncludes(const SDKRectD2D& src) const noexcept {
    return (IsPointInRect(src.x, src.y) &&
            IsPointInRect(src.x + src.width, src.y + src.height));
  }
 
  bool IsPointInRect(double p_x, double p_y) const noexcept {
    if (IsNull())
      return false;
    return (p_x >= x && p_x <= (x + width) &&
            p_y >= y && p_y <= (y + height));
  }
 
  bool IsPointInRect(const SDKPointD2D& p) const noexcept {
      return IsPointInRect(p.x, p.y);
  }
 
  RectD2D& Expand(double factor)
  {
    double expand_x = width * factor;
    double expand_y = height * factor;
    x -= expand_x;
    y -= expand_y;
    width  += 2 * expand_x;
    height += 2 * expand_y;
    return *this;
  }
 
  RectF2D GetRectF2D() const
  {
    RectF2D rect_f2d(
      static_cast<float>(x),
      static_cast<float>(y),
      static_cast<float>(width),
      static_cast<float>(height));
    return rect_f2d;
  }
 
  typedef std::vector<RectD2D> container;
};
 
class RectI2D : public SDKRectI2D {
  // Constructors
public:
  // Uninitialized rectangle
  RectI2D() noexcept { x = y = width = height = 0; }
  // Copy constructor
  RectI2D(const SDKRectI2D& src) noexcept
    : SDKRectI2D(src) {
  }
  // From x, y, width, height
  RectI2D(
    SDKInt32 init_x, SDKInt32 init_y,
    SDKUInt32 init_w, SDKUInt32 init_h) noexcept {
      x = init_x, y = init_y, width = init_w, height = init_h;
  }
  #if 0
  // 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 SDKRect2D& r) const noexcept {
    return (x == r.x && y == r.y && width == r.width && height == r.height);
  }
 
  // Operations
  void operator=(const SDKRectI2D& src_r) noexcept {
    x = src_r.x, y = src_r.y, width = src_r.width, height = src_r.height;
  }
 
  bool operator==(const SDKRect2D& r) const noexcept { return  IsEqual(r); }
  bool operator!=(const SDKRect2D& r) const noexcept { return !IsEqual(r); }
  #endif
  // Operations
  RectI2D& operator=(const SDKRectI2D& src_r) noexcept {
    *static_cast<SDKRectI2D*>(this) = src_r;
    return *this;
  }
  RectI2D& operator=(const SDKRectF2D& src_r) noexcept {
    x = point_type::coordinate_type(src_r.x);
    y = point_type::coordinate_type(src_r.y);
    width = size_type::coordinate_type(src_r.width);
    height = size_type::coordinate_type(src_r.height);
    return *this;
  }
  RectI2D& operator=(const SDKRectD2D& src_r) noexcept {
    x = point_type::coordinate_type(src_r.x);
    y = point_type::coordinate_type(src_r.y);
    width = size_type::coordinate_type(src_r.width);
    height = size_type::coordinate_type(src_r.height);
    return *this;
  }
 
  typedef std::vector<RectI2D> container;
};
 
class RoundRectF2D : public SDKRoundRectF2D {
public:
  // Constructors
  // Uninitialized rectangle
  RoundRectF2D() noexcept {
    rect.x = rect.y = rect.width = rect.height = rad_x = rad_y = 0.0f;
  }
  // Copy constructor
  RoundRectF2D(const SDKRoundRectF2D& src_r) noexcept : SDKRoundRectF2D(src_r) {}
  // From rect, rad_x, rad_y
  RoundRectF2D(const SDKRectF2D& init_r, float init_rad_x, float init_rad_y) noexcept {
    rect = init_r;
    rad_x = init_rad_x, rad_y = init_rad_y;
  }
  // Operations
  RoundRectF2D& operator=(const SDKRoundRectF2D& src_r) noexcept {
    *static_cast<SDKRoundRectF2D*>(this) = src_r;
    return *this;
  }
 
  typedef std::vector<RoundRectF2D> container;
};
 
class EllipseF2D : public SDKEllipseF2D {
public:
  // Constructors
  // Uninitialized ellipse
  EllipseF2D() noexcept { center.x = center.y = rad_x = rad_y = 0.0f; }
  // Copy constructor
  EllipseF2D(const SDKEllipseF2D& src_e) noexcept : SDKEllipseF2D(src_e) {}
  // From center, rad_x and rad_y
  EllipseF2D(const SDKPointF2D& init_pt, float init_rad_x, float init_rad_y) noexcept {
    center = init_pt;
    rad_x = init_rad_x, rad_y = init_rad_y;
  }
  // Operations
  EllipseF2D& operator=(const SDKEllipseF2D& src_e) noexcept {
    *static_cast<SDKEllipseF2D*>(this) = src_e;
    return *this;
  }
 
  typedef std::vector<EllipseF2D> container;
};
 
class QBezierSegment : public SDKQBezierSegment {
public:
  // Constructors
  // Uninitialized segment
  QBezierSegment() noexcept { pt1.x = pt1.y = pt2.x = pt2.y = 0.0f; }
  // Copy constructor
  QBezierSegment(const SDKQBezierSegment& src) noexcept : SDKQBezierSegment(src) {}
  // From two points
  QBezierSegment(const SDKPointF2D& init_pt1, const SDKPointF2D& init_pt2) noexcept {
    pt1 = init_pt1;
    pt2 = init_pt2;
  }
  // From 4 coordinates
  QBezierSegment(float x_c, float y_c, float x_end, float y_end) noexcept {
    pt1.x = x_c, pt1.y = y_c;
    pt2.x = x_end, pt2.y = y_end;
  }
  // Operations
  QBezierSegment& operator=(const SDKQBezierSegment& src) noexcept {
    *static_cast<SDKQBezierSegment*>(this) = src;
    return *this;
  }
 
  typedef std::vector<QBezierSegment> container;
};
 
class CuBezierSegment : public SDKCuBezierSegment {
public:
  // Constructors
  // Uninitialized segment
  CuBezierSegment() noexcept {
    pt1.x = pt1.y = pt2.x = pt2.y = pt3.x = pt3.y = 0.0f;
  }
  // Copy constructor
  CuBezierSegment(const SDKCuBezierSegment& src) noexcept : SDKCuBezierSegment(src) {}
  // From three points
  CuBezierSegment(
    const SDKPointF2D& init_pt1, const SDKPointF2D& init_pt2, const SDKPointF2D& init_pt3) noexcept {
      pt1 = init_pt1;
      pt2 = init_pt2;
      pt3 = init_pt3;
  }
  // From 6 coordinates
  CuBezierSegment(float x_c1, float y_c1, float x_c2, float y_c2,
    float x_end, float y_end) noexcept {
    pt1.x = x_c1, pt1.y = y_c1;
    pt2.x = x_c2, pt2.y = y_c2;
    pt3.x = x_end, pt3.y = y_end;
  }
  // Operations
  CuBezierSegment& operator=(const SDKCuBezierSegment& src) noexcept {
    *static_cast<SDKCuBezierSegment*>(this) = src;
    return *this;
  }
 
  typedef std::vector<CuBezierSegment> container;
};
 
class GeoPoint : public SDKGeoPoint {
public:
  GeoPoint() noexcept {
    x = SDK_MAX_DOUBLE;
    y = SDK_MAX_DOUBLE;
  }
 
  GeoPoint(double _x, double _y) noexcept { 
    x = _x;
    y = _y;
  }
 
  GeoPoint(const GeoPoint& src) noexcept { 
    x = src.x;
    y = src.y;
  }
 
  GeoPoint(const SDKGeoPoint& src) noexcept { 
    x = src.x;
    y = src.y;
  }
 
  GeoPoint(const SDKPointD2D& src) noexcept {
    x = src.x;
    y = src.y;
  }
 
  #if 0
  bool IsValid() const
  {
    return (x > kDegLonMax || x < kDegLonMin 
         || y > kDegLatMax || y < kDegLatMin) ? false : true;
  }
 
  // Returns true if geopoint is equal to another geopoint
  bool IsEqual(const GeoPoint& 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) >= FLT_EPSILON)
      return false;
    if (fabs(y - pt.y) >= FLT_EPSILON)
      return false;
 
    return true;
  }
  #endif
  // Operations
  GeoPoint& operator=(const SDKGeoPoint& src) noexcept {
    *static_cast<SDKGeoPoint*>(this) = src;
    return *this;
  }
  #if 0
  bool operator==(const GeoPoint& pt) const noexcept { return  IsEqual(pt); }
  bool operator!=(const GeoPoint& pt) const noexcept { return !IsEqual(pt); }
  #endif
  typedef std::vector<GeoPoint> container;
 
private:
 
  GeoPoint(SDKInt32 x, SDKInt32 y) {
  }
};
 
template <typename _GeoDistance, typename _GeoCoordinate>
static inline _GeoDistance GeoLonDistance(_GeoCoordinate lon1, _GeoCoordinate lon2);
 
static inline GeoIntDistance GeoIntLonDistance(GeoInt lon1, GeoInt lon2) {
  //return (lon1 <= lon2) ? lon2 - lon1 : kGeoIntLonMax - lon1 + lon2 - kGeoIntLonMin;
  // The same but for what?
  //return lon2 - lon1 - GeoInt(lon2 < lon1);
  return GeoIntDistance(lon2 - lon1);
}
 
static inline GeoIntDistance GeoLonDistance(GeoInt lon1, GeoInt lon2) {
  return GeoIntLonDistance(lon1, lon2);
}
 
static inline double GeoLonDistance(double lon1, double lon2) {
  //return lon2 - lon1 + ((lon2 - lon1) < 0 ? kDegLonFull : 0);
  // Commented formula (above) give different results in the following cases:
  // 179.97777777777779 -> +180.0 = 0.022222222222211485
  // 179.97777777777779 -> -180.0 = 0.022222222222239907
  // Formula below works better, it gives the same results
  return (lon1 <= lon2) ? lon2 - lon1 : kDegLonMax - lon1 + lon2 - kDegLonMin;
}
 
static inline double GeoLonDistanceMin(double lon1, double lon2)
{
  double dist1 = GeoLonDistance(lon1, lon2);
  double dist2 = GeoLonDistance(lon2, lon1);
  return (dist1 <= dist2) ? dist1 : dist2;
}
 
static inline GeoIntDistance GeoIntLonComplimentDistance(GeoIntDistance lon_distance) {
  //return kGeoIntLonFull - lon_distance;
  return GeoIntDistance(-GeoInt(lon_distance));
}
 
static inline GeoIntDistance GeoLonComplimentDistance(GeoIntDistance lon_distance) {
  return GeoIntLonComplimentDistance(lon_distance);
}
 
static inline double GeoLonComplimentDistance(double lon_distance) {
  return kDegLonFull - lon_distance;
}
 
static inline GeoInt GeoIntLonShift(GeoInt lon, GeoInt shift) {
  return lon + shift;
}
 
static inline GeoInt GeoLonShift(GeoInt lon, GeoInt shift) {
  return GeoIntLonShift(lon, shift);
}
 
static inline double GeoLonShift(double lon, double shift) {
  //double new_lon = lon + shift;
  //return (new_lon > kDegLonMax) ? kDegLonMin + new_lon - kDegLonMax : new_lon;
  using std::fmod;
  double new_lon = fmod(lon + shift, kDegLonFull);
  if (new_lon >= kDegLonMax)
    new_lon -= kDegLonFull;
  else if (new_lon < kDegLonMin)
    new_lon += kDegLonFull;
  return new_lon;
}
 
static inline bool IsGeoIntLonInside(GeoInt lon, GeoInt lon1, GeoInt lon2) {
  //if (lon1 <= lon2)
  //  return ((lon >= lon1) && (lon <= lon2));
  //return ((lon >= kGeoIntLonMin) && (lon <= lon2)) ||
  //       ((lon >= lon1) && (lon <= kGeoIntLonMax));
  return GeoIntDistance(lon - lon1) <= GeoIntDistance(lon2 - lon1);
}
 
static inline bool IsGeoLonInside(GeoInt lon, GeoInt lon1, GeoInt lon2) {
  return IsGeoIntLonInside(lon, lon1, lon2);
}
 
// Simple version which does not take into account that -180/180 is the same
static inline bool IsGeoLonInsideR(double lon, double lon1, double lon2) {
  if (lon1 <= lon2)
    return ((lon1 <= lon) && (lon <= lon2));
  return ((kDegLonMin <= lon) && (lon <= lon2)) ||
         ((lon1       <= lon) && (lon <= kDegLonMax));
}
 
static inline bool IsGeoLonInside(double lon, double lon1, double lon2) {
  //
  //return GeoLonDistance(lon1, lon) <= GeoLonDistance(lon1, lon2);
  //
  // Version with distances (commented) seem to be more simple but it is affected 
  // by double accuracy, because it uses double calculations.
  // Version with ranges (below) work in 100% cases and any accuracy.
  // 'If' solves the problem of -180/180 w/o adding any calculations.
  if (kDegLonMin == lon || kDegLonMax == lon)
    return IsGeoLonInsideR(lon, lon1, lon2) || IsGeoLonInsideR(-lon, lon1, lon2);
  return IsGeoLonInsideR(lon, lon1, lon2);
}
 
static inline GeoIntDistance GeoIntLatDistance(GeoInt lat1, GeoInt lat2) {
  return (lat1 <= lat2) ? lat2 - lat1 : lat1 - lat2;
}
 
static inline GeoIntDistance GeoLatDistance(GeoInt lat1, GeoInt lat2) {
  using std::abs;
  return abs(lat2 - lat1);
}
 
static inline double GeoLatDistance(double lat1, double lat2) {
  //return (lat1 <= lat2) ? lat2 - lat1 : lat1 - lat2;
  using std::abs;
  return abs(lat2 - lat1);
}
 
static inline GeoInt GeoIntLatShift(GeoInt lat, GeoInt shift) {
  if (shift >= 0)
    return (GeoIntLatDistance(lat, kGeoIntLatMax) > GeoIntDistance(shift))
           ? lat + shift : kGeoIntLatMax;
  else
    return (GeoIntLatDistance(kGeoIntLatMin, lat) > GeoIntDistance(-shift))
           ? lat + shift : kGeoIntLatMin;
}
 
static inline GeoInt GeoLatShift(GeoInt lat, GeoInt shift) {
  return GeoIntLatShift(lat, shift);
}
 
static inline double GeoLatShift(double lat, const double& shift) {
  double new_lat = lat + shift;
  if (new_lat > kDegLatMax)
    return kDegLatMax;
  if (new_lat < kDegLatMin)
    return kDegLatMin;
  return new_lat;
}
 
static inline bool IsGeoIntLatInside(GeoInt lat, GeoInt lat1, GeoInt lat2) {
  if (lat1 <= lat2)
    return ((lat >= lat1) && (lat <= lat2));
  else
    return ((lat >= lat2) && (lat <= lat1));
}
 
static inline bool IsGeoLatInside(GeoInt lat, GeoInt lat1, GeoInt lat2) {
  return IsGeoIntLatInside(lat, lat1, lat2);
}
 
static inline bool IsGeoLatInside(double lat, double lat1, double lat2) {
  if (lat1 <= lat2)
    return ((lat >= lat1) && (lat <= lat2));
  else
    return ((lat >= lat2) && (lat <= lat1));
}
 
static inline double NormalizeGeoLon(double lon) {
  using std::fmod;
  lon = fmod(lon, kDegLonFull);
  if (lon >= kDegLonMax)
    lon -= kDegLonFull;
  else if (lon < kDegLonMin)
    lon += kDegLonFull;
  //while (lon > kDegLonMax)
  //  lon -= kDegLonFull;
  //while (lon < kDegLonMin)
  //  lon += kDegLonFull;
  return lon;
}
 
static inline double NormalizeGeoLat(double lat) {
  if (lat > kDegLatMax)
    lat = kDegLatMax;
  else if (lat < kDegLatMin)
    lat = kDegLatMin;
  return lat;
}
 
class GeoIntPoint : public SDKGeoIntPoint {
public:
  GeoIntPoint() noexcept {
    x = y = 0;
  }
  GeoIntPoint(GeoInt _x, GeoInt _y) noexcept {
    x = _x; y = _y;
  }
  GeoIntPoint(const SDKGeoIntPoint& src) noexcept {
    x = src.x; y = src.y;
  }
  GeoIntPoint(const GeoIntPoint& src) noexcept {
    x = src.x; y = src.y;
  }
  // Operations
  void operator=(const GeoIntPoint& src) noexcept {
    x = src.x; y = src.y;
  }
 
  typedef std::vector<GeoIntPoint> container;
};
 
class GeoIntPoint3D : public SDKGeoIntPoint3D {
public:
  GeoIntPoint3D() noexcept {
    x = y = 0; z = 0.0;
  }
  GeoIntPoint3D(GeoInt _x, GeoInt _y, double _z) noexcept {
    x = _x; y = _y; z = _z;
  }
  GeoIntPoint3D(const GeoIntPoint3D& src) noexcept {
    x = src.x; y = src.y; z = src.z;
  }
  // Operations
  void operator=(const GeoIntPoint3D& src) noexcept {
    x = src.x; y = src.y; z = src.z;
  }
 
  typedef std::vector<GeoIntPoint3D> container;
};
 
class GeoPoint3D : public SDKGeoPoint3D {
public:
  GeoPoint3D() {
    x = y = z = 0.0;
  }
  GeoPoint3D(double _x, double _y, double _z)  {
    x = _x; y = _y; z = _z;
  }
  GeoPoint3D(const GeoPoint3D& src) {
    x = src.x; y = src.y; z = src.z;
  }
  // Operations
  void operator=(const GeoPoint3D& src) {
    x = src.x; y = src.y; z = src.z;
  }
 
  typedef std::vector<GeoPoint3D> container;
};
 
class GeoIntRect : public SDKGeoIntRect {
public:
  GeoIntRect() noexcept {
    sw.x = sw.y = ne.x = ne.y = 0;
  }
 
  GeoIntRect(const GeoIntPoint& _sw, const GeoIntPoint& _ne) noexcept {
    sw = _sw; ne = _ne;
  }
 
  GeoIntRect(GeoInt sw_lon, GeoInt sw_lat, GeoInt ne_lon, GeoInt ne_lat
    ) noexcept {
    SetRect(sw_lon, sw_lat, ne_lon, ne_lat);
  }
 
  GeoIntRect(const SDKGeoIntRect& src) noexcept {
    SetRect(src.sw.lon, src.sw.lat, src.ne.lon, src.ne.lat);
  }
 
  // Default copy constructor is suitable here
  //GeoIntRect(const GeoIntRect& src) noexcept { *this = src; }
 
  // Operations
  // Default operator=() is suitable here
  //void operator=(const GeoIntRect& src) noexcept { sw = src.sw; ne = src.ne; }
  bool operator&(const GeoIntRect& src) noexcept {
    return IsIntersected(*this, src);
  }
 
  void SetRect(GeoInt sw_lon, GeoInt sw_lat, GeoInt ne_lon, GeoInt ne_lat
    ) noexcept {
    sw.lat = sw_lat; sw.lon = sw_lon; ne.lat = ne_lat; ne.lon = ne_lon;
  }
 
  bool IsNormalized() const noexcept {
    return (sw.lon <= ne.lon) && (sw.lat <= ne.lat);
  }
 
  // returns TRUE if rectangle has no area
  bool IsRectEmpty() const noexcept {
    return ((min.x == max.x) || (min.y == max.y)) ? true : false;
  }
 
  // returns TRUE if rectangle is at (0,0) and has no area
  bool IsRectNull() const noexcept {
    return (min.x == 0 && min.y == 0 &&
      max.x == 0 && max.y == 0) ? true : false;
  }
 
  // pointer to the array of 2 rectangles.
#ifndef SDK_CC_BCC
  SDKUInt32 Normalize(GeoIntRect (&rects)[2]) const noexcept {
#else
  SDKUInt32 Normalize(GeoIntRect* rects) const noexcept {
#endif
    if (ne.lat < sw.lat) {
      return 0; // Wrong case
    }
    if (sw.lon <= ne.lon) {
      rects[0] = *this;
      return 1;
    }
    rects[0] = GeoIntRect(sw.lon, sw.lat, kGeoIntLonMax, ne.lat);
    rects[1] = GeoIntRect(kGeoIntLonMin, sw.lat, ne.lon, ne.lat);
    return 2;
  }
 
  bool IsIntersected(const SDKGeoIntRect& r) const noexcept {
    return IsIntersected(*this, r);
  }
 
  static bool IsIntersected(
    const SDKGeoIntRect& r1,
    const SDKGeoIntRect& r2) noexcept {
 
    if (r1.sw.lon > r1.ne.lon) // over 180 rectangle
      return IsIntersected(r2,
        GeoIntRect(r1.sw.lon, r1.sw.lat, kGeoIntLonMax, r1.ne.lat))
      || IsIntersected(r2,
        GeoIntRect(kGeoIntLonMin, r1.sw.lat, r1.ne.lon, r1.ne.lat));
 
    if (r2.sw.lon > r2.ne.lon) // over 180 rectangle
      return IsIntersected(r2, r1);
 
    return ((r1.sw.lon <= r2.ne.lon && r1.ne.lon >= r2.sw.lon) &&
            (r1.sw.lat <= r2.ne.lat && r1.ne.lat >= r2.sw.lat));
  }
 
  static SDKGeoIntRect Union(const SDKGeoIntRect& r1,
    const SDKGeoIntRect& r2) noexcept {
 
    GeoIntRect res = r1;
    res.Union(r2);
    return res;
  }
 
  GeoIntRect& Union(const SDKGeoIntRect& _r2) noexcept {
 
    GeoIntRect& r1 = *this;
    const GeoIntRect& r2 = static_cast<const SDKGeoIntRect&>(_r2);
 
    if (r1.IsRectNull())
      return (*this = r2), *this;
    if (r2.IsRectNull())
      return *this;
 
    if (r1.ne.lat < r1.sw.lat || r2.ne.lat < r2.sw.lat) {
      this->~GeoIntRect();
      new (this) GeoIntRect();
      return *this;
    }
 
    // at first check cases when rects are intersected along longitude.
    GeoInt sw_lon = 0, ne_lon = 0;
    if ((r1.sw.lon == r2.sw.lon) && (r1.ne.lon == r2.ne.lon)) {
      sw_lon = r1.sw.lon, ne_lon = r1.ne.lon;
    } else {
      bool is_r1_lon_tail_in_r2 = IsGeoIntLonInside(r1.ne.lon, r2.sw.lon, r2.ne.lon);
      bool is_r2_lon_tail_in_r1 = IsGeoIntLonInside(r2.ne.lon, r1.sw.lon, r1.ne.lon);
      bool is_r1_lon_nose_in_r2 = IsGeoIntLonInside(r1.sw.lon, r2.sw.lon, r2.ne.lon);
      bool is_r2_lon_nose_in_r1 = IsGeoIntLonInside(r2.sw.lon, r1.sw.lon, r1.ne.lon);
      if (is_r1_lon_tail_in_r2 && is_r2_lon_tail_in_r1 &&
          is_r1_lon_nose_in_r2 && is_r2_lon_nose_in_r1)
        sw_lon = kGeoIntLonMin, ne_lon = kGeoIntLonMax;
      else if (is_r1_lon_nose_in_r2 && is_r1_lon_tail_in_r2)
        sw_lon = r2.sw.lon, ne_lon = r2.ne.lon; // r1 is inside r2
      else if (is_r2_lon_nose_in_r1 && is_r2_lon_tail_in_r1)
        sw_lon = r1.sw.lon, ne_lon = r1.ne.lon; // r2 is inside r1
      else if (is_r1_lon_tail_in_r2)
        sw_lon = r1.sw.lon, ne_lon = r2.ne.lon; // partly intersected
      else if (is_r2_lon_tail_in_r1)
        sw_lon = r2.sw.lon, ne_lon = r1.ne.lon; // partly intersected
      else // not intersected along longitude.
      if (GeoIntLonDistance(r1.ne.lon, r2.sw.lon) < GeoIntLonDistance(r2.ne.lon, r1.sw.lon))
        sw_lon = r1.sw.lon, ne_lon = r2.ne.lon; // r1 on the left of r2
      else
        sw_lon = r2.sw.lon, ne_lon = r1.ne.lon; // r1 on the right of r2
    }
 
    // then check cases when rects are intersected along latitude.
#if 1
    // Latitudes are comparable in the Cartesian style so it is no need
    // to calculate them in a such complicated manner.
    GeoInt sw_lat = (r1.sw.lat <= r2.sw.lat) ? r1.sw.lat : r2.sw.lat;
    GeoInt ne_lat = (r1.ne.lat >= r2.ne.lat) ? r1.ne.lat : r2.ne.lat;
#else
    GeoInt sw_lat = 0, ne_lat = 0;
    if ((r1.sw.lat == r2.sw.lat) && (r1.ne.lat == r2.ne.lat)) {
      sw_lat = r1.sw.lat, ne_lat = r1.ne.lat;
    } else {
      bool is_r1_lat_tail_in_r2 = IsGeoIntLatInside(r1.ne.lat, r2.sw.lat, r2.ne.lat);
      bool is_r2_lat_tail_in_r1 = IsGeoIntLatInside(r2.ne.lat, r1.sw.lat, r1.ne.lat);
      bool is_r1_lat_nose_in_r2 = IsGeoIntLatInside(r1.sw.lat, r2.sw.lat, r2.ne.lat);
      bool is_r2_lat_nose_in_r1 = IsGeoIntLatInside(r2.sw.lat, r1.sw.lat, r1.ne.lat);
      if (is_r1_lat_tail_in_r2 && is_r2_lat_tail_in_r1 &&
          is_r1_lat_nose_in_r2 && is_r2_lat_nose_in_r1)
        sw_lat = kGeoIntLatMin, ne_lat = kGeoIntLatMax;
      else if (is_r1_lat_nose_in_r2 && is_r1_lat_tail_in_r2)
        sw_lat = r2.sw.lat, ne_lat = r2.ne.lat; // r1 is inside r2
      else if (is_r2_lat_nose_in_r1 && is_r2_lat_tail_in_r1)
        sw_lat = r1.sw.lat, ne_lat = r1.ne.lat; // r2 is inside r1
      else if (is_r1_lat_tail_in_r2)
        sw_lat = r1.sw.lat, ne_lat = r2.ne.lat; // partly intersected
      else if (is_r2_lat_tail_in_r1)
        sw_lat = r2.sw.lat, ne_lat = r1.ne.lat; // partly intersected
      else // not intersected along latitude
      if (GeoIntLatDistance(r1.ne.lat, r2.sw.lat) < GeoIntLatDistance(r2.ne.lat, r1.sw.lat))
        sw_lat = r1.sw.lat, ne_lat = r2.ne.lat; // r1 below r2
      else
        sw_lat = r2.sw.lat, ne_lat = r1.ne.lat; // r1 above r2
    }
#endif
 
    //return sdk::GeoIntRect(sw_lon, sw_lat, ne_lon, ne_lat);
    sw.lon = sw_lon;
    sw.lat = sw_lat;
    ne.lon = ne_lon;
    ne.lat = ne_lat;
    return *this;
  }
 
  bool PointInRect(const GeoIntPoint& p) const noexcept {
    return PointInRect(p, *this);
  }
 
  static bool PointInRect(
    const SDKGeoIntPoint& p,
    const SDKGeoIntRect& r) noexcept {
#if 1
    if (GeoIntDistance(p.lon - r.sw.lon)
        > GeoIntDistance(r.ne.lon - r.sw.lon))
      return false;
    return r.sw.lat <= p.lat && p.lat <= r.ne.lat;
#else
    if (r.IsRectNull())
      return false;
    if (r.ne.lat < r.sw.lat) // Wrong case
      return false;
    if (r.sw.lon > r.ne.lon) // over 180 rectangle
      return PointInRect(p,
              GeoIntRect(r.sw.lon, r.sw.lat, kGeoIntLonMax, r.ne.lat))
          || PointInRect(p,
              GeoIntRect(kGeoIntLonMin, r.sw.lat, r.ne.lon, r.ne.lat));
    return (p.lon >= r.sw.lon && p.lon <= r.ne.lon &&
            p.lat >= r.sw.lat && p.lat <= r.ne.lat);
#endif
  }
 
  GeoIntPoint Center() const noexcept {
#if 1
    GeoIntPoint center(
      GeoInt(sw.lon + (GeoIntDistance(ne.lon - sw.lon) >> 1)),
      (sw.lat + ne.lat) / 2);
    return center;
#else
    GeoIntPoint center;
    if (sw.x == ne.x) {
      center.x = sw.x;
    } else {
      double sw_x = DegFromGeoInt(sw.x);
      double ne_x = DegFromGeoInt(ne.x);
      if (sw_x > ne_x)
        ne_x += 360.0;
 
      double center_x = sw_x + ((ne_x - sw_x) / 2);
      while(center_x >= 360.0) // Normalize x
        center_x -= 360.0;
 
      center.x = GeoIntFromDeg(center_x);
    }
 
    if (sw.y == ne.y)
      center.y = sw.y;
    else
      center.y = (sw.y + ne.y) / 2;
#endif
    return center;
  }
 
  typedef std::vector<GeoIntRect> container;
};
 
inline bool operator==(const GeoIntRect& r1, const GeoIntRect& r2) {
  return (r1.sw.lon == r2.sw.lon) && (r1.sw.lat == r2.sw.lat) &&
         (r1.ne.lon == r2.ne.lon) && (r1.ne.lat == r2.ne.lat);
}
 
class GeoPointRect;
inline bool operator==(const GeoPointRect& r1, const GeoPointRect& r2);
 
class GeoPointRect : public SDKGeoPointRect {
public:
  GeoPointRect() noexcept { sw.lat = sw.lon = ne.lat = ne.lon = 0.0; }
  GeoPointRect(const GeoPoint& _sw, const GeoPoint& _ne) noexcept {
    sw = _sw; ne = _ne;
  }
 
  GeoPointRect(double sw_lon, double sw_lat, double ne_lon, double ne_lat
    ) noexcept {
    SetRect(sw_lon, sw_lat, ne_lon, ne_lat);
  }
 
  GeoPointRect(const SDKGeoPointRect& src) noexcept {
    sw.lon = src.sw.lon; sw.lat = src.sw.lat;
    ne.lon = src.ne.lon; ne.lat = src.ne.lat; }
 
  // Default copy constructor is suitable here
  //GeoPointRect(const GeoPointRect& src) noexcept { *this = src; }
  // Operations
  // Default copy operator is suitable here
  //void operator=(const GeoPointRect& src) noexcept { sw = src.sw; ne = src.ne; }
 
  void SetRect(double sw_lon, double sw_lat, double ne_lon, double ne_lat
    ) noexcept {
    sw.lat = sw_lat; sw.lon = sw_lon; ne.lat = ne_lat; ne.lon = ne_lon;
  }
 
  // returns TRUE if rectangle has no area
  bool IsRectEmpty() const noexcept {
    return ((min.x == max.x) || (min.y == max.y));
  }
 
  // returns TRUE if rectangle is at (0,0) and has no area
  bool IsRectNull() const noexcept {
    return (min.x == 0.0 && min.y == 0.0 &&
      max.x == 0.0 && max.y == 0.0);
  }
 
  // pointer to the array of 2 rectangles.
#ifndef SDK_CC_BCC
  SDKUInt32 Normalize(GeoPointRect (&rects)[2]) const noexcept {
#else
  SDKUInt32 Normalize(GeoPointRect* rects) const noexcept {
#endif
    if (ne.lat < sw.lat) {
      return 0;
    }
 
    if (sw.lon <= ne.lon) {
      rects[0] = *this;
      return 1;
    }
 
    rects[0] = GeoPointRect(sw.lon, sw.lat, kDegLonMax, ne.lat);
    rects[1] = GeoPointRect(kDegLonMin, sw.lat, ne.lon, ne.lat);
    return 2;
  }
 
  bool IsIntersected(const SDKGeoPointRect& r) const noexcept {
    return IsIntersected(*this, r);
  }
 
  static bool IsIntersectedSimple(const SDKGeoPointRect& r1,
    const SDKGeoPointRect& r2) noexcept {
 
    return ((r1.sw.lon <= r2.ne.lon && r1.ne.lon >= r2.sw.lon) &&
            (r1.sw.lat <= r2.ne.lat && r1.ne.lat >= r2.sw.lat));
  }
 
  static bool IsIntersected(const SDKGeoPointRect& r1,
    const SDKGeoPointRect& r2) noexcept {
 
    auto right_rect = [](const SDKGeoPointRect& r) {
      return GeoPointRect(r.sw.lon, r.sw.lat, kDegLonMax, r.ne.lat); };
    auto left_rect = [](const SDKGeoPointRect& r) {
      return GeoPointRect(kDegLonMin, r.sw.lat, r.ne.lon, r.ne.lat); };
 
    if ((r1.sw.lon > r1.ne.lon) && // over 180
        (r2.sw.lon > r2.ne.lon))   // over 180
    {
      return IsIntersectedSimple(right_rect(r1), right_rect(r2))
          || IsIntersectedSimple(right_rect(r1), left_rect(r2))
          || IsIntersectedSimple(left_rect(r1), right_rect(r2))
          || IsIntersectedSimple(left_rect(r1), left_rect(r2));
    }
 
    if (r1.sw.lon > r1.ne.lon) // over 180
    {
      return IsIntersectedSimple(right_rect(r1), r2)
          || IsIntersectedSimple(left_rect(r1), r2);
    }
 
    if (r2.sw.lon > r2.ne.lon) // over 180
    {
      return IsIntersectedSimple(r1, right_rect(r2))
          || IsIntersectedSimple(r1, left_rect(r2));
    }
 
    return IsIntersectedSimple(r1, r2);
  }
 
  static bool PointInRect(const GeoPoint& p,
    const GeoPointRect& r) noexcept {
 
      if (r.IsRectNull())
        return false;
      if (r.sw.lon > r.ne.lon) // over 180 rectangle
        return PointInRect(p,
                GeoPointRect(r.sw.lon, r.sw.lat, kDegLonMax, r.ne.lat))
            || PointInRect(p,
                GeoPointRect(kDegLonMin, r.sw.lat, r.ne.lon, r.ne.lat));
      return (p.lon >= r.sw.lon && p.lon <= r.ne.lon &&
              p.lat >= r.sw.lat && p.lat <= r.ne.lat);
  }
 
  // Returns True if r1 is completely inside r2
  static bool RectInRect(const GeoPointRect& r1,
    const GeoPointRect& r2) noexcept {
 
    GeoPointRect r = GeoPointRect::Union(r1, r2);
    return r == r2;
  }
 
  static GeoPointRect Union(
    const SDKGeoPointRect& r1,
    const SDKGeoPointRect& r2) noexcept {
 
    GeoPointRect res(r1);
    res.Union(r2);
    return res;
  }
 
  GeoPointRect& Union(const SDKGeoPointRect& r) noexcept {
 
    GeoPointRect& r1 = *this;
    const GeoPointRect& r2 = static_cast<const GeoPointRect&>(r);
    if (r1.IsRectNull())
      return r1 = r2;
    if (r2.IsRectNull())
      return r1;
    if (r1.ne.lat < r1.sw.lat || r2.ne.lat < r2.sw.lat) {
      this->~GeoPointRect();
      new (this) GeoPointRect();
      return *this;
    }
 
    // at first check cases when rects are intersected along longitude.
    double sw_lon = 0, ne_lon = 0;
    if ((r1.sw.lon == r2.sw.lon) && (r1.ne.lon == r2.ne.lon)) {
      sw_lon = r1.sw.lon, ne_lon = r1.ne.lon;
    } else {
      bool is_r1_lon_tail_in_r2 = IsGeoLonInside(r1.ne.lon, r2.sw.lon, r2.ne.lon);
      bool is_r2_lon_tail_in_r1 = IsGeoLonInside(r2.ne.lon, r1.sw.lon, r1.ne.lon);
      bool is_r1_lon_nose_in_r2 = IsGeoLonInside(r1.sw.lon, r2.sw.lon, r2.ne.lon);
      bool is_r2_lon_nose_in_r1 = IsGeoLonInside(r2.sw.lon, r1.sw.lon, r1.ne.lon);
      if (is_r1_lon_tail_in_r2 && is_r2_lon_tail_in_r1 &&
          is_r1_lon_nose_in_r2 && is_r2_lon_nose_in_r1)
        sw_lon = kDegLonMin, ne_lon = kDegLonMax;
      else if (is_r1_lon_nose_in_r2 && is_r1_lon_tail_in_r2)
        sw_lon = r2.sw.lon, ne_lon = r2.ne.lon; // r1 is inside r2
      else if (is_r2_lon_nose_in_r1 && is_r2_lon_tail_in_r1)
        sw_lon = r1.sw.lon, ne_lon = r1.ne.lon; // r2 is inside r1
      else if (is_r1_lon_tail_in_r2)
        sw_lon = r1.sw.lon, ne_lon = r2.ne.lon; // partly intersected
      else if (is_r2_lon_tail_in_r1)
        sw_lon = r2.sw.lon, ne_lon = r1.ne.lon; // partly intersected
      else // not intersected along longitude.
      if (GeoLonDistance(r1.ne.lon, r2.sw.lon) < GeoLonDistance(r2.ne.lon, r1.sw.lon))
        sw_lon = r1.sw.lon, ne_lon = r2.ne.lon; // r1 on the left of r2
      else
        sw_lon = r2.sw.lon, ne_lon = r1.ne.lon; // r1 on the right of r2
    }
 
    double sw_lat = r1.sw.lat < r2.sw.lat ? r1.sw.lat : r2.sw.lat;
    double ne_lat = r1.ne.lat > r2.ne.lat ? r1.ne.lat : r2.ne.lat;
 
    //return sdk::GeoPointRect(sw_lon, sw_lat, ne_lon, ne_lat);
    sw.lon = sw_lon;
    sw.lat = sw_lat;
    ne.lon = ne_lon;
    ne.lat = ne_lat;
    return *this;
  }
 
  sdk::GeoPoint Center() const noexcept {
    sdk::GeoPoint center;
    if (sw.x == ne.x) {
      center.x = sw.x;
    } else {
      double sw_x = sw.x;
      double ne_x = ne.x;
      if (sw_x > ne_x)
        ne_x += kDegLonFull;
 
      double center_x = sw_x + ((ne_x - sw_x) / 2);
      while(center_x >= kDegLonMax) // Normalize x
        center_x -= kDegLonFull;
 
      center.x = center_x;
    }
 
    if (sw.y == ne.y)
      center.y = sw.y;
    else
      center.y = (sw.y + ne.y) / 2;
 
    return center;
  }
 
  typedef std::vector<GeoPointRect> container;
};
 
inline bool operator==(const GeoPointRect& r1, const GeoPointRect& r2) {
  return (r1.sw.lon == r2.sw.lon) && (r1.sw.lat == r2.sw.lat) &&
         (r1.ne.lon == r2.ne.lon) && (r1.ne.lat == r2.ne.lat);
}
 
inline GeoPointRect RectD2DToGeoPointRect(const RectD2D& geo_rect) {
  return GeoPointRect(geo_rect.x, geo_rect.y,
    GeoLonShift(geo_rect.x, geo_rect.width),
    GeoLatShift(geo_rect.y, geo_rect.height));
}
 
inline GeoPointRect GeoPointRectFromRectD2D(const RectD2D& geo_rect) {
  return RectD2DToGeoPointRect(geo_rect);
}
 
inline RectD2D GeoPointRectToRectD2D(const GeoPointRect& geo_rect) {
  return RectD2D(geo_rect.sw.x, geo_rect.sw.y,
    GeoLonDistance(geo_rect.sw.x, geo_rect.ne.x),
    GeoLatDistance(geo_rect.sw.y, geo_rect.ne.y));
}
 
inline RectD2D RectD2DFromGeoPointRect(const GeoPointRect& geo_rect) {
  return GeoPointRectToRectD2D(geo_rect);
}
 
inline GeoIntRect GeoPointRectToGeoIntRect(const GeoPointRect& geo_rect) {
  return GeoIntRect(
    GeoIntFromDeg(geo_rect.sw.x), GeoIntFromDeg(geo_rect.sw.y),
    GeoIntFromDeg(geo_rect.ne.x), GeoIntFromDeg(geo_rect.ne.y));
}
 
inline GeoIntRect GeoIntRectFromGeoPointRect(const GeoPointRect& geo_rect) {
  return GeoPointRectToGeoIntRect(geo_rect);
}
 
inline GeoPointRect GeoIntRectToGeoPointRect(const GeoIntRect& geo_rect) {
  return GeoPointRect(
    DegFromGeoInt(geo_rect.sw.x), DegFromGeoInt(geo_rect.sw.y),
    DegFromGeoInt(geo_rect.ne.x), DegFromGeoInt(geo_rect.ne.y));
}
 
inline GeoPointRect GeoPointRectFromGeoIntRect(const GeoIntRect& geo_rect) {
  return GeoIntRectToGeoPointRect(geo_rect);
}
 
} // namespace sdk
 
#endif // SDK_GEOMETRY_TYPES_HELPERS_H_