Initial commit

Lts/Viewer/SituationMap/MathUtils/geometry_engine.cpp

@@ -0,0 +1,419 @@
+/**
+**
+** @RDE_HEADER@
+** Implementation of 2d matrix operations
+** $Id$
+** $HeadURL$
+** $Author$
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Hardware-Environment: Intel-PC
+** Software-Environment: Windows 7, Qt 5.4. ArcGIS 10.2.5
+**
+** Language ........: C++ 11
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Author ...........: Jörg Turla, SPD G, Tel. 3132
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Notes .........:
+**
+**   22.06.2016, JT  : First edition for use with Qt5
+**
+** -----------------------------------------------------------------------------------------------
+*/
+
+
+#include "geometry_engine.h"
+
+
+#include <Map/coord_translation_functor.h>
+#include <Map/map.h>
+#include <MapImpl/map_impl.h>
+#include <MapImpl/abstract_map_object_impl.h>
+
+#include <MathUtils/clipper.hpp>
+
+// ESRI
+#include <arcgis/Geometry.h>
+#include <arcgis/GeometryEngine.h>
+//#include <arcgis/Line.h>
+#include <arcgis/Polyline.h>
+#include <arcgis/PolylineBuilder.h>
+#include <arcgis/Polygon.h>
+#include <arcgis/PolygonBuilder.h>
+
+#include <QPointF>
+#include <QVector>
+#include <QDebug>
+
+
+namespace SituationMap { namespace MathUtils
+{
+  //
+  // Line
+  //
+
+  GeometryEngine::Geometry *GeometryEngine::createLine(Map *map, const QPointF &p1, const QPointF &p2)
+  {
+    QVector<QPointF> vertices;
+    vertices << p1 << p2;
+
+    return SituationMap::MathUtils::GeometryEngine::createPolyline(map, vertices);
+  } // GeometryEngine::Geometry *GeometryEngine::createLine( Map * map, QPointF p1, QPointF p2 )
+
+
+  template<class T>
+  inline GeometryEngine::Geometry * createPolyline(Map * map, const T & verticies)
+  {
+    MapImpl * mapImpl = dynamic_cast<MapImpl*>(map);
+    if (! mapImpl)
+      return nullptr;
+
+    SituationMap::CoordTranslationFunctor *mapCtFunctor = map->coordTranslationFunctor();
+    if (! mapCtFunctor)
+      return nullptr;
+
+    Esri::ArcGISRuntime::PolylineBuilder builder ( mapImpl->getEsriSpatialReference() );
+
+    for (auto pit = verticies.cbegin(); pit != verticies.cend(); ++pit)
+    {
+      const QPointF p(mapCtFunctor->geographicToMap(*pit));
+      builder.addPoint(p.x(),p.y());
+    }
+
+    Esri::ArcGISRuntime::Polyline * esriPolyline = new Esri::ArcGISRuntime::Polyline( builder.toGeometry() );
+
+    return esriPolyline;
+  } // GeometryEngine::Geometry * createPolyline(Map * map, const T & verticies)
+
+
+
+  GeometryEngine::Geometry *GeometryEngine::createPolyline(Map *map, const QVector<QPointF> &vertices )
+  {
+    return SituationMap::MathUtils::createPolyline<QVector<QPointF>>(map, vertices);
+  } // GeometryEngine::Geometry * GeometryEngine::createPolyline( Map * map, const QVector<QPointF> & verticies )
+
+  GeometryEngine::Geometry *GeometryEngine::createPolyline(Map *map, const QList<QPointF> &vertices)
+  {
+    return SituationMap::MathUtils::createPolyline<QList<QPointF>>(map, vertices);
+  } // GeometryEngine::Geometry * GeometryEngine::createPolyline(  Map * map, const QVector<QPointF> & verticies )
+
+
+  //
+  // Polygon
+  //
+
+  template<class T>
+  inline GeometryEngine::Geometry *createPolygon(Map *map, const T &verticies)
+  {
+    MapImpl * mapImpl = dynamic_cast<MapImpl*>(map);
+
+    if (! mapImpl) return nullptr;
+
+    SituationMap::CoordTranslationFunctor * mapCtFunctor = map->coordTranslationFunctor();
+
+    if (! mapCtFunctor) return nullptr;
+
+    Esri::ArcGISRuntime::PolygonBuilder builder( mapImpl->getEsriSpatialReference() );
+
+    for (auto pit = verticies.cbegin(); pit != verticies.cend(); ++pit )
+    {
+      const QPointF p(mapCtFunctor->geographicToMap(*pit));
+      builder.addPoint(p.x(),p.y());
+    }
+
+    Esri::ArcGISRuntime::Polygon * esriPolygon = new Esri::ArcGISRuntime::Polygon( builder.toGeometry() );
+
+    return esriPolygon;
+  } // GeometryEngine::Geometry * GeometryEngine::createPolygon(  Map * map, const QVector<QPointF> & verticies )
+
+
+  GeometryEngine::Geometry * GeometryEngine::createPolygon(Map * map, const QVector<QPointF> & vertices )
+  {
+    return SituationMap::MathUtils::createPolygon<QVector<QPointF>>( map, vertices );
+  } // GeometryEngine::Geometry * GeometryEngine::createPolygon( Map * map, const QVector<QPointF> & verticies )
+
+  GeometryEngine::Geometry * GeometryEngine::createPolygon(Map * map, const QList<QPointF> & vertices )
+  {
+    return SituationMap::MathUtils::createPolygon<QList<QPointF>>( map, vertices );
+  } // GeometryEngine::Geometry * GeometryEngine::createPolygon(  Map * map, const QVector<QPointF> & verticies )
+
+
+  //
+  // cleanup etc.
+  //
+
+  void GeometryEngine::deleteGeometry(Geometry *geom)
+  {
+    delete geom;
+  } // void GeometryEngine::deleteGeoemtry( Geometry * geom )
+
+
+  bool GeometryEngine::contains( AbstractMapObject *mapObj, const Geometry &hull)
+  {
+    if (nullptr == mapObj) return false;
+    return mapObj->geometryIsInHull( hull );
+
+  } //bool GeometryEngine::contains( AbstractMapObject * mapObj, const Geometry & hull )
+
+
+  bool GeometryEngine::contains(const Geometry &geom, const Geometry &hull)
+  {
+    if (geom.isEmpty() || hull.isEmpty())
+      return false;
+    return Esri::ArcGISRuntime::GeometryEngine::contains(hull, geom);
+  } // bool GeometryEngine::contains(const Geometry & geom, const Geometry & hull)
+
+
+  bool GeometryEngine::intersect(  AbstractMapObject *mapObj, const Geometry &intersector)
+  {
+    if (! mapObj)
+      return false;
+    return mapObj->geometryIntersect(intersector);
+  } // bool GeometryEngine::intersect( const Geometry & inputGeom, const Geometry & intersector )
+
+
+  bool GeometryEngine::intersect(const Geometry &inputGeom, const Geometry &intersector)
+  {
+    if (inputGeom.isEmpty() || intersector.isEmpty())
+      return false;
+
+#ifdef DEBUGGERTEST
+    if (inputGeom.type() == EsriRuntimeQt::GeometryType::Polyline)
+    {
+      const EsriRuntimeQt::Polyline & l         = inputGeom;
+      int                             numPoints = l.pointCount();
+
+      for (int i = 0; i < numPoints; ++i)
+      {
+        QPointF p = l.qxy(i);
+        __asm int 3
+      }
+    }
+
+    if (intersector.type() == EsriRuntimeQt::GeometryType::Line)
+    {
+      const EsriRuntimeQt::Line & l      = intersector;
+      double                      startx = l.startX();
+      double                      starty = l.startY();
+      double                      endx   = l.endX();
+      double                      endy   = l.endY();
+
+      __asm int 3
+    }
+#endif
+
+    return Esri::ArcGISRuntime::GeometryEngine::crosses(inputGeom, intersector);
+  } // bool GeometryEngine::intersect( const Geometry & inputGeom, const Geometry & intersector )
+
+QVector<QPointF> GeometryEngine::parallelTranslation(SituationMap::CoordTranslationFunctor *mapCtFunctor, const QVector<QPointF> &line, double distance)
+{
+  /* ~ first lokal functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+  auto length = [](const QPointF &v) -> double { return sqrt(v.x()*v.x() + v.y()*v.y()); };
+
+
+  auto normalize = [](const QPointF &v) -> QPointF { return v / sqrt(v.x()*v.x() + v.y()*v.y()); };
+
+
+  auto intersection = [](const QPointF &p1, const QPointF &r1, const QPointF &p2, const QPointF &r2) -> QPointF
+  {
+    double f = r2.y()*r1.x() - r1.y()*r2.x();
+
+    double a = (p1.x() + r1.x()) * p1.y() - p1.x() * (p1.y() + r1.y());
+    double b = (p2.x() + r2.x()) * p2.y() - p2.x() * (p2.y() + r2.y());
+
+    double sx = (r2.x() * a - r1.x() * b) / f;
+    double sy = (-r1.y() * b + r2.y() * a) / f;
+
+    return QPointF(sx, sy);
+
+  }; // intersection
+
+
+  auto orientation = [](const QPointF &p, const QPointF &q, const QPointF &r) -> int
+  {
+    // See https://www.geeksforgeeks.org/orientation-3-ordered-points/
+    // for details of below formula.
+    double f = (q.y() - p.y()) * (r.x() - q.x()) - (q.x() - p.x()) * (r.y() - q.y());
+
+    if (qFuzzyIsNull(f)) return 0;  // colinear
+
+    return (f > 0) ? 1 : 2; // clock or counterclock wise
+  }; // orientation
+
+
+  auto testIntersection = [&orientation, &intersection, &normalize](const QPointF &p1, const QPointF &q1, const QPointF &p2, const QPointF &q2) -> bool
+  {
+    // Find the four orientations needed for general and
+    // special cases
+    int o1 = orientation(p1, q1, p2);
+    int o2 = orientation(p1, q1, q2);
+    int o3 = orientation(p2, q2, p1);
+    int o4 = orientation(p2, q2, q1);
+
+    // General case
+    if (o1 != o2 && o3 != o4)
+    {
+      const QPointF & n1 = q1 - p1;
+      const QPointF & n2 = q2 - p2;
+      const QPointF & s = intersection(p1, normalize(n1), p2, normalize(n2));
+
+      double f1 = (!qFuzzyIsNull(n1.x())) ? (s.x() - p1.x()) / n1.x() : (s.y() - p1.y()) / n1.y();
+      double f2 = (!qFuzzyIsNull(n2.x())) ? (s.x() - p2.x()) / n2.x() : (s.y() - p2.y()) / n2.y();
+
+      return ((f1 >= 0) && (f1 <= 1.0) && (f2 >= 0) && (f2 <= 1.0));
+    }
+
+    return false; // Doesn't fall in any of the above cases
+
+  }; // testIntersection
+
+
+  /* ~ now let's do the job ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+  if (line.size() < 2)
+  {
+    // Nothing to do --> return input line
+    return line;
+  }
+
+  QVector<QPointF> transformedLine;
+
+  transformedLine.reserve(line.size());
+
+  for (auto &point : qAsConst(line))
+  {
+    // Let's transform the coordinates to maps coordinate system ...
+    transformedLine << mapCtFunctor->geographicToMap(point);
+  }
+
+  struct LineSegment
+  {
+    QPointF m_p1;
+    QPointF m_p2;
+    QPointF m_t;
+
+    LineSegment() = default;
+    LineSegment(const QPointF &p1, const QPointF &p2, const QPointF &t)
+      : m_p1(p1), m_p2(p2), m_t(t)
+    {}
+  };
+
+  // build single line segments to translate along it's normal
+  QVector<LineSegment> multiSegmLine;
+
+  multiSegmLine.reserve(transformedLine.size() - 1);
+
+  for (int i = 1; i < transformedLine.size(); ++i)
+  {
+    const QPointF & p1 = transformedLine[i - 1];
+    const QPointF & p2 = transformedLine[i];
+    const QPointF & t = normalize(p2 - p1);
+    QPointF         n = QPointF(t.y()*distance, -t.x()*distance);
+    multiSegmLine << LineSegment(p1 + n, p2 + n, t);
+  }
+
+
+  transformedLine.clear();
+  transformedLine << multiSegmLine.first().m_p1;
+
+  for (int i = 1; i < multiSegmLine.size(); ++i)
+  {
+    const LineSegment & l1 = multiSegmLine[i - 1];
+    const LineSegment & l2 = multiSegmLine[i];
+
+    const QPointF & dt = l1.m_t - l2.m_t;
+
+    transformedLine << ((qFuzzyIsNull(dt.x()) && qFuzzyIsNull(dt.y())) ? l1.m_p2 : intersection(l1.m_p2, l1.m_t, l2.m_p1, l2.m_t));
+  }
+
+  transformedLine << multiSegmLine.last().m_p2;
+
+  // check result
+  for (int i = 1; i < transformedLine.size(); ++i)
+  {
+    const QPointF & p1 = transformedLine[i - 1];
+    const QPointF & p2 = transformedLine[i];
+
+    if (length(p2 - p1) < distance)
+    {
+      // failure segment is to short relative to distance
+      return QVector<QPointF>();
+    }
+    for (int j = 1; j < transformedLine.size(); ++j)
+    {
+      if (j == i) continue;
+
+      const QPointF & g1 = transformedLine[j-1];
+      const QPointF & g2 = transformedLine[j];
+
+      if (testIntersection(p1, p2, g1, g2))
+      {
+        // failure resulting line has self intersections
+        return QVector<QPointF>();
+      }
+    }
+  }
+
+  QVector<QPointF> pLine;
+
+  // Transform coordinates back to geographic ...
+  pLine.reserve(transformedLine.size());
+  for (auto &p : qAsConst(transformedLine))
+  {
+    pLine << mapCtFunctor->mapToGeographic(p);
+  }
+
+  return pLine;
+}
+// QVector<QPointF> GeometryEngine::parallelTranslation(SituationMap::CoordTranslationFunctor *mapCtFunctor, const QVector<QPointF> &line, double distance)
+
+QVector<Point3D> GeometryEngine::buffer(AbstractMapObject *mapObj, double distance)
+{
+  if (!mapObj)
+    return QVector<Point3D>();
+
+  AbstractMapObjectImpl *mapObjImpl = dynamic_cast<AbstractMapObjectImpl*>(mapObj);
+
+  if (!mapObjImpl)
+    return QVector<Point3D>();
+
+
+  const Esri::ArcGISRuntime::Geometry &esriGeometry = mapObjImpl->getEsriGeometry();
+
+  // Esri::ArcGISRuntime::GeometryEngine::buffer         -> works for 2D
+  // Esri::ArcGISRuntime::GeometryEngine::bufferGeodetic -> works for 2D and 3D!?
+  const Esri::ArcGISRuntime::Polygon polyline = Esri::ArcGISRuntime::GeometryEngine::bufferGeodetic(esriGeometry,
+                                                                                                    distance,
+                                                                                                    Esri::ArcGISRuntime::LinearUnitId::Meters,
+                                                                                                    1,
+                                                                                                    Esri::ArcGISRuntime::GeodeticCurveType::Geodesic);
+  if (polyline.parts().isEmpty())
+      return QVector<Point3D>();
+
+
+  const Esri::ArcGISRuntime::ImmutablePart &immutablePart = polyline.parts().part(0);
+  const int size = immutablePart.pointCount();
+
+  QVector<Point3D> resultVec;
+  resultVec.reserve(size);
+  for (int i = 0; i < size; ++i)
+  {
+    const Esri::ArcGISRuntime::Point &esriP = immutablePart.point(i);
+    resultVec.append(Point3D(esriP.x(), esriP.y(), esriP.z()));
+  }
+
+  //  qCritical() << " resultVec = " << resultVec.size();
+  //  qCritical() << " res = " << polyline.toJson();
+
+  return resultVec;
+}
+
+
+} } // namespace SituationMap::MathUtils
+