CartoTypeGeometry.h

/*
CartoTypeGeometry.h
Copyright (C) CartoType Ltd 2021-2023.
See www.cartotype.com for more information.
*/
 
#pragma once
 
#include <collection.h>
 
using namespace Platform;
using namespace Platform::Collections;
using namespace Windows::Foundation::Collections;
 
namespace CartoTypeCore
{
class PathIntersectionInfo;
class Geometry;
}
 
namespace CartoType
{
ref class Geometry;
ref class MapObject;
 
using GeometryList = IVector<Geometry^>;
 
using MapObjectList = IVector<MapObject^>;
 
public ref class Point sealed
    {
    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 sealed
    {
    double X;
    double Y;
    };
 
public enum class PointType
    {
    OnCurve,
    Quadratic,
    Cubic    
    };
 
public ref class PathPoint sealed
    {
    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 HeightProfilePoint sealed
    {
    public:
    property double Longitude;
    property double Latitude;
    property double HeightInMeters;
    property double TimeInSeconds;
    property double DistanceInMeters;
    };
 
public ref class Rect sealed
    {
    public:
    Rect();
    Rect(double aMinX,double aMinY,double aMaxX,double aMaxY);
 
    property double MinX;
    property double MinY;
    property double MaxX;
    property double MaxY;
    };
 
public 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,
    /* <summary> The paths intersect or are identical. </summary> */
    Intersects,
    Contains,
    Contained
    };
 
using PathIntersectionTypeList = IVector<PathIntersectionType>;
 
public ref class PathIntersectionInfo sealed
    {
    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);
    };
 
using PathIntersectionInfoList = IVector<PathIntersectionInfo^>;
 
public ref class Geometry sealed: public Path
    {
    public:
    Geometry(CoordType aCoordType,bool aClosed);
    Geometry(MapObject^ aMapObject);
    static Geometry^ RectGeometry(Rect^ aRect,CoordType aCoordType);
    Geometry^ ContourGeometry(int aContourIndex);
    bool ContourIsOuter(int aIndex);
    void Clear();
    property CoordType CoordType { CartoType::CoordType get(); }
    void AppendPoint(Point^ aPoint);
    void AppendPathPoint(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^ IntersectionTypes(MapObjectList^ aMapObjectList);
    PathIntersectionInfoList^ IntersectionInfos(MapObjectList^ aMapObjectList);
    bool Intersects(MapObject^ aMapObject);
    bool Contains(MapObject^ aMapObject);
    bool Contained(MapObject^ aMapObject);
    Geometry^ Clip(ClipOperation aClipOperation,MapObject^ aMapObject);
    GeometryList^ ClipMapObjects(ClipOperation aClipOperation,MapObjectList^ aMapObjectList);
    static Geometry^ Envelope(MapObject^ aMapObject,double aOffsetInMeters);
    Result ConvertLinesToGreatCircles(double aMaxDistanceInMeters);
 
    internal:
    Geometry(std::unique_ptr<CartoTypeCore::Geometry> aGeometry);
    
    std::unique_ptr<CartoTypeCore::Geometry> m_geometry;
    };
 
}