CartoTypeGeometry.h

/*
CartoTypeGeometry.h
Copyright (C) CartoType Ltd 2021-2023.
See www.cartotype.com for more information.
*/
 
#pragma once
 
using namespace System;
using namespace System::Collections::Generic;
 
namespace CartoTypeCore
{
class PathIntersectionInfo;
class Geometry;
}
 
namespace CartoType
{
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);
    PathPoint^ Point(int aContourIndex,int aPointIndex);
    };
 
public enum class CoordType
    {
    Degree,
    Display,
    Screen = Display,
    Map,
    MapMeter
    };
 
public enum class PathIntersectionType
    {
    Unknown,
    Separate,
    Intersects,
    Contains,
    Contained
    };
 
public ref class PathIntersectionTypeList: List<PathIntersectionType>
    {
    };
 
public ref class PathIntersectionInfo
    {
    public:
    PathIntersectionInfo() { Type = PathIntersectionType::Unknown; }
 
    property PathIntersectionType Type;
    property double Distance;
    property double NearestX1;
    property double NearestY1;
    property double NearestX2;
    property double NearestY2;
 
    internal:
    void Set(const CartoTypeCore::PathIntersectionInfo& 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();
    property CoordType CoordType { CartoType::CoordType get(); }
    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 PathPoint^ Point(int aContourIndex,int aPointIndex);
    property bool IsEmpty { bool get(); };
    property bool IsClosed { bool get(); };
    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);
    Result ConvertLinesToGreatCircles(double aMaxDistanceInMeters);
 
    protected:
    !Geometry();
        
    internal:
    Geometry(CartoTypeCore::Geometry* aGeometry);
    ~Geometry();
    
    CartoTypeCore::Geometry* m_geometry = nullptr;
    };
 
public ref class GeometryList: List<Geometry^>
    {
    };
 
}