Continues migration with DDS, Common

Lts/Common/LtsCoordinate/UnitTest_Coordinate/CMakeLists.txt

@@ -0,0 +1,30 @@
+#
+# @RDE_HEADER@
+# $Id$
+# $HeadURL$
+# $Author$
+#
+
+SET(UnitTestSources
+  lts_coordinate_unit_test.cpp
+  lts_coordinate_unit_test.h
+)
+
+IF(BUILD_TESTING)
+ADD_EXECUTABLE(commonUnitTestCoordinate ${LinkedSources} ${UnitTestSources} )
+
+TARGET_LINK_LIBRARIES(commonUnitTestCoordinate
+    NGLLogger
+    nglcoreapplication
+    LtsCoordinate
+    LtsElevation
+    LtsCoordTrans
+    situationMapCommon
+    situationMapElevationMap
+    Qt5::Core
+    Qt5::Gui
+    Qt5::Test)
+
+ADD_TEST(NAME commonUnitTestCoordinate COMMAND $<TARGET_FILE:commonUnitTestCoordinate>)
+
+ENDIF()

Lts/Common/LtsCoordinate/UnitTest_Coordinate/lts_coordinate_unit_test.cpp

@@ -0,0 +1,971 @@
+
+
+
+#include "lts_coordinate_unit_test.h"
+
+#include <LtsCoordTrans/lts_coord_trans.h>
+#include <LtsCoordinate/lts_coordinate.h>
+#include <LtsCoordinate/lts_coord_vector.h>
+#include <ElevationMap/elevation_map_manager.h>
+
+#include <nglapplication/nglcoreapplication.h>
+#include <NGLLogger/NGLLoggerBootstrap.h>
+#include <QtTest/QTest>
+
+
+Q_DECLARE_METATYPE(LtsUtils::QPoint3D);
+
+
+#include <iostream>
+#include <iomanip>
+
+static const int                          s_id{4711};
+static LtsElevation::LtsElevationManager *s_eleMgr{nullptr};
+
+
+
+
+
+
+
+class MyLtsElevationManagerBootstrap : public LtsElevation::LtsElevationManager
+{
+  using BaseClass = LtsElevation::LtsElevationManager;
+
+public:
+  static LtsElevationManager *createInstanceUnitTest(int id, const QStringList &filePaths_rough_to_fine)
+  {
+    return BaseClass::createInstanceUnitTest(id, filePaths_rough_to_fine);
+  }
+
+};
+
+
+
+
+UnitTestCoordinate::UnitTestCoordinate()
+  : m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("UnitTestCoordinate"))
+{}
+
+
+void UnitTestCoordinate::initTestCase()
+{
+  
+
+  QString filePath(QStringLiteral("/usr/share/arcgis/resources/elevation/Altmark_dt1.tif"));
+
+  s_eleMgr = MyLtsElevationManagerBootstrap::createInstanceUnitTest(s_id, {filePath});
+
+  const bool bIsValid = s_eleMgr->isValid();
+  std::cerr << "myBootstrapMgr->isValid() 1 = " << bIsValid << std::endl;
+
+  
+  {
+    s_eleMgr->waitForInitialization();
+    const bool bIsValid = s_eleMgr->isValid();
+    std::cerr << "myBootstrapMgr->isValid() 2 = " << bIsValid << std::endl;
+  }
+
+  QVERIFY2(s_eleMgr , "static LtsElevationManager does not exist");
+
+  
+  
+  
+  using namespace std::placeholders;
+  LtsCoordTrans::LtsCoordinate::elevationCbFunc elevationCB = std::bind(&LtsElevation::LtsElevationManager::elevation,
+                                                                      s_eleMgr, _1, _2, _3, _4);
+  LtsCoordTrans::LtsCoordinate::setElevationCallback(elevationCB);
+
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::hasElevationCallback() , "setElevationCallback failed");
+}
+
+void UnitTestCoordinate::init()
+{
+  QVERIFY2(s_eleMgr, "static LtsElevationManager does not exist");
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::hasElevationCallback() , "setElevationCallback failed");
+}
+
+void UnitTestCoordinate::test_NaN()
+{
+  bool equal = qFuzzyCompare(std::nan(""), std::nan(""));
+  NOTICE_LOG(m_logger) << " qFuzzyCompare(NaN, NaN) = " << equal;
+
+  
+  QVERIFY2(equal == false, "qFuzzyCompare(NaN, NaN) failed");
+}
+
+void UnitTestCoordinate::test_coordinate_simple1()
+{
+  LtsCoordTrans::LtsCoordinate ltsCoord;
+
+  QVERIFY2(ltsCoord.isValid() == false, "isValid failed");
+
+  const Core::GeoPosition &geoPos = ltsCoord.geoPosition();
+  NOTICE_LOG(m_logger) << " geoPosition = " << geoPos;
+  QVERIFY2(qFuzzyIsNull(geoPos.lon()) , "geoPosition failed");
+  QVERIFY2(qFuzzyIsNull(geoPos.lat()) , "geoPosition failed");
+  QVERIFY2(std::isnan(  geoPos.z()  ) , "geoPosition failed");
+
+  const QPointF &utm                          = ltsCoord.toUtmPointF();
+  const QPointF &utm2                         = ltsCoord.toUtm<QPointF>();
+  const LtsCoordTrans::UtmCoordinate3D &utm3D = ltsCoord.toUtmCoordinate3D();
+  NOTICE_LOG(m_logger) << " utmCoordinateAsPointF = " << utm;
+  NOTICE_LOG(m_logger) << " utmCoordinateAsPointF = " << utm2;
+  NOTICE_LOG(m_logger) << " UtmCoordinate3D       = " << utm3D;
+
+  QVERIFY2(qFuzzyCompare(utm3D.x, 166021.44308053952), "data no equal");
+  QVERIFY2(qFuzzyCompare(utm3D.y, 0.0               ), "data no equal");
+  QVERIFY2(              utm3D.zone == 31            , "data no equal"); 
+  QVERIFY2(utm == utm2 , "data no equal");
+
+  const Core::GeoPosition &geoPos2 = ltsCoord.geoPosition();
+  NOTICE_LOG(m_logger) << " geoPosition2 = " << geoPos2;
+  QVERIFY2(qFuzzyIsNull(geoPos2.lon()) , "geoPosition2 failed");
+  QVERIFY2(qFuzzyIsNull(geoPos2.lat()) , "geoPosition2 failed");
+  QVERIFY2(std::isnan(  geoPos2.z()  ) , "geoPosition2 failed");
+}
+
+void UnitTestCoordinate::test_coordinate_simple2()
+{
+  Core::GeoPosition defaultGeoPos;
+  LtsCoordTrans::LtsCoordinate ltsCoord(defaultGeoPos);
+
+  QVERIFY2(ltsCoord.isValid() == false, "isValid failed");
+
+  const Core::GeoPosition &geoPos = ltsCoord.geoPosition();
+  NOTICE_LOG(m_logger) << " geoPosition = " << geoPos;
+  QVERIFY2(qFuzzyIsNull(geoPos.lon()) , "geoPosition failed");
+  QVERIFY2(qFuzzyIsNull(geoPos.lat()) , "geoPosition failed");
+  QVERIFY2(qFuzzyIsNull(geoPos.z()  ) , "geoPosition failed");
+
+  const QPointF &utm = ltsCoord.toUtm<QPointF>();
+  NOTICE_LOG(m_logger) << " utmCoordinateAsPointF = " << utm;
+
+  
+  const Core::GeoPosition &geoPos2 = ltsCoord.geoPosition();
+  NOTICE_LOG(m_logger) << " geoPosition2 = " << geoPos2;
+  QVERIFY2(qFuzzyIsNull(geoPos2.lon()) , "geoPosition2 failed");
+  QVERIFY2(qFuzzyIsNull(geoPos2.lat()) , "geoPosition2 failed");
+  QVERIFY2(qFuzzyIsNull(geoPos2.z()  ) , "geoPosition2 failed");
+}
+
+void UnitTestCoordinate::test_coordinate_simple3()
+{
+  static const Core::GeoPosition s_invalidPos(std::nan(""), std::nan(""), std::nan(""));
+
+  
+  LtsCoordTrans::LtsCoordinate ltsCoord(s_invalidPos);
+
+  QVERIFY2(ltsCoord.isValid() == false, "isValid failed");
+
+  const Core::GeoPosition &geoPos = ltsCoord.geoPosition();
+  NOTICE_LOG(m_logger) << " geoPosition = " << geoPos;
+  QVERIFY2(std::isnan(geoPos.lon()) , "geoPosition failed");
+  QVERIFY2(std::isnan(geoPos.lat()) , "geoPosition failed");
+  QVERIFY2(std::isnan(geoPos.z())   , "geoPosition failed");
+
+  const QPointF &utm = ltsCoord.toUtm<QPointF>();
+  NOTICE_LOG(m_logger) << " utmCoordinateAsPointF = " << utm;
+  QVERIFY2(utm.isNull()   , "utm failed");
+}
+
+void UnitTestCoordinate::test_coordinate_simple4()
+{
+  LtsCoordTrans::LtsCoordinate::resetConversionCounter();
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::getConversionCounter() == 0, "getConversionCounter failed");
+
+  const LtsCoordTrans::UtmCoordinate &utmIn = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  const double zValue = 2.3;
+
+  const LtsCoordTrans::LtsCoordinate ltsCoord(utmIn.geographic(), zValue); 
+
+  
+
+  const LtsCoordTrans::UtmCoordinate &utmCoord_FirstTry = ltsCoord.utmCoordinate();
+  Q_UNUSED(utmCoord_FirstTry);
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::getConversionCounter() == 1, "getConversionCounter failed");
+
+  const LtsCoordTrans::UtmCoordinate &utmCoord_SecondTry = ltsCoord.utmCoordinate();
+  Q_UNUSED(utmCoord_SecondTry);
+
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::getConversionCounter() == 1, "getConversionCounter failed");
+}
+
+
+
+void UnitTestCoordinate::test_coordinate_fromUtm()
+{
+  const LtsCoordTrans::UtmCoordinate &utmIn = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  const double zValue = 2.3;
+  NOTICE_LOG(m_logger) << " utmIn    = " << utmIn;
+
+  
+  LtsCoordTrans::LtsCoordinate ltsCoord(utmIn.geographic(), zValue); 
+
+  const LtsCoordTrans::UtmCoordinate &utmCoord = ltsCoord.utmCoordinate();
+  NOTICE_LOG(m_logger) << " utmCoord = " << utmCoord;
+  NOTICE_LOG(m_logger) << " utmCoord = " << utmCoord.mgrs();
+  QVERIFY2(utmCoord.mgrs() == QStringLiteral("32U PD 70000 10000") , "utmCoordinate failed");
+
+  
+  const Core::GeoPosition &geoPos = ltsCoord.geoPosition();
+  NOTICE_LOG(m_logger) << " geoPosition = " << geoPos;
+
+  QVERIFY2(qFuzzyCompare(geoPos.lon(), 0.200706392814992), "geoPosition failed");
+  QVERIFY2(qFuzzyCompare(geoPos.lat(), 0.914792952478694), "geoPosition failed");
+  QVERIFY2(qFuzzyCompare(geoPos.z()  , zValue  )         , "geoPosition failed");
+
+  
+  const QPointF &utmP2D = ltsCoord.toUtm<QPointF>();
+  NOTICE_LOG(m_logger) << " utmP2D = " << utmP2D;
+  QVERIFY2(qFuzzyCompare(utmP2D.x(),  670000.5), "utm1 failed");
+  QVERIFY2(qFuzzyCompare(utmP2D.y(), 5810000.5), "utm2 failed");
+
+  const LtsUtils::QPoint3D &utmP3D = ltsCoord.toUtm<LtsUtils::QPoint3D>();
+  NOTICE_LOG(m_logger) << " utmP3D = " << utmP3D;
+  QVERIFY2(qFuzzyCompare(utmP3D.x(),  670000.5), "utm1 failed");
+  QVERIFY2(qFuzzyCompare(utmP3D.y(), 5810000.5), "utm2 failed");
+  QVERIFY2(qFuzzyCompare(utmP3D.z()  , zValue ), "utm3 failed");
+
+  const LtsCoordTrans::UtmCoordinate3D &utmCoord3D = ltsCoord.toUtmCoordinate3D();
+  NOTICE_LOG(m_logger) << " UtmCoordinate3D = " << utmCoord3D;
+  QVERIFY2(qFuzzyCompare(utmCoord3D.x,  670000.5), "utmCoord3D failed");
+  QVERIFY2(qFuzzyCompare(utmCoord3D.y, 5810000.5), "utmCoord3D failed");
+  QVERIFY2(qFuzzyCompare(utmCoord3D.z(), zValue ), "utmCoord3D failed");
+
+  
+  const LtsCoordTrans::UtmCoordinate &utmCoord2D = utmCoord3D;
+  NOTICE_LOG(m_logger) << " utmCoord2D = " << utmCoord2D;
+  QVERIFY2(qFuzzyCompare(utmCoord2D.x,  670000.5), "utmCoord2D failed");
+  QVERIFY2(qFuzzyCompare(utmCoord2D.y, 5810000.5), "utmCoord2D failed");
+
+  
+  const LtsCoordTrans::UtmCoordinate &utm = ltsCoord.utmCoordinate();
+  QVERIFY2(utm.mgrs() == QStringLiteral("32U PD 70000 10000") , "utmCoordinate failed");
+}
+
+void UnitTestCoordinate::test_coordinate_fromUtm2()
+{
+  const LtsCoordTrans::UtmCoordinate &utmInZone32 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U LA 10000 00000"));
+  const double zValue = 2.3;
+  NOTICE_LOG(m_logger) << " utmInZone32    = " << utmInZone32;
+
+  const QPointF &utmInDefQPointF = utmInZone32.geographic();
+
+  const int zone31 = 31;
+  const LtsCoordTrans::UtmCoordinate &utmInZone31 = LtsCoordTrans::UtmCoordinate::fromGeographic(utmInDefQPointF, zone31);
+  NOTICE_LOG(m_logger) << " utmInZone31    = " << utmInZone31;
+
+  NOTICE_LOG(m_logger) << " utmInZone31.geographic()    = " << utmInZone31.geographic();
+  NOTICE_LOG(m_logger) << " utmInZone32.geographic()    = " << utmInZone32.geographic();
+
+  QVERIFY2(utmInZone31.geographic() == utmInZone32.geographic(), "geographic failed");
+
+  {
+    
+    LtsCoordTrans::LtsCoordinate ltsFromUtm31(utmInZone31.geographic(), zValue); 
+    LtsCoordTrans::LtsCoordinate ltsFromUtm32(utmInZone32.geographic(), zValue); 
+
+    double dist = ltsFromUtm31.distanceUtm3D(ltsFromUtm32);
+    NOTICE_LOG(m_logger) << " dist1    = " << dist;
+    QVERIFY2(qFuzzyCompare(dist, 0), "distance3D");
+  }
+  {
+    
+    LtsCoordTrans::LtsCoordinate ltsFromUtm31(utmInZone31.geographic()    , zValue); 
+    LtsCoordTrans::LtsCoordinate ltsFromUtm32(utmInZone32.geographic(1, 0), zValue); 
+
+    double dist = ltsFromUtm31.distanceUtm3D(ltsFromUtm32);
+    NOTICE_LOG(m_logger) << " dist2    = " << dist;
+    QVERIFY2(fabs(dist-1) < 0.00001, "distance3D"); 
+  }
+
+  {
+    
+    
+    
+    LtsCoordTrans::LtsCoordinate ltsFromUtm31 = LtsCoordTrans::LtsCoordinate::fromUtmCoordinate(utmInZone31, zValue); 
+    LtsCoordTrans::LtsCoordinate ltsFromUtm32 = LtsCoordTrans::LtsCoordinate::fromUtmCoordinate(utmInZone32, zValue); 
+
+    double dist = ltsFromUtm31.distanceUtm3D(ltsFromUtm32);
+    NOTICE_LOG(m_logger) << " dist3    = " << dist;
+    QVERIFY2(qFuzzyCompare(dist, 0), "distance3D");
+  }
+
+  {
+    LtsCoordTrans::LtsCoordinate ltsFromUtm32(utmInZone32.geographic(), zValue); 
+
+    const QPointF &utmP2D_def = ltsFromUtm32.toUtm<QPointF>();
+    const QPointF &utmP2D_31  = ltsFromUtm32.toUtm<QPointF>(31);
+    NOTICE_LOG(m_logger) << " utmP2D_def    = " << utmP2D_def;
+    NOTICE_LOG(m_logger) << " utmP2D_31     = " << utmP2D_31;
+
+    LtsCoordTrans::LtsCoordinate lts1 = LtsCoordTrans::LtsCoordinate::fromUtm(utmP2D_def, 32, 0.0);
+    LtsCoordTrans::LtsCoordinate lts2 = LtsCoordTrans::LtsCoordinate::fromUtm(utmP2D_31, 31, 0.0);
+    NOTICE_LOG(m_logger) << " lts1    = " << lts1;
+    NOTICE_LOG(m_logger) << " lts2    = " << lts2;
+
+    double dist = lts1.distanceUtm3D(lts2);
+    NOTICE_LOG(m_logger) << " dist4    = " << dist;
+    QVERIFY2(qFuzzyCompare(dist, 0), "distance3D");
+  }
+}
+
+
+void UnitTestCoordinate::test_coordinate_elevationAt()
+{
+  const double zValue = 1.23;
+
+  const LtsCoordTrans::UtmCoordinate &utmIn = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  NOTICE_LOG(m_logger) << " utmIn    = " << utmIn;
+
+  LtsCoordTrans::LtsCoordinate ltsFromUtm(utmIn.geographic(), zValue); 
+  NOTICE_LOG(m_logger) << " ltsFromUtm1    = " << ltsFromUtm;
+  QVERIFY2(qFuzzyCompare(ltsFromUtm.geoPosition().z(), zValue)           , "geoPosition failed");
+
+  
+  const double ele = ltsFromUtm.elevationAt();
+  QVERIFY2(qFuzzyCompare(ele, 75), "elevationAt failed");
+
+  NOTICE_LOG(m_logger) << " ltsFromUtm2    = " << ltsFromUtm;
+  QVERIFY2(qFuzzyCompare(ltsFromUtm.geoPosition().z(), zValue)           , "geoPosition failed");
+
+  
+  ltsFromUtm.setZValueAccordingElevation();
+  NOTICE_LOG(m_logger) << " ltsFromUtm3    = " << ltsFromUtm;
+  QVERIFY2(qFuzzyCompare(ltsFromUtm.geoPosition().z(), 75)           , "setZValueAccordingElevation failed");
+
+  
+  const LtsUtils::QPoint3D &utmP3D = ltsFromUtm.toUtm<LtsUtils::QPoint3D>();
+  NOTICE_LOG(m_logger) << " utmP3D_a = " << utmP3D;
+  QVERIFY2(qFuzzyCompare(utmP3D.z(), 75  )         , "utmCoordinateAsPoint3D failed");
+
+  {
+    
+    const double ele3 = LtsCoordTrans::LtsCoordinate::elevationAt(ltsFromUtm);
+    NOTICE_LOG(m_logger) << " ele3    = " << ele3;
+    
+    QVERIFY2(qFuzzyCompare(ele, ele3  ), "LtsCoordinate::elevationAt failed");
+  }
+
+  
+  
+  
+  
+  
+  LtsCoordTrans::UtmCoordinate utmMoved = ltsFromUtm.utmCoordinate();
+  utmMoved.x += 11;
+  utmMoved.y += 22;
+  const int zValueNew = 123;
+  ltsFromUtm = LtsCoordTrans::LtsCoordinate(utmMoved.geographic(), zValueNew);
+  NOTICE_LOG(m_logger) << " ltsFromUtm4    = " << ltsFromUtm;
+
+  
+  const double ele2 = ltsFromUtm.elevationAt();
+  NOTICE_LOG(m_logger) << " ltsFromUtm5    = " << ltsFromUtm;
+  QVERIFY2(ele2 != 75 , "setZValueAccordingElevation failed");
+}
+
+void UnitTestCoordinate::test_coordinate_elevationAt_isCovered()
+{
+  const LtsCoordTrans::UtmCoordinate &utmIn1 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  const LtsCoordTrans::UtmCoordinate &utmIn2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U MD 10000 10000"));
+
+  LtsCoordTrans::LtsCoordinate ltsFromUtm1(utmIn1.geographic(), 11); 
+  LtsCoordTrans::LtsCoordinate ltsFromUtm2(utmIn2.geographic(), 11); 
+
+  {
+    bool bIsCovered = false;
+    double ele = ltsFromUtm1.elevationAt(-123, &bIsCovered);
+    Q_UNUSED(ele);
+    QVERIFY2(bIsCovered == true , "elevationAt1a failed");
+
+    
+    bIsCovered = false;
+    ele = ltsFromUtm1.elevationAt(-123, &bIsCovered);
+    Q_UNUSED(ele);
+    QVERIFY2(bIsCovered == true , "elevationAt1b failed");
+
+
+    
+    bIsCovered = false;
+    ele = LtsCoordTrans::LtsCoordinate::elevationAt(ltsFromUtm1, -123, &bIsCovered);
+    Q_UNUSED(ele);
+    QVERIFY2(bIsCovered == true , "elevationAt2a failed");
+
+    
+    bIsCovered = false;
+    ele = LtsCoordTrans::LtsCoordinate::elevationAt(ltsFromUtm1, -123, &bIsCovered);
+    Q_UNUSED(ele);
+    QVERIFY2(bIsCovered == true , "elevationAt2b failed");
+  }
+
+  {
+    bool bIsCovered = true;
+    double ele = ltsFromUtm2.elevationAt(-123, &bIsCovered);
+    Q_UNUSED(ele);
+    QVERIFY2(bIsCovered == false , "elevationAt2 failed");
+
+    
+    bIsCovered = true;
+    ele = LtsCoordTrans::LtsCoordinate::elevationAt(ltsFromUtm2, -123, &bIsCovered);
+    Q_UNUSED(ele);
+    QVERIFY2(bIsCovered == false , "elevationAt1 failed");
+  }
+}
+
+void UnitTestCoordinate::test_coordinate_elevation_data()
+{
+  QTest::addColumn<QString>("mgrs");
+  QTest::addColumn<double>("elevationIn");
+  QTest::addColumn<double>("elevationRef");
+
+  
+  QTest::newRow("elevation 10 ") << QStringLiteral("32 U PD 70000 10000") << std::nan("") << 75.0;
+  QTest::newRow("elevation 11 ") << QStringLiteral("32 U PD 70000 10000") << 0.0          << 75.0;
+  QTest::newRow("elevation 20 ") << QStringLiteral("32 U PD 72000 13000") << std::nan("") << 80.0;
+  QTest::newRow("elevation 21 ") << QStringLiteral("32 U PD 72000 13000") << 0.340        << 80.0;
+}
+void UnitTestCoordinate::test_coordinate_elevation()
+{
+  QFETCH(QString, mgrs);
+  QFETCH(double,  elevationIn);
+  QFETCH(double,  elevationRef);
+
+  const LtsCoordTrans::UtmCoordinate &utmIn = LtsCoordTrans::UtmCoordinate::fromMgrs(mgrs);
+  NOTICE_LOG(m_logger) << " utmIn    = " << utmIn;
+
+  LtsCoordTrans::LtsCoordinate ltsFromUtm(utmIn.geographic(), elevationIn); 
+  NOTICE_LOG(m_logger) << " ltsFromUtm    = " << ltsFromUtm;
+
+  
+  NOTICE_LOG(m_logger) << " geoPosition = " << ltsFromUtm.geoPosition();
+  ltsFromUtm.replaceZValueByElevationIfValue(elevationIn);
+
+  
+  NOTICE_LOG(m_logger) << " geoPosition = " << ltsFromUtm.geoPosition();
+  QVERIFY2(qFuzzyCompare(ltsFromUtm.geoPosition().z(), elevationRef), "elevation failed");
+
+  
+  const LtsUtils::QPoint3D &utmP3D = ltsFromUtm.toUtm<LtsUtils::QPoint3D>();
+  NOTICE_LOG(m_logger) << " utmP3D = " << utmP3D;
+  QVERIFY2(qFuzzyCompare(utmP3D.z(), elevationRef)         , "utmCoordinateAsPoint3D failed");
+}
+
+void UnitTestCoordinate::test_coordinate_mgrs()
+{
+  const LtsCoordTrans::UtmCoordinate &utmIn = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  NOTICE_LOG(m_logger) << " utmIn    = " << utmIn.mgrs();
+
+  LtsCoordTrans::LtsCoordinate ltsFromUtm(utmIn.geographic());
+
+  {
+    const QString asMgrs = ltsFromUtm.mgrs();
+    NOTICE_LOG(m_logger) << " asMgrs   = " << asMgrs;
+    QVERIFY2(asMgrs.compare(QStringLiteral("32U PD 70000 10000")) == 0, "UtmCoordinate::mgrs failed");
+  }
+  {
+    const QString asMgrs = ltsFromUtm.mgrsWithZ();
+    NOTICE_LOG(m_logger) << " asMgrs   = " << asMgrs;
+    QVERIFY2(asMgrs.compare(QStringLiteral("32U PD 70000 10000 z=75.00")) == 0, "UtmCoordinate::mgrs failed");
+  }
+
+  {
+    const LtsCoordTrans::LtsCoordinate coord(0.200706392814992, 0.914792952478694, 123);
+    
+    
+    const QString str1 = coord.toString();
+    NOTICE_LOG(m_logger) << " str1 cheap     = " << str1;
+    QVERIFY2(str1.compare(QStringLiteral("LtsCoordinate(m_geo=[[lon: 0.200706392814992, lat: 0.914792952478694]z: 123], m_utm2D.x 0, m_utm2D.y 0, m_utm2D.zone -1, elevation nan)")) == 0, "toString failed");
+
+    
+    
+    
+    
+    const bool fullAndExpensive = true;
+    const QString str2 = coord.toString(fullAndExpensive);
+    NOTICE_LOG(m_logger) << " str2 expensive = " << str2;
+    QVERIFY2(str2.compare(QStringLiteral("LtsCoordinate(m_geo=[[lon: 0.200706392814992, lat: 0.914792952478694]z: 123], m_utm2D.x 670000.499999998, m_utm2D.y 5810000.5, m_utm2D.zone 32, m_utm2D.mgrs '32U PD 70000 10000', elevation 75.000)")) == 0, "toString failed");
+  }
+
+}
+
+void UnitTestCoordinate::test_coordinate_distance()
+{
+  const LtsCoordTrans::UtmCoordinate &utmIn1 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  const LtsCoordTrans::UtmCoordinate &utmIn2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70010 10100"));
+  NOTICE_LOG(m_logger) << " XXutmIn1    = " << utmIn1;
+  NOTICE_LOG(m_logger) << " XXutmIn2    = " << utmIn2;
+
+  QVERIFY2(qFuzzyCompare((utmIn2.x - utmIn1.x),  10)  , "coord failed");
+  QVERIFY2(qFuzzyCompare((utmIn2.y - utmIn1.y), 100)  , "coord failed");
+
+  const LtsCoordTrans::LtsCoordinate lts1(utmIn1.geographic(),  11); 
+  const LtsCoordTrans::LtsCoordinate lts2(utmIn2.geographic(), 111); 
+
+  {
+    double dist2D = lts1.distanceUtm2D(lts2);
+    NOTICE_LOG(m_logger) << " dist2D    = " << dist2D;
+    QVERIFY2(std::fabs(dist2D-100.499) < 0.01, "distanceUtm2D failed");
+  }
+
+  {
+    double dist3D = lts1.distanceUtm3D(lts2);
+    NOTICE_LOG(m_logger) << " dist3D    = " << dist3D;
+    QVERIFY2(std::fabs(dist3D-141.774) < 0.01, "distanceUtm3D failed");
+  }
+}
+
+
+void UnitTestCoordinate::test_coordinate_distanceDiffZones()
+{
+  const LtsCoordTrans::UtmCoordinate &utmIn1 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("31 U FR 99999 00000"));
+  const LtsCoordTrans::UtmCoordinate &utmIn2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U LA 00000 00000"));
+  NOTICE_LOG(m_logger) << " XXutmIn1    = " << utmIn1;
+  NOTICE_LOG(m_logger) << " XXutmIn2    = " << utmIn2;
+
+  
+  
+  LtsCoordTrans::LtsCoordinate lts1(utmIn1.geographic(), 0);
+  LtsCoordTrans::LtsCoordinate lts2(utmIn2.geographic(), 0);
+  NOTICE_LOG(m_logger) << " lts1    = " << lts1;
+  NOTICE_LOG(m_logger) << " lts2    = " << lts2;
+
+  double dist = lts1.distanceUtm3D(lts2);
+
+  NOTICE_LOG(m_logger) << " dist    = " << dist;
+  QVERIFY2(std::fabs(dist-33382.7) < 0.1, "distance3D failed");
+}
+
+void UnitTestCoordinate::test_squareInDifferentZone()
+{
+  const LtsCoordTrans::UtmCoordinate &utm_bl = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  const LtsCoordTrans::UtmCoordinate &utm_br = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 11000"));
+  const LtsCoordTrans::UtmCoordinate &utm_tl = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 71000 10000"));
+  const LtsCoordTrans::UtmCoordinate &utm_tr = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 71000 11000"));
+
+  const LtsCoordTrans::LtsCoordinate lts_bl(utm_bl.geographic(), 0);
+  const LtsCoordTrans::LtsCoordinate lts_br(utm_br.geographic(), 0);
+  const LtsCoordTrans::LtsCoordinate lts_tl(utm_tl.geographic(), 0);
+  const LtsCoordTrans::LtsCoordinate lts_tr(utm_tr.geographic(), 0);
+
+  {
+    
+    QVERIFY2(qFuzzyCompare(lts_bl.distanceUtm2D(lts_br), 1000.0), "distance3D 1 failed");
+    QVERIFY2(qFuzzyCompare(lts_tl.distanceUtm2D(lts_tr), 1000.0), "distance3D 2 failed");
+    QVERIFY2(qFuzzyCompare(lts_br.distanceUtm2D(lts_tr), 1000.0), "distance3D 3 failed");
+    QVERIFY2(qFuzzyCompare(lts_bl.distanceUtm2D(lts_tl), 1000.0), "distance3D 4 failed");
+    
+    QVERIFY2(qFuzzyCompare(lts_bl.distanceUtm2D(lts_tr), 1414.213562373177), "distance3D 5 failed");
+    QVERIFY2(qFuzzyCompare(lts_br.distanceUtm2D(lts_tl), 1414.213562373177), "distance3D 6 failed");
+  }
+
+  
+  
+  {
+    const LtsCoordTrans::UtmCoordinate &utm31_bl = LtsCoordTrans::UtmCoordinate(31, utm_bl.x, utm_bl.y);
+    const LtsCoordTrans::UtmCoordinate &utm31_br = LtsCoordTrans::UtmCoordinate(31, utm_br.x, utm_br.y);
+    const LtsCoordTrans::UtmCoordinate &utm31_tl = LtsCoordTrans::UtmCoordinate(31, utm_tl.x, utm_tl.y);
+    const LtsCoordTrans::UtmCoordinate &utm31_tr = LtsCoordTrans::UtmCoordinate(31, utm_tr.x, utm_tr.y);
+
+    
+    QVERIFY2(qFuzzyCompare(LtsCoordTrans::distance(utm31_bl, utm31_br), 1000.0), "LtsCoordTrans::distance 1 failed");
+    QVERIFY2(qFuzzyCompare(LtsCoordTrans::distance(utm31_tl, utm31_tr), 1000.0), "LtsCoordTrans::distance 2 failed");
+    QVERIFY2(qFuzzyCompare(LtsCoordTrans::distance(utm31_br, utm31_tr), 1000.0), "LtsCoordTrans::distance 3 failed");
+    QVERIFY2(qFuzzyCompare(LtsCoordTrans::distance(utm31_bl, utm31_tl), 1000.0), "LtsCoordTrans::distance 4 failed");
+    
+    QVERIFY2(qFuzzyCompare(LtsCoordTrans::distance(utm31_bl, utm31_tr), 1414.213562373095), "LtsCoordTrans::distance 5 failed");
+    QVERIFY2(qFuzzyCompare(LtsCoordTrans::distance(utm31_br, utm31_tl), 1414.213562373095), "LtsCoordTrans::distance 6 failed");
+  }
+
+  
+  
+  
+  
+  
+  
+  
+}
+
+void UnitTestCoordinate::test_coordinate_angle()
+{
+  
+  
+  const LtsCoordTrans::UtmCoordinate &utm_ul = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  const LtsCoordTrans::LtsCoordinate lts_ul(utm_ul.geographic(), 0);
+
+  {
+    
+    const LtsCoordTrans::UtmCoordinate &utm_2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 11000"));
+    const LtsCoordTrans::LtsCoordinate lts_2(utm_2.geographic(), 0);
+    double angle = LtsCoordTrans::LtsCoordinate::angleDegreeUtm2D(lts_ul, lts_2);
+    QVERIFY2(qFuzzyCompare(angle, 0.0), "angleUtm2D 1 failed");
+  }
+
+  {
+    
+    const LtsCoordTrans::UtmCoordinate &utm_2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 71000 10000"));
+    const LtsCoordTrans::LtsCoordinate lts_2(utm_2.geographic(), 0);
+    double angle = LtsCoordTrans::LtsCoordinate::angleDegreeUtm2D(lts_ul, lts_2);
+    QVERIFY2(qFuzzyCompare(angle, 90.0), "angleUtm2D 1 failed");
+  }
+
+  {
+    
+    const LtsCoordTrans::UtmCoordinate &utm_2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 09000"));
+    const LtsCoordTrans::LtsCoordinate lts_2(utm_2.geographic(), 0);
+    double angle = LtsCoordTrans::LtsCoordinate::angleDegreeUtm2D(lts_ul, lts_2);
+    QVERIFY2(qFuzzyCompare(angle, 180.0), "angleUtm2D 1 failed");
+  }
+
+  {
+    
+    const LtsCoordTrans::UtmCoordinate &utm_2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 69000 10000"));
+    const LtsCoordTrans::LtsCoordinate lts_2(utm_2.geographic(), 0);
+    double angle = LtsCoordTrans::LtsCoordinate::angleDegreeUtm2D(lts_ul, lts_2);
+    QVERIFY2(qFuzzyCompare(angle, 270.0), "angleUtm2D 1 failed");
+  }
+
+  
+  {
+     const LtsCoordTrans::UtmCoordinate &utm_or = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 71000 12000"));
+     const LtsCoordTrans::LtsCoordinate lts_or(utm_or.geographic(), 0);
+     double angle = LtsCoordTrans::LtsCoordinate::angleDegreeUtm2D(lts_ul, lts_or);
+     
+     QVERIFY2(qFuzzyCompare(angle, 26.565051177056659526), "angleUtm2D 1 failed");
+     QVERIFY2((angle-26.5651 < 0.001), "angleUtm2D 1 failed");
+   }
+}
+
+void UnitTestCoordinate::test_coordinate_cont()
+{
+  std::vector<Core::GeoPosition> stdVec;
+  stdVec.push_back(Core::GeoPosition(0.1, 0.11, 1));
+  stdVec.push_back(Core::GeoPosition(0.2, 0.22, 2));
+  stdVec.push_back(Core::GeoPosition(0.3, 0.33, 3));
+
+  const QVector<LtsCoordTrans::LtsCoordinate> &newCont = LtsCoordTrans::convert<QVector<LtsCoordTrans::LtsCoordinate>>(stdVec);
+
+  NOTICE_LOG(m_logger) << " newCont.size()    = " << newCont.size();
+  QVERIFY2(stdVec.size() == static_cast<size_t>(newCont.size()), "convert failed");
+}
+
+using namespace LtsCoordTrans;
+class ParticpantPositionStore
+{
+public:
+  ParticpantPositionStore() = default;
+  ~ParticpantPositionStore() = default;
+
+  void setGeoPosition(const Core::GeoPosition &newGeoPos)
+  {
+    m_ltsCoord                = LtsCoordinate(newGeoPos);
+    m_ltsCoord_NoImplicitCopy.updateGeoPosition(newGeoPos);
+  }
+
+  
+  
+  
+  
+  LtsCoordinate getLtsCoord_copy()
+  {
+    return m_ltsCoord;
+  }
+
+  
+  
+  const LtsCoordinateNoImplicitCopy& getLtsCoord_noCopy() 
+  {
+    return m_ltsCoord_NoImplicitCopy;
+  }
+
+  
+  
+  
+  
+  
+
+
+
+  LtsCoordinate               m_ltsCoord;
+  LtsCoordinateNoImplicitCopy m_ltsCoord_NoImplicitCopy;
+};
+
+
+void UnitTestCoordinate::test_coordinate_avoid_copy()
+{
+  LtsCoordTrans::LtsCoordinate::resetConversionCounter();
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::getConversionCounter() == 0, "getConversionCounter failed");
+
+  ParticpantPositionStore store;
+
+  
+  
+  
+  const UtmCoordinate &utmIn = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U PD 70000 10000"));
+  const LtsCoordinate ltsIn(utmIn.geographic(), 11);
+
+  store.getLtsCoord_noCopy().updateGeoPosition(ltsIn.geoPosition());
+
+  
+  
+  
+  
+  
+  const LtsCoordinateNoImplicitCopy &justReference = store.getLtsCoord_noCopy();
+  NOTICE_LOG(m_logger) << " justReference = " << justReference.mgrs(); 
+
+  const LtsCoordTrans::UtmCoordinate &convertedToUtm = justReference.utmCoordinate();
+  NOTICE_LOG(m_logger) << " convertedToUtm    = " << convertedToUtm;
+  QVERIFY2(qFuzzyCompare(convertedToUtm.x, 670000.5 ), "convert failed");
+  QVERIFY2(qFuzzyCompare(convertedToUtm.y, 5810000.5), "convert failed");
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::getConversionCounter() == 1, "getConversionCounter failed");
+
+
+  
+  
+  
+  const LtsCoordTrans::UtmCoordinate &convertedToUtmSecondTry = justReference.utmCoordinate();
+  Q_UNUSED(convertedToUtmSecondTry)
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::getConversionCounter() == 1, "getConversionCounter failed");
+
+  
+  std::vector<LtsCoordinateNoImplicitCopy> myVec;
+  myVec.push_back(justReference);
+
+  
+  const LtsCoordTrans::LtsCoordinateNoImplicitCopy &retrievedUtmRef = myVec.front();
+  NOTICE_LOG(m_logger) << " retrievedUtm = " << retrievedUtmRef.mgrs(); 
+
+  
+  QVERIFY2(justReference.mgrs() == retrievedUtmRef.mgrs(), "getConversionCounter failed");
+
+  
+  
+
+  
+  QVERIFY2(LtsCoordTrans::LtsCoordinate::getConversionCounter() == 1, "getConversionCounter failed");
+
+
+  
+  
+  
+}
+
+
+
+
+template <typename T>
+void removeItem(T& map, int key) {  map.erase(key);   }
+
+
+template <>
+void removeItem(QMap<int, int>& map, int key) {  map.remove(key);   }
+
+
+template <>
+void removeItem(QHash<int, int>& map, int key) {  map.remove(key);   }
+
+
+template <typename T>
+void test_references(T& map)
+{
+  for (int i=2; i<10; ++i)
+    map[i] = i;
+
+  const int &ref2 = map[2];
+  const int &ref3 = map[3];
+  const int &ref4 = map[4];
+  const int &ref5 = map[5];
+  const int &ref6 = map[6];
+  const int &ref7 = map[7];
+  const int &ref8 = map[8];
+
+  QVERIFY2(ref2 == 2, "ref failed");
+  QVERIFY2(ref3 == 3, "ref failed");
+  QVERIFY2(ref4 == 4, "ref failed");
+  QVERIFY2(ref5 == 5, "ref failed");
+  QVERIFY2(ref6 == 6, "ref failed");
+  QVERIFY2(ref7 == 7, "ref failed");
+  QVERIFY2(ref8 == 8, "ref failed");
+
+  
+  removeItem(map, 1);
+  removeItem(map, 3);
+  removeItem(map, 5);
+
+  {
+    QVERIFY2(ref2 == 2, "ref failed");
+    
+    QVERIFY2(ref4 == 4, "ref failed");
+    
+    QVERIFY2(ref6 == 6, "ref failed");
+    QVERIFY2(ref7 == 7, "ref failed");
+    QVERIFY2(ref8 == 8, "ref failed");
+  }
+
+  
+  map[0] = 0;
+  map[1] = 1;
+  const int &ref0 = map[0];
+  const int &ref1 = map[1];
+
+  {
+    QVERIFY2(ref0 == 0, "ref failed");
+    QVERIFY2(ref1 == 1, "ref failed");
+    
+    QVERIFY2(ref2 == 2, "ref failed");
+    
+    QVERIFY2(ref4 == 4, "ref failed");
+    
+    QVERIFY2(ref6 == 6, "ref failed");
+    QVERIFY2(ref7 == 7, "ref failed");
+    QVERIFY2(ref8 == 8, "ref failed");
+  }
+
+}
+
+void UnitTestCoordinate::test_container_references()
+{
+  
+  
+  
+  
+  
+  
+
+  
+  
+  {
+    std::unordered_map<int, int> std_unordered_map;
+    test_references(std_unordered_map);
+  }
+  {
+    std::map<int, int> std_map;
+    test_references(std_map);
+  }
+  {
+    QMap<int, int> Qmap;
+    test_references(Qmap);
+  }
+  {
+    QHash<int, int> Qhash;
+    test_references(Qhash);
+  }
+}
+
+
+
+
+
+void UnitTestCoordinate::test_coordVector()
+{
+  std::vector<Core::GeoPosition> geoVec;
+
+  {
+    
+    QPointF utmPnt = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U LB 00001 50001")).geographic();
+    geoVec.push_back( Core::GeoPosition(utmPnt.x(), utmPnt.y(), 1.1) );
+
+    utmPnt = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U LB 00001 50001")).geographic(1, 0);
+    geoVec.push_back( Core::GeoPosition(utmPnt.x(), utmPnt.y(), 2.2) );
+
+    utmPnt = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32 U LB 00001 50001")).geographic(2, 0);
+    geoVec.push_back( Core::GeoPosition(utmPnt.x(), utmPnt.y(), 3.3) );
+  }
+
+  const LtsCoordVector coordVec(geoVec);
+  QVERIFY2(coordVec.size() == 3, "size failed");
+
+  int cnt = LtsCoordTrans::getConversionCounter_UTMUPS_Forward();
+
+  { 
+    const std::vector<LtsCoordTrans::UtmCoordinate> &utmVec = coordVec.toStdUtmCoord(32);
+
+
+
+
+
+    QVERIFY2(utmVec.size() == 3, "size failed");
+    QVERIFY2(utmVec.front().mgrs() == QStringLiteral("32U LB 00001 50001"), "mgrs failed");
+    QVERIFY2(utmVec.back().mgrs()  == QStringLiteral("32U LB 00003 50001"), "mgrs failed");
+    QVERIFY2(LtsCoordTrans::getConversionCounter_UTMUPS_Forward() - cnt == 3, "getConversionCounterUTMUPS_Forward failed");
+  }
+  { 
+    const std::vector<LtsCoordTrans::UtmCoordinate> &utmVec = coordVec.toStdUtmCoord(32);
+    QVERIFY2(utmVec.size() == 3, "size failed");
+    QVERIFY2(utmVec.front().mgrs() == QStringLiteral("32U LB 00001 50001"), "mgrs failed");
+    QVERIFY2(utmVec.back().mgrs()  == QStringLiteral("32U LB 00003 50001"), "mgrs failed");
+    QVERIFY2(LtsCoordTrans::getConversionCounter_UTMUPS_Forward() - cnt == 3, "getConversionCounterUTMUPS_Forward failed");
+  }
+
+  { 
+    const std::vector<LtsCoordTrans::UtmCoordinate> &utmVec = coordVec.toStdUtmCoord(31);
+    QVERIFY2(utmVec.size() == 3, "size failed");
+    QVERIFY2(LtsCoordTrans::getConversionCounter_UTMUPS_Forward() - cnt == 6, "getConversionCounterUTMUPS_Forward failed");
+  }
+  { 
+    const std::vector<LtsCoordTrans::UtmCoordinate> &utmVec = coordVec.toStdUtmCoord(31);
+    QVERIFY2(utmVec.size() == 3, "size failed");
+    QVERIFY2(LtsCoordTrans::getConversionCounter_UTMUPS_Forward() - cnt == 6, "getConversionCounterUTMUPS_Forward failed");
+  }
+
+  
+  
+  
+  
+  { 
+    const QVector<LtsCoordTrans::UtmCoordinate> &utmVec = coordVec.toQVectorUtmCoord(32);
+    QVERIFY2(utmVec.size() == 3, "size failed");
+    QVERIFY2(utmVec.front().mgrs() == QStringLiteral("32U LB 00001 50001"), "mgrs failed");
+    QVERIFY2(utmVec.back().mgrs()  == QStringLiteral("32U LB 00003 50001"), "mgrs failed");
+    QVERIFY2(LtsCoordTrans::getConversionCounter_UTMUPS_Forward() - cnt == 6, "getConversionCounterUTMUPS_Forward failed");
+  }
+  { 
+    const QVector<LtsCoordTrans::UtmCoordinate> &utmVec = coordVec.toQVectorUtmCoord(32);
+    QVERIFY2(utmVec.size() == 3, "size failed");
+    QVERIFY2(utmVec.front().mgrs() == QStringLiteral("32U LB 00001 50001"), "mgrs failed");
+    QVERIFY2(utmVec.back().mgrs()  == QStringLiteral("32U LB 00003 50001"), "mgrs failed");
+    QVERIFY2(LtsCoordTrans::getConversionCounter_UTMUPS_Forward() - cnt == 6, "getConversionCounterUTMUPS_Forward failed");
+  }
+
+  
+  
+  
+  
+  { 
+    const QVector<QPointF> &utmVec = coordVec.toQVectorQPointF(32);
+    QVERIFY2(utmVec.size() == 3, "size failed");
+    QVERIFY2(LtsCoordTrans::getConversionCounter_UTMUPS_Forward() - cnt == 6, "getConversionCounterUTMUPS_Forward failed");
+  }
+  { 
+    const QVector<LtsCoordTrans::UtmCoordinate> &utmVec = coordVec.toQVectorUtmCoord(32);
+    QVERIFY2(utmVec.size() == 3, "size failed");
+    QVERIFY2(LtsCoordTrans::getConversionCounter_UTMUPS_Forward() - cnt == 6, "getConversionCounterUTMUPS_Forward failed");
+  }
+
+}
+
+
+
+
+
+int main(int argc, char *argv[])
+{
+  NGLCoreApplication app(argc, argv);
+  app.createLogger("UnitTestCoordinate", "log4cxxPositionUnitTest.props");
+
+  UnitTestCoordinate tc;
+
+  int ret = QTest::qExec(&tc, argc, argv);
+
+  
+  if (s_eleMgr)
+  {
+    s_eleMgr->cleanupAll();
+  }
+
+  return ret;
+}
+
+

Lts/Common/LtsCoordinate/UnitTest_Coordinate/lts_coordinate_unit_test.h

@@ -0,0 +1,80 @@
+
+
+
+#pragma once
+
+#include <LtsElevation/lts_elevation_manager.h>
+
+#include <ElevationMap/elevation_map_manager.h>
+
+#include <QCoreApplication>
+#include <QtTest/QTest>
+#include <NGLLogger/INGLLogger.h>
+
+
+using LOGGER_T = NGL::INGLLogger&;
+
+
+
+
+class UnitTestCoordinate : public QObject
+{
+  Q_OBJECT
+
+public:
+  UnitTestCoordinate();
+
+
+private Q_SLOTS:
+
+  
+  
+  
+
+
+  void initTestCase();          
+
+  void init();                  
+  
+
+
+  void test_NaN();
+
+  void test_coordinate_simple1();
+  void test_coordinate_simple2();
+  void test_coordinate_simple3();
+  void test_coordinate_simple4();
+
+  void test_coordinate_fromUtm();
+  void test_coordinate_fromUtm2();
+
+  void test_coordinate_elevationAt();
+  void test_coordinate_elevationAt_isCovered();
+
+  void test_coordinate_elevation_data();
+  void test_coordinate_elevation();
+
+  void test_coordinate_mgrs();
+
+  void test_coordinate_distance();
+  void test_coordinate_distanceDiffZones();
+
+  void test_squareInDifferentZone();
+
+  void test_coordinate_angle();
+
+  void test_coordinate_cont();
+
+  void test_coordinate_avoid_copy();
+
+
+  
+  void test_container_references();
+  void test_coordVector();
+
+
+  
+
+private:
+  LOGGER_T m_logger;
+};