GeometryObject.h

#pragma once
 
#include <QVariant>
#include <QSharedDataPointer>
 
#include <Cartography/Forward.h>
 
#include <knowCore/ReturnValue.h>
 
#include "EuclidSystem.h"
#include "Forward.h"
 
#include <Cartography/GeometryObject.h>
 
class QString;
 
 
 
namespace knowCore
{
  template<>
  struct FollowReturnValuePattern<Cartography::ReturnValue> : public std::true_type
  {};
}
 
namespace knowGIS
{
  class GeometryObject : public Cartography::GeometryObject
  {
  public:
    using Cartography::GeometryObject::GeometryObject;
    using Cartography::GeometryObject::operator=;
    GeometryObject(const Cartography::GeometryObject& _rhs) : Cartography::GeometryObject(_rhs)
    {}
    ~GeometryObject();
    GeometryObject& operator=(const Cartography::GeometryObject& _rhs); // has to be explicitly defined because of deprecation of generated ones
    Point toPoint() const;
    Point centroid() const;
  public:
    static knowCore::ReturnValue<GeometryObject> fromEWKB(const QByteArray& _data) { return Cartography::GeometryObject::fromEWKB(_data); }
    static knowCore::ReturnValue<GeometryObject> fromWKB(const QByteArray& _data, bool _extented = false) { return Cartography::GeometryObject::fromWKB(_data, _extented); }
    static knowCore::ReturnValue<GeometryObject> fromWKT(const QString& _data) { return Cartography::GeometryObject::fromWKT(_data); }
    static knowCore::ReturnValue<GeometryObject> fromGML(const QString& _data) { return Cartography::GeometryObject::fromGML(_data); }
    static knowCore::ReturnValue<GeometryObject> fromJson(const QString& _data) { return Cartography::GeometryObject::fromJson(_data); }
    static knowCore::ReturnValue<GeometryObject> fromJsonValue(const QJsonValue& _data) { return Cartography::GeometryObject::fromJsonValue(_data); }
    static knowCore::ReturnValue<GeometryObject> fromGeoVariant(const QVariant& _data) { return Cartography::GeometryObject::fromGeoVariant(_data); }
    static knowCore::ReturnValue<GeometryObject> polygon(const QVariantList& _exteriorRing, const QVariantList& _interiorRings = QVariantList()) { return Cartography::GeometryObject::polygon(_exteriorRing, _interiorRings); }
  public:
    static QList<GeometryObject> load(const QString& _filename);
  };
}
 
#include <knowCore/Formatter.h>
KNOWCORE_CORE_DECLARE_FORMATTER(knowGIS::GeometryObject)
{
  if(p.isValid())
  {
    return forward(p.toWKT(), ctx);
  } else {
    return forward("[invalid geometry]", ctx);
  }
}
 
#include <knowCore/MetaType.h>
KNOWCORE_DECLARE_FULL_METATYPE(knowGIS, GeometryObject)
 
#include "Operators.h"
 
namespace knowGIS
{
  template<>
  struct intersects<GeometryObject>
  {
    bool operator()(const GeometryObject& _lhs, const GeometryObject& _rhs) const
    {
      return _lhs.intersects(_rhs);
    }
  };
  template<>
  struct overlaps<GeometryObject>
  {
    bool operator()(const GeometryObject& _lhs, const GeometryObject& _rhs) const
    {
      return _lhs.overlaps(_rhs);
    }
  };
  template<>
  struct contains<GeometryObject>
  {
    bool operator()(const GeometryObject& _lhs, const GeometryObject& _rhs) const
    {
      return _lhs.contains(_rhs);
    }
  };
  template<>
  struct within<GeometryObject>
  {
    bool operator()(const GeometryObject& _lhs, const GeometryObject& _rhs) const
    {
      return _lhs.within(_rhs);
    }
  };
  template<>
  struct touches<GeometryObject>
  {
    bool operator()(const GeometryObject& _lhs, const GeometryObject& _rhs) const
    {
      return _lhs.touches(_rhs);
    }
  };
  template<>
  struct disjoint<GeometryObject>
  {
    bool operator()(const GeometryObject& _lhs, const GeometryObject& _rhs) const
    {
      return _lhs.disjoint(_rhs);
    }
  };
}