geometry.h

Go to the documentation of this file.

 
#ifndef SDK_GEOMETRY_INTERFACE_H_
#define SDK_GEOMETRY_INTERFACE_H_
#pragma once
 
#include <base/inc/platform.h>
#include <base/inc/base_types.h>
#include <base/inc/sdk_string_handler.h>
#include <base/inc/sdk_component_interface.h>
#include <base/inc/geometry/geometry_base_types.h>
 
namespace sdk {
namespace crs {
 
// Classes declared in other files.
class IHorizontalCoordinateSystem;
class IProjection;
class IVerticalCoordinateSystem;
 
} // namespace crs
} // namespace sdk
 
#ifndef SDK_GEOMETRY_NAMESPACE
#define SDK_GEOMETRY_NAMESPACE SDK_NAMESPACE::geometry
#endif // SDK_GEOMETRY_NAMESPACE
 
#ifndef SDK_GEOMETRY_BEGIN_NAMESPACE
#define SDK_GEOMETRY_BEGIN_NAMESPACE namespace SDK_NAMESPACE {   \
  namespace geometry {
#endif // SDK_GEOMETRY_BEGIN_NAMESPACE
 
#ifndef SDK_GEOMETRY_END_NAMESPACE
#define SDK_GEOMETRY_END_NAMESPACE } }
#endif // SDK_GEOMETRY_END_NAMESPACE
 
SDK_GEOMETRY_BEGIN_NAMESPACE
  
// Classes declared in this file.
FWD_DECL_INTERFACE(IEnvelope);
FWD_DECL_INTERFACE(IGeometry);
FWD_DECL_INTERFACE(IGeometryCollection);
FWD_DECL_INTERFACE(IPointCollection);
FWD_DECL_INTERFACE(IPointCollectionRef);
FWD_DECL_INTERFACE(IPoint);
FWD_DECL_INTERFACE(IMultipoint);
FWD_DECL_INTERFACE(ICurveSegment);
FWD_DECL_INTERFACE(ICurve);
FWD_DECL_INTERFACE(ICompositeCurve);
FWD_DECL_INTERFACE(IRing);
FWD_DECL_INTERFACE(ISurface);
FWD_DECL_INTERFACE(IMultiSurface);
FWD_DECL_INTERFACE(IPointCollectionParameters);
FWD_DECL_INTERFACE(IGrid);
FWD_DECL_INTERFACE(IBezierCurve);
 
typedef SDKUInt32 GeometryTypeFlagType;
 
static const SDKUInt64 kGeometryID_Undefined = -1;
 
typedef enum GeometryType {
  kGMT_Null = 0,
  kGMT_Point = 1,
  kGMT_Multipoint = 2,
  kGMT_Curve = 3,
  kGMT_Surface = 4,
  kGMT_Triangles = 5,
  kGMT_Grid = 6,
  kGMT_TriangleFan = 7,
  kGMT_CompositeCurve = 8,
  kGMT_Ring = 9,
  kGMT_GeometryCollection = 10,
  kGMT_Polygon = 11,
  kGMT_MultiSurface = 12,
  kGMT_MultiPolygon = 13,
  kGMT_CurveSegment = 14,
  kGMT_MultiCompositeCurve = 15,
  kGMT_MultiCurve = 16,
  kGMT_TriangleStrip = 17,
  kGMT_Circle = 18,
  kGMT_BezierCurve = 19,
} GeometryType;
 
struct GeometryTypeName {
  SDKUInt16   m_code;
  const char* m_name;
};
 
static const GeometryTypeName kGeometryTypeNames[] = {
  { kGMT_Null,           "Null" },
  { kGMT_Point,          "Point" },
  { kGMT_Multipoint,     "Multipoint" },
  { kGMT_Curve,          "Curve" },
  { kGMT_Surface,        "Surface" },
  { kGMT_Triangles,      "Triangles" },
  { kGMT_Grid,           "Grid" },
  { kGMT_TriangleFan,    "TriangleFan" },
  { kGMT_CompositeCurve, "CompositeCurve" },
  { kGMT_Ring,           "Ring" },
  { kGMT_GeometryCollection, "GeometryCollection" },
  { kGMT_Polygon,        "Polygon" },
  { kGMT_MultiSurface,   "MultiSurface" },
  { kGMT_MultiPolygon,   "MultiPolygon" },
  { kGMT_CurveSegment,   "CurveSegment" },
  { kGMT_MultiCompositeCurve, "MultiCompositeCurve" },
  { kGMT_MultiCurve,     "MultiCurve" },
  { kGMT_TriangleStrip,  "TriangleStrip" },
  { kGMT_Circle,         "Circle" },
  { kGMT_BezierCurve,    "BezierCurve" }
};
 
typedef enum GeometryTypeFlag {
  kGMTF_Null                = 0x0000, 
  kGMTF_Point               = 0x0001,
  kGMTF_Multipoint          = 0x0002,
  kGMTF_Curve               = 0x0004,
  kGMTF_Surface             = 0x0008,
  kGMTF_Triangles           = 0x0010,
  kGMTF_Grid                = 0x0020,
  kGMTF_TriangleFan         = 0x0040,
  kGMTF_CompositeCurve      = 0x0080,
  kGMTF_Ring                = 0x0100,
  kGMTF_GeometryCollection  = 0x0200,
  kGMTF_Polygon             = 0x0000,
  kGMTF_MultiSurface        = 0x0400,
  kGMTF_MultiPolygon        = 0x0000,
  kGMTF_CurveSegment        = 0x0800,
  kGMTF_MultiCompositeCurve = 0x1000,
  kGMTF_MultiCurve          = 0x2000,
  kGMTF_TriangleStrip       = 0x4000,
  kGMTF_Circle              = 0x8000,
  kGMTF_BezierCurve         = 0x10000,
  kGMTF_All                 = 0xFFFFFFFF, 
} GeometryTypeFlag;
 
static const SDKUInt32 kGeometryTypeToTypeFlagTable[] = {
  kGMTF_Null, 
  kGMTF_Point,
  kGMTF_Multipoint,
  kGMTF_Curve,
  kGMTF_Surface,
  kGMTF_Triangles,
  kGMTF_Grid,
  kGMTF_TriangleFan,
  kGMTF_CompositeCurve,
  kGMTF_Ring,
  kGMTF_GeometryCollection,
  kGMTF_Polygon,
  kGMTF_MultiSurface,
  kGMTF_MultiPolygon,
  kGMTF_CurveSegment,
  kGMTF_MultiCompositeCurve,
  kGMTF_MultiCurve,
  kGMTF_TriangleStrip,
  kGMTF_Circle,
  kGMTF_BezierCurve,
};
 
typedef enum GeometryDimension {
  kGMD_NoD = 0,
  kGMD_0D = 1, 
  kGMD_1D,     
  kGMD_2D,     
  kGMD_25D,    
  kGMD_3D,     
} GeometryDimension;
 
typedef enum PointDimension {
  kGMPD_2  = 2,  
  kGMPD_3  = 3,  
  kGMPD_4  = 4,  
} PointDimension;
 
typedef enum PointType {
  kGMPT_GeoIntPoint = 0, 
  kGMPT_GeoIntPoint3D,   
  kGMPT_GeoPoint,        
  kGMPT_GeoPoint3D,      
  // kGMPT_PointD2D = kGMPT_GeoPoint,
  kGMPT_PointF2D,        
  kGMPT_PointF3D,        
  kGMPT_PointD2D,        
  kGMPT_PointD3D,        
} PointType;
 
typedef enum Axis {
  kAxis_X = 0,
  kAxis_Y,
  kAxis_Z,
} Direction;
 
typedef SDKUInt8 PointDimensionType;
 
typedef enum GeometryInterpolationMethod {
  kGM_IM_SeparatePoints = 0,
  kGM_IM_Linear = 1,
  kGM_IM_CircularArc3Points = 2,
  kGM_IM_Geodesic = 3,
  kGM_IM_Loxodromic = 4,
  kGM_IM_CubicSpline = 5,
} GeometryInterpolationMethod;
 
typedef SDKUInt8 GeometryInterpolationMethodType;
 
typedef enum PointCollectionParameter {
  PointCollectionParameter_Approximation = 0, 
} PointCollectionParameter;
 
class IGeometry : public ISDKComponent {
public:
  virtual SDKResult SDK_CALLTYPE GetGeometryType(
    GeometryType& type) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetDimension(
      GeometryDimension& dimension) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetEnvelope(
    IEnvelope** envelope) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE IsEmpty() const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE IsInfinite() const throw() = 0;
  
  virtual SDKResult SDK_CALLTYPE GetBoundary(
    IGeometry** geometry) throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetPointCollection(
    IPointCollectionParameters* parameters,
    IPointCollection** point_collection) throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE Project(
    sdk::crs::IProjection* projection, 
    IGeometry** projected_geometry) throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetHorizontalCoordinateSystem(
    sdk::crs::IHorizontalCoordinateSystem** coordinate_system) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetVerticalCoordinateSystem(
    sdk::crs::IVerticalCoordinateSystem** coordinate_system) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetHorizontalDatum(
    SDKUInt16& hordat) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetGeometryFlags(
    SDKUInt64& flags) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetGeometryID(
    SDKUInt64& flags) const throw() = 0;
 
  SDK_IMPLEMENT_IID(IGeometry)
  SDK_END_INTERFACE(IGeometry)
};
SDK_DECLARE_IID(IGeometry)
 
class IGeometryCollection : public ISDKComponent {
public:
  virtual SDKResult SDK_CALLTYPE GetGeometryCount(
    SDKUInt32& count) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetGeometry(
    SDKUInt32 index,
    IGeometry** geometry) const throw() = 0;
 
//   virtual SDKResult SDK_CALLTYPE GetGeometries(
//     SDKUInt32 index, 
//     SDKUInt32 count, 
//     IGeometry** geometry) const throw() = 0;
 
  SDK_IMPLEMENT_IID(IGeometryCollection)
  SDK_END_INTERFACE(IGeometryCollection)
};
SDK_DECLARE_IID(IGeometryCollection)
 
class IEnvelope : public ISDKComponent {
public:
  virtual SDKResult SDK_CALLTYPE GetCoordinates(
    SDKAnyType type,
    void* xmin, 
    void* ymin, 
    void* xmax, 
    void* ymax) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetZCoordinates(
    SDKAnyType type,
    void* zmin, 
    void* zmax) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE IsEmpty() const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetDimension(
    GeometryDimension& dimension) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE IsInfinite() const throw() = 0;
 
  SDK_IMPLEMENT_IID(IEnvelope)
  SDK_END_INTERFACE(IEnvelope)
};
SDK_DECLARE_IID(IEnvelope)
 
class IPoint : public IGeometry {
public:
  virtual SDKResult SDK_CALLTYPE GetCoords(
    SDKAnyType type,
    void* X,
    void* Y) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetZ(
    SDKAnyType type,
    void* Z) const throw() = 0;
 
  SDK_IMPLEMENT_IID(IPoint)
  SDK_END_INTERFACE(IPoint)
};
SDK_DECLARE_IID(IPoint)
 
class IPointCollection : public ISDKComponent {
public:
  virtual SDKResult SDK_CALLTYPE GetPointCount(
    SDKUInt32& point_count) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetItemCount(
    SDKUInt32& item_count) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetItemPointCount(SDKUInt32 item, 
    SDKUInt32& point_count) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetPointDimension(PointDimensionType& 
    point_dimension) const throw() = 0;
 
//   virtual SDKResult SDK_CALLTYPE GetIPoint(
//     SDKUInt32 index,
//     IPoint** point) const throw() = 0;
 
//   virtual SDKResult SDK_CALLTYPE GetIPoints(
//     SDKUInt32 index, 
//     SDKUInt32 count, 
//     IPoint** point) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetPoints(
    SDKUInt32 index, 
    SDKUInt32 count, 
    PointType type,
    void* points) const throw() = 0;
 
//   virtual SDKResult SDK_CALLTYPE Get3DPoints(
//     SDKUInt32 index, 
//     SDKUInt32 count, 
//     PointType type,
//     void* points) const throw() = 0;
 
  SDK_IMPLEMENT_IID(IPointCollection)
  SDK_END_INTERFACE(IPointCollection)
};
SDK_DECLARE_IID(IPointCollection)
 
class IPointCollectionRef : public ISDKComponent {
public:  
  virtual SDKResult SDK_CALLTYPE GetPointsRef(
    const void** points,
    PointDimensionType* dimension,
    const SDKAnyType** types,
    const SDKUInt32** counts,
    SDKUInt32* array_count) throw() = 0;
 
  SDK_IMPLEMENT_IID(IPointCollectionRef)
  SDK_END_INTERFACE(IPointCollectionRef)
};
SDK_DECLARE_IID(IPointCollectionRef)
 
class IMultipoint : public IGeometry {
public:
  SDK_IMPLEMENT_IID(IMultipoint)
  SDK_END_INTERFACE(IMultipoint)
};
SDK_DECLARE_IID(IMultipoint)
 
class ICurveSegment : public IGeometry {
public:
  virtual SDKResult SDK_CALLTYPE GetInterpolationMethod(
    GeometryInterpolationMethod& interpolation_method) const throw() = 0;
 
  SDK_IMPLEMENT_IID(ICurveSegment)
  SDK_END_INTERFACE(ICurveSegment)
};
SDK_DECLARE_IID(ICurveSegment)
 
class ICurve : public IGeometry {
public:
  virtual SDKResult SDK_CALLTYPE IsClosed() const throw() = 0;
 
  SDK_IMPLEMENT_IID(ICurve)
  SDK_END_INTERFACE(ICurve)
};
SDK_DECLARE_IID(ICurve)
 
class ICompositeCurve : public IGeometry {
public:
 
  SDK_IMPLEMENT_IID(ICompositeCurve)
  SDK_END_INTERFACE(ICompositeCurve)
};
SDK_DECLARE_IID(ICompositeCurve)
 
class IRing : public IGeometry {
public:
  virtual SDKResult SDK_CALLTYPE IsExterior() const throw() = 0;
 
  SDK_IMPLEMENT_IID(IRing)
  SDK_END_INTERFACE(IRing)
};
SDK_DECLARE_IID(IRing)
 
class ISurface : public IGeometry {
public:
  virtual SDKResult SDK_CALLTYPE IsEnvelope() const throw() = 0;
  
  virtual SDKResult SDK_CALLTYPE GetExteriorRingCount(
    SDKUInt32& count) const throw() = 0; 
 
//   virtual SDKResult SDK_CALLTYPE GetInteriorRings(
//     SDKUInt32 requested_number,
//     IGeometryCollection** interior_rings) throw() = 0;
 
  SDK_IMPLEMENT_IID(ISurface)
  SDK_END_INTERFACE(ISurface)
};
SDK_DECLARE_IID(ISurface)
 
class IMultiSurface : public IGeometry {
public:
 
  SDK_IMPLEMENT_IID(IMultiSurface)
  SDK_END_INTERFACE(IMultiSurface)
};
SDK_DECLARE_IID(IMultiSurface)
 
class IGrid : public IGeometry {
public:
  virtual SDKResult SDK_CALLTYPE GetBounds(
    SDKUInt8 axis,
    SDKAnyType type,
    void* min, 
    void* max) const throw() = 0;
 
  virtual SDKResult SDK_CALLTYPE GetCellCount(
    SDKUInt8 axis,
    SDKUInt32& count) const throw() = 0;
 
  SDK_IMPLEMENT_IID(IGrid)
  SDK_END_INTERFACE(IGrid)
};
SDK_DECLARE_IID(IGrid)
 
class INullGeometry : public IGeometry {
public:
 
  SDK_IMPLEMENT_IID(INullGeometry)
  SDK_END_INTERFACE(INullGeometry)
};
SDK_DECLARE_IID(INullGeometry)
 
class IPointCollectionParameters : public ISDKComponent {
public:
  virtual SDKResult SDK_CALLTYPE GetParameter(
    PointCollectionParameter id,
    SDKAny& value) throw() = 0;
  virtual SDKResult SDK_CALLTYPE SetParameter(
    PointCollectionParameter id,
    const SDKAny& value) throw() = 0;
 
  SDK_IMPLEMENT_IID(IPointCollectionParameters)
  SDK_END_INTERFACE(IPointCollectionParameters)
};
SDK_DECLARE_IID(IPointCollectionParameters)
 
class IBezierCurve : public IGeometry {
public:
  virtual void SDK_CALLTYPE SetDegree(SDKUInt8 degree) noexcept = 0;
  virtual void SDK_CALLTYPE GetDegree(SDKUInt8& degree) const noexcept = 0;
 
  virtual SDKResult SDK_CALLTYPE ConstructBezierCurve(double density,
    SDKInt32 from,
    SDKInt32 to,
    IGeometrySP& out_curve) const noexcept = 0;
 
  SDK_IMPLEMENT_IID(IBezierCurve)
  SDK_END_INTERFACE(IBezierCurve)
};
SDK_DECLARE_IID(IBezierCurve)
 
 
// typedef enum tagCurveDensifyMethod {
//   /// \brief The curve length increment. Output line segments will be
//   /// no longer than this. 
//   GM_CurveDensify_ByLength = 0,
//   /// \brief The angle increment. Line segments will become shorter as the 
//   /// curvature increases.
//   GM_CurveDensify_ByAngle = 1,
//   /// \brief The deviation from true curve. Line segments of varying length
//   /// will be generated. The curve parameter specifies the maximum allowable
//   /// distance between a line segment and the portion of the curve that it is
//   /// approximating.
//   GM_CurveDensify_ByDeviation = 2,
// } CurveDensifyMethod;
// 
// /// \brief Describes the kinds of geodetic curves that can be constructed.
// typedef enum tagGeodeticType {
//   /// \brief Geodesic line type. Also known as Great Circle.
//   GM_GeodeticType_Geodesic      = 0,
//   /// \brief Loxodrome line type.
//   GM_GeodeticType_Loxodrome     = 1,
// } GeodeticType;
// 
 
// 
// /// \brief Provides access to members that construct various kinds of geodetic 
// /// curves. 
// /// Classes that implement IConstructGeodetic: Curve
// ///
// 
// typedef struct tagConstructGeodeticCurveParameters {
//   double linear_unit; // Meters per unit.
//   CurveDensifyMethod densify_method;
//   double densify_parameter; // A densification method.
// } ConstructGeodeticCurveParameters; // Parameter of densification
// 
// class IConstructGeodeticCurve : public ISDKComponent {
// public:
//   /// \brief Constructs a geodesic circle centered on the specified point.
//   /// \param center_point [in] Pointer to the center of the circle.
//   /// \param radius [in] The length in units.
//   /// \param parameters [in] Constructing parameters.
//   /// \return SDKResult_Succeeded
//   /// \return SDKResult_NotImplemented
//   /// \return SDKResult_InvalidArgument
//   virtual SDKResult SDK_CALLTYPE ConstructGeodesicCircle(
//     PointD2D* center_point,
//     double radius,
//     ConstructGeodeticCurveParameters parameters) throw() = 0;
// 
//   /// \brief Constructs a geodesic ellipse with origin at the specified point
//   ///        and semi major axis oriented according to the specified azimuth. 
//   /// \param center_point [in] Pointer to the center of the ellipse.
//   /// \param semi_major_axis_length [in] The length of the semi major axis.
//   /// \param semi_minor_axis_length [in] The length of the semi minor axis.
//   /// \param semi_major_axis_azimuth [in] The azimuth of the semi major axis.
//   /// \param parameters [in] Constructing parameters.
//   /// \return SDKResult_Succeeded
//   /// \return SDKResult_NotImplemented
//   /// \return SDKResult_InvalidArgument
//   virtual SDKResult SDK_CALLTYPE ConstructGeodesicEllipse(
//     PointD2D* center_point,
//     double semi_major_axis_length,
//     double semi_minor_axis_length,
//     double semi_major_axis_azimuth,
//     ConstructGeodeticCurveParameters parameters) throw() = 0;
// 
//   /// \brief Constructs a geodetic line with the specified length and azimuth. 
//   /// The 'by length' and 'by deviation' densification options are supported.
//   /// \param geodetic_line_type [in] The geodetic line type.
//   /// \param from_point [in] Pointer to the start point.
//   /// \param length [in] The length in units.
//   /// \param azimuth [in] The azimuth in degree.
//   /// \param parameters [in] Constructing parameters.
//   /// \return SDKResult_Succeeded
//   /// \return SDKResult_NotImplemented
//   /// \return SDKResult_InvalidArgument
//   virtual SDKResult SDK_CALLTYPE ConstructGeodeticLineFromDistance(
//     GeodeticType geodetic_line_type,
//     PointD2D* from_point,
//     double length,
//     double azimuth,
//     ConstructGeodeticCurveParameters parameters) throw() = 0;
// 
//   /// \brief Constructs a geodetic line connecting the specified points. 
//   /// \param geodetic_line_type [in] The geodetic line type.
//   /// \param from_point [in] Pointer to the start point.
//   /// \param from_point [in] Pointer to the end point.
//   /// \param parameters [in] Constructing parameters.
//   /// \return SDKResult_Succeeded
//   /// \return SDKResult_NotImplemented
//   /// \return SDKResult_InvalidArgument
//   virtual SDKResult SDK_CALLTYPE ConstructGeodeticLineFromPoints(
//     GeodeticType geodetic_line_type,
//     PointD2D* from_point,
//     PointD2D* to_point,
//     ConstructGeodeticCurveParameters parameters) throw() = 0;
// 
//   SDK_IMPLEMENT_IID(IConstructGeodeticCurve)
//   SDK_END_INTERFACE(IConstructGeodeticCurve)
// };
// SDK_DECLARE_IID(IConstructGeodeticCurve)
 
 
SDK_GEOMETRY_END_NAMESPACE
 
#endif // SDK_GEOMETRY_INTERFACE_H_