CartoTypeGeometry.h

/*
CartoTypeGeometry.h
Copyright (C) CartoType Ltd 2021.
See www.cartotype.com for more information.
*/
 
#pragma once
 
using namespace System;
using namespace System::Collections::Generic;
 
namespace CartoType
{
 
class TPathIntersectionInfo;
class CGeometry;
 
ref class GeometryList;
ref class MapObject;
ref class MapObjectList;
 
public ref class Point
    {
    public:
    Point() {  }
    Point(double aX, double aY) { X = aX; Y = aY; }
    Point(Point^ aPoint) { if (aPoint) { X = aPoint->X; Y = aPoint->Y; } }
    property double X;
    property double Y;
    };
 
public value struct PointValue
    {
    double X;
    double Y;
    };
 
public enum class PointType
    {
    OnCurve,
    Quadratic,
    Cubic    
    };
 
public ref class PathPoint
    {
    public:
    PathPoint() {  }
    PathPoint(double aX,double aY,PointType aType) { X = aX; Y = aY; Type = aType; }
    PathPoint(PathPoint^ aPoint) { if (aPoint) { X = aPoint->X; Y = aPoint->Y; Type = aPoint->Type; } }
 
    property double X;
    property double Y;
    property PointType Type;
    }; 
 
public ref class Rect
    {
    public:
    Rect();
    Rect(double aMinX,double aMinY,double aMaxX,double aMaxY);
 
    property double MinX;
    property double MinY;
    property double MaxX;
    property double MaxY;
    };
 
enum class ClipOperation
    {
    Intersection,
    Union,
    Difference,
    Xor
    };
 
public interface class Path
    {
    int ContourCount();
    int PointCount(int aContourIndex);
    void GetPoint(int aContourIndex,int aPointIndex,PathPoint^ aPoint);
    };
 
public enum class CoordType
    {
    Degree,
    Screen,
    Map,
    MapMeter
    };
 
public enum class PathIntersectionType
    {
    Unknown,
    Separate,
    /* <summary> The paths intersect or are identical. </summary> */
    Intersects,
    Contains,
    Contained
    };
 
public ref class PathIntersectionTypeList: List<PathIntersectionType>
    {
    };
 
public ref class PathIntersectionInfo
    {
    public:
    PathIntersectionType m_type = PathIntersectionType::Unknown;
    double m_distance = 0;
    double m_nearest_x1 = 0;
    double m_nearest_y1 = 0;
    double m_nearest_x2 = 0;
    double m_nearest_y2 = 0;
 
    internal:
    void Set(const TPathIntersectionInfo& aInfo);
    };
 
public ref class PathIntersectionInfoList: List<PathIntersectionInfo^>
    {
    };
 
public ref class Geometry: public Path
    {
    public:
    Geometry(CoordType aCoordType,bool aClosed);
    Geometry(MapObject^ aMapObject);
    Geometry(Rect^ aRect,CoordType aCoordType);
    Geometry(Geometry^ aOther,int aContourIndex);
    bool ContourIsOuter(int aIndex);
    void Clear();
    CoordType GetCoordType();
    void AppendPoint(Point^ aPoint);
    void AppendPoint(PathPoint^ aPoint);
    void AppendPoint(double aX,double aY);
    void AppendPoint(double aX,double aY,PointType aPointType);
    void BeginContour();
    virtual int ContourCount();
    virtual int PointCount(int aContourIndex);
    virtual void GetPoint(int aContourIndex,int aPointIndex,PathPoint^ aPoint);
    bool IsEmpty();
    bool IsClosed();
    void SetClosed(bool aClosed);
    void Reverse();
    PathIntersectionType IntersectionType(MapObject^ aMapObject);
    PathIntersectionInfo^ IntersectionInfo(MapObject^ aMapObject);
    PathIntersectionTypeList^ IntersectionType(MapObjectList^ aMapObjectList);
    PathIntersectionInfoList^ IntersectionInfo(MapObjectList^ aMapObjectList);
    bool Intersects(MapObject^ aMapObject);
    bool Contains(MapObject^ aMapObject);
    bool Contained(MapObject^ aMapObject);
    Geometry^ Clip(ClipOperation aClipOperation,MapObject^ aMapObject);
    GeometryList^ Clip(ClipOperation aClipOperation,MapObjectList^ aMapObjectList);
    static Geometry^ Envelope(MapObject^ aMapObject,double aOffsetInMeters);
 
    protected:
    !Geometry();
        
    internal:
    Geometry(CGeometry* aGeometry);
    ~Geometry();
    
    CGeometry* m_geometry = nullptr;
    };
 
public ref class GeometryList: List<Geometry^>
    {
    };
 
}